refactor: extract shared primitives into vite_powershell crate (#368)

## Summary

- New `vite_powershell` crate owns the platform-shared primitives
previously inlined in `vite_task_plan::ps1_shim`: `POWERSHELL_PREFIX`,
`powershell_host()` (LazyLock-cached `pwsh.exe`/`powershell.exe`
lookup), and `find_ps1_sibling()` (case-insensitive `.cmd` → sibling
`.ps1` resolution).
- `vite_task_plan::ps1_shim` keeps its task-specific layers — workspace
+ `node_modules/.bin` scope check, cwd-relative arg conversion,
`Arc<AbsolutePath>` / `Arc<[Str]>` return types — and now imports the
primitives from `vite_powershell`.
- No behavior change. All existing snapshot/unit/integration tests pass.

## Why

vite-plus is adding `vite_command::ps1_shim` (see
voidzero-dev/vite-plus#1489) to fix the same Ctrl+C terminal-corruption
symptom for package-manager-routed commands (`vp dlx`, `vp add`, `vp
update`, etc.). Without this extraction it would have to copy the
constant, the host-discovery LazyLock, and the sibling-`.ps1` check.
With this extraction both task scripts (vite-task) and pm commands (vp)
compose the same primitives with their own scope rules.

The two callers diverge intentionally and don't share enough to merge
into one helper:
- vite-task's wrapper produces `(Arc<AbsolutePath>, Arc<[Str]>)` with
**cwd-relative** `.ps1` paths because the args become part of the task
graph's spawn fingerprint and must stay portable across machines.
- vite-plus's wrapper (in vp's `vite_command`) produces
`(AbsolutePathBuf, Vec<OsString>)` with **absolute** `.ps1` paths
because there's no cache fingerprint at spawn time.

## Test plan

- [x] `cargo test -p vite_powershell` — 5 new tests pass (sibling found,
case-insensitive `.CMD`, no-sibling, non-`.cmd`, no-extension)
- [x] `cargo test -p vite_task_plan` — 39 unit + 45 integration tests
pass; the existing rewrite snapshot tests are preserved
- [x] `cargo clippy -p vite_powershell -p vite_task_plan --all-targets`
— clean
- [x] Companion vp PR to switch `vite_command::ps1_shim` to depend on
`vite_powershell` once this lands and a new vite-task SHA is pinned

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> **Low Risk**
> Mostly a dependency extraction/refactor with tests; behavior should
remain the same aside from potential edge-case differences in
`.cmd`/`.ps1` detection on Windows.
> 
> **Overview**
> Extracts the Windows `.cmd`→`.ps1` PowerShell-shim primitives into a
new `vite_powershell` crate, including the `POWERSHELL_PREFIX` args,
cached `pwsh.exe`/`powershell.exe` host discovery, and sibling-`.ps1`
lookup.
> 
> Updates `vite_task_plan::ps1_shim` to depend on and call these shared
helpers while keeping its workspace/`node_modules/.bin` scoping and
cwd-relative argument rewrite logic, and adds unit tests for the new
crate. Workspace `Cargo.toml`/`Cargo.lock` are updated to include the
new crate and dependency.
> 
> <sup>Reviewed by [Cursor Bugbot](https://cursor.com/bugbot) for commit
1e2b791. Configure
[here](https://www.cursor.com/dashboard/bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

---------

Co-authored-by: branchseer <3612422+branchseer@users.noreply.github.com>

Author: fengmk2

Cargo.lock

@@ -145,6 +145,7 @@ vec1 = "1.12.1"
 vite_glob = { path = "crates/vite_glob" }
 vite_graph_ser = { path = "crates/vite_graph_ser" }
 vite_path = { path = "crates/vite_path" }
+vite_powershell = { path = "crates/vite_powershell" }
 vite_select = { path = "crates/vite_select" }
 vite_shell = { path = "crates/vite_shell" }
 vite_str = { path = "crates/vite_str" }

Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "vite_powershell"
+version = "0.1.0"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+rust-version.workspace = true
+
+[dependencies]
+vite_path = { workspace = true }
+which = { workspace = true }
+
+[dev-dependencies]
+tempfile = { workspace = true }
+
+[lints]
+workspace = true
+
+[lib]
+doctest = false

crates/vite_powershell/Cargo.toml

@@ -0,0 +1,146 @@
+//! Windows-specific helpers for routing `.cmd` invocations through
+//! `PowerShell` so spawning never goes through `cmd.exe`.
+//!
+//! Running a `.cmd` from any shell makes `cmd.exe` prompt "Terminate batch
+//! job (Y/N)?" on Ctrl+C, which leaves the terminal corrupt. Routing
+//! through `PowerShell` against the sibling `.ps1` shim sidesteps the prompt
+//! and lets Ctrl+C propagate cleanly.
+//!
+//! This crate carries only the platform-shared primitives (the
+//! `PowerShell` host lookup, the fixed argument prefix, and the
+//! sibling-`.ps1` discovery). Higher-level wrappers in
+//! `vite_task_plan::ps1_shim` (cwd-relative arg rewrite, scoped to
+//! `node_modules/.bin`) and `vite_command::ps1_shim` (absolute-path
+//! arg rewrite, applied to any `.cmd`) compose these primitives with
+//! their own scope rules and return-type conventions.
+//!
+//! See <https://github.com/voidzero-dev/vite-plus/issues/1176> and
+//! <https://github.com/voidzero-dev/vite-plus/issues/1489>.
+
+use std::sync::Arc;
+
+use vite_path::{AbsolutePath, AbsolutePathBuf};
+
+/// Fixed arguments prepended before the `.ps1` path. `-NoProfile`/`-NoLogo`
+/// skip user profile loading; `-ExecutionPolicy Bypass` allows running the
+/// unsigned shims that npm/pnpm/yarn install.
+pub const POWERSHELL_PREFIX: &[&str] =
+    &["-NoProfile", "-NoLogo", "-ExecutionPolicy", "Bypass", "-File"];
+
+/// Cached location of the `PowerShell` host. Prefers cross-platform
+/// `pwsh.exe` when present, falling back to the Windows built-in
+/// `powershell.exe`. Returns `None` on non-Windows or when neither host
+/// is on `PATH`.
+///
+/// Cached as `Arc<AbsolutePath>` so callers that want shared ownership
+/// (e.g. `vite_task_plan`'s plan-time rewrite) can do `Arc::clone(host)`
+/// without copying the path.
+#[cfg(windows)]
+#[must_use]
+pub fn powershell_host() -> Option<&'static Arc<AbsolutePath>> {
+    use std::sync::LazyLock;
+
+    static POWERSHELL_HOST: LazyLock<Option<Arc<AbsolutePath>>> = LazyLock::new(|| {
+        let resolved = which::which("pwsh.exe").or_else(|_| which::which("powershell.exe")).ok()?;
+        AbsolutePathBuf::new(resolved).map(Arc::<AbsolutePath>::from)
+    });
+    POWERSHELL_HOST.as_ref()
+}
+
+#[cfg(not(windows))]
+#[must_use]
+pub const fn powershell_host() -> Option<&'static Arc<AbsolutePath>> {
+    None
+}
+
+/// Given a resolved `.cmd` path, return its sibling `.ps1` if one exists
+/// on disk. The extension match is case-insensitive (matches `.cmd`,
+/// `.CMD`, `.Cmd`).
+///
+/// Returns `None` when the path is not a `.cmd` or no `.ps1` sibling
+/// exists. Callers that need additional scope checks (e.g. "must live
+/// inside the workspace's `node_modules/.bin`") should layer those on
+/// top of this primitive.
+#[must_use]
+pub fn find_ps1_sibling(resolved: &AbsolutePath) -> Option<AbsolutePathBuf> {
+    let ext = resolved.as_path().extension().and_then(|e| e.to_str())?;
+    if !ext.eq_ignore_ascii_case("cmd") {
+        return None;
+    }
+
+    let ps1 = resolved.with_extension("ps1");
+    if !ps1.as_path().is_file() {
+        return None;
+    }
+
+    Some(ps1)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+
+    use tempfile::tempdir;
+
+    use super::*;
+
+    #[expect(clippy::disallowed_types, reason = "tempdir bridges std PathBuf into AbsolutePath")]
+    fn abs(buf: std::path::PathBuf) -> AbsolutePathBuf {
+        AbsolutePathBuf::new(buf).unwrap()
+    }
+
+    #[test]
+    fn find_ps1_sibling_returns_path_when_both_present() {
+        let dir = tempdir().unwrap();
+        let root = abs(dir.path().canonicalize().unwrap());
+        fs::write(root.as_path().join("npm.cmd"), "").unwrap();
+        fs::write(root.as_path().join("npm.ps1"), "").unwrap();
+
+        let resolved = abs(root.as_path().join("npm.cmd"));
+        let sibling = find_ps1_sibling(&resolved).expect("should find sibling");
+        assert_eq!(sibling.as_path(), root.as_path().join("npm.ps1"));
+    }
+
+    #[test]
+    fn find_ps1_sibling_is_case_insensitive_on_extension() {
+        let dir = tempdir().unwrap();
+        let root = abs(dir.path().canonicalize().unwrap());
+        fs::write(root.as_path().join("pnpm.CMD"), "").unwrap();
+        fs::write(root.as_path().join("pnpm.ps1"), "").unwrap();
+
+        let resolved = abs(root.as_path().join("pnpm.CMD"));
+        assert!(find_ps1_sibling(&resolved).is_some());
+    }
+
+    #[test]
+    fn find_ps1_sibling_returns_none_when_sibling_missing() {
+        let dir = tempdir().unwrap();
+        let root = abs(dir.path().canonicalize().unwrap());
+        fs::write(root.as_path().join("npm.cmd"), "").unwrap();
+
+        let resolved = abs(root.as_path().join("npm.cmd"));
+        assert!(find_ps1_sibling(&resolved).is_none());
+    }
+
+    #[test]
+    fn find_ps1_sibling_returns_none_for_non_cmd() {
+        let dir = tempdir().unwrap();
+        let root = abs(dir.path().canonicalize().unwrap());
+        fs::write(root.as_path().join("bun.exe"), "").unwrap();
+        fs::write(root.as_path().join("bun.ps1"), "").unwrap();
+
+        let resolved = abs(root.as_path().join("bun.exe"));
+        assert!(find_ps1_sibling(&resolved).is_none());
+    }
+
+    #[test]
+    fn find_ps1_sibling_returns_none_for_no_extension() {
+        let dir = tempdir().unwrap();
+        let root = abs(dir.path().canonicalize().unwrap());
+        fs::write(root.as_path().join("node"), "").unwrap();
+        fs::write(root.as_path().join("node.ps1"), "").unwrap();
+
+        let resolved = abs(root.as_path().join("node"));
+        assert!(find_ps1_sibling(&resolved).is_none());
+    }
+}

crates/vite_powershell/src/lib.rs

@@ -28,6 +28,7 @@ tracing = { workspace = true }
 vite_glob = { workspace = true }
 vite_graph_ser = { workspace = true }
 vite_path = { workspace = true }
+vite_powershell = { workspace = true }
 vite_shell = { workspace = true }
 vite_str = { workspace = true }
 vite_task_graph = { workspace = true }