fix(command): route Windows .cmd shims through PowerShell for pm commands

Apply the same .cmd → .ps1 rewrite to `vite_command::run_command` (and
`run_command_with_fspy`) so package-manager-routed commands (`vp dlx`,
`vp add`, `vp remove`, `vp update`, `vp install`, …) stop spawning
`cmd.exe` on Windows and Ctrl+C no longer leaves the terminal in a
broken state.

The task-layer fix (`vite_task_plan::ps1_shim`) only covered
`node_modules/.bin/*.cmd` — too narrow for pm shims like `npm.cmd` /
`pnpm.cmd` / `yarn.cmd` which live in `~/.vite-plus/js_runtime/...`
and system PATH. The new module drops the `node_modules/.bin` check:
if a `.cmd` has a sibling `.ps1`, route through PowerShell.

Closes #1489

Author: fengmk2

crates/vite_command/src/lib.rs

@@ -12,6 +12,8 @@ use tokio_util::sync::CancellationToken;
 use vite_error::Error;
 use vite_path::{AbsolutePath, AbsolutePathBuf, RelativePathBuf};
 
+mod ps1_shim;
+
 /// Result of running a command with fspy tracking.
 #[derive(Debug)]
 pub struct FspyCommandResult {
@@ -142,8 +144,12 @@ where
     let cwd = cwd.as_ref();
     let paths = envs.get("PATH");
     let bin_path = resolve_bin(bin_name, paths.map(|p| OsStr::new(p.as_str())), cwd)?;
-    let mut cmd = build_command(&bin_path, cwd);
-    cmd.args(args).envs(envs);
+    let (program, prefix_args) = match ps1_shim::rewrite_cmd_to_powershell(&bin_path) {
+        Some(rewritten) => rewritten,
+        None => (bin_path, Vec::new()),
+    };
+    let mut cmd = build_command(&program, cwd);
+    cmd.args(&prefix_args).args(args).envs(envs);
     let status = cmd.status().await?;
     Ok(status)
 }
@@ -171,8 +177,15 @@ where
     S: AsRef<OsStr>,
 {
     let cwd = cwd.as_ref();
-    let mut cmd = fspy::Command::new(bin_name);
-    cmd.args(args)
+    let bin_path = resolve_bin(bin_name, envs.get("PATH").map(|p| OsStr::new(p.as_str())), cwd)?;
+    let (program, prefix_args) = match ps1_shim::rewrite_cmd_to_powershell(&bin_path) {
+        Some(rewritten) => rewritten,
+        None => (bin_path, Vec::new()),
+    };
+
+    let mut cmd = fspy::Command::new(program.as_path());
+    cmd.args(&prefix_args)
+        .args(args)
         // set system environment variables first
         .envs(std::env::vars_os())
         // then set custom environment variables
@@ -454,12 +467,9 @@ mod tests {
                 run_command_with_fspy("npm-not-exists", &["--version"], &envs, &temp_dir_path)
                     .await;
             assert!(result.is_err(), "Should not find binary path, but got: {:?}", result);
-            assert!(
-                result
-                    .err()
-                    .unwrap()
-                    .to_string()
-                    .contains("could not resolve the full path of program '\"npm-not-exists\"'")
+            assert_eq!(
+                result.unwrap_err().to_string(),
+                "Cannot find binary path for command 'npm-not-exists'"
             );
         }
     }

crates/vite_command/src/ps1_shim.rs

@@ -0,0 +1,197 @@
+//! Windows-specific: when a resolved binary is a `.cmd` shim with a sibling
+//! `.ps1`, rewrite the spawn to go through `powershell.exe -File <sibling.ps1>`.
+//!
+//! 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` sidesteps the prompt and lets Ctrl+C propagate cleanly.
+//!
+//! Unlike the task-layer rewrite (`vite_task_plan::ps1_shim`, scoped to
+//! `node_modules/.bin/*.cmd` inside the workspace), this one applies to any
+//! `.cmd` whose `.ps1` sibling exists. Package manager shims (`npm.cmd`,
+//! `pnpm.cmd`, `yarn.cmd`, `npx.cmd`) live in `~/.vite-plus/js_runtime/...`
+//! or system PATH — outside any `node_modules/.bin` — so the structural
+//! check there is too narrow for this code path. If a `.ps1` sibling exists,
+//! the same tool that emitted the `.cmd` (npm cmd-shim, pnpm, yarn) emitted
+//! the `.ps1` with equivalent semantics.
+//!
+//! See <https://github.com/voidzero-dev/vite-plus/issues/1489>
+//! and <https://github.com/voidzero-dev/vite-plus/issues/1176>.
+
+use std::ffi::OsString;
+
+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.
+#[cfg(any(windows, test))]
+const POWERSHELL_PREFIX: &[&str] =
+    &["-NoProfile", "-NoLogo", "-ExecutionPolicy", "Bypass", "-File"];
+
+/// Rewrite a resolved `.cmd` invocation to go through PowerShell.
+///
+/// Returns `Some((powershell_host, prefix_args))` when the rewrite applies,
+/// where `prefix_args` is `["-NoProfile", "-NoLogo", "-ExecutionPolicy",
+/// "Bypass", "-File", <abs ps1 path>]`. Caller prepends `prefix_args` to the
+/// user args and spawns `powershell_host`.
+///
+/// Returns `None` when:
+/// - not on Windows,
+/// - no PowerShell host (`pwsh.exe` or `powershell.exe`) is on PATH,
+/// - the resolved path is not a `.cmd` (case-insensitive),
+/// - the `.cmd` has no sibling `.ps1`.
+#[cfg(windows)]
+#[must_use]
+pub fn rewrite_cmd_to_powershell(
+    resolved: &AbsolutePath,
+) -> Option<(AbsolutePathBuf, Vec<OsString>)> {
+    let host = powershell_host()?;
+    rewrite_with_host(resolved, host)
+}
+
+#[cfg(not(windows))]
+#[must_use]
+pub const fn rewrite_cmd_to_powershell(
+    _resolved: &AbsolutePath,
+) -> Option<(AbsolutePathBuf, Vec<OsString>)> {
+    None
+}
+
+/// Cached location of the PowerShell host. Prefers cross-platform `pwsh.exe`
+/// when present, falling back to the Windows built-in `powershell.exe`.
+#[cfg(windows)]
+fn powershell_host() -> Option<&'static AbsolutePathBuf> {
+    use std::sync::LazyLock;
+
+    static POWERSHELL_HOST: LazyLock<Option<AbsolutePathBuf>> = LazyLock::new(|| {
+        let resolved = which::which("pwsh.exe").or_else(|_| which::which("powershell.exe")).ok()?;
+        AbsolutePathBuf::new(resolved)
+    });
+    POWERSHELL_HOST.as_ref()
+}
+
+/// Pure rewrite logic. Factored out so tests can drive it on any platform
+/// without depending on a real `powershell.exe`.
+#[cfg(any(windows, test))]
+fn rewrite_with_host(
+    resolved: &AbsolutePath,
+    host: &AbsolutePathBuf,
+) -> Option<(AbsolutePathBuf, Vec<OsString>)> {
+    let ps1 = find_ps1_sibling(resolved)?;
+
+    tracing::debug!(
+        "rewriting .cmd to powershell: {} -> {} -File {}",
+        resolved.as_path().display(),
+        host.as_path().display(),
+        ps1.as_path().display(),
+    );
+
+    let mut prefix_args: Vec<OsString> =
+        POWERSHELL_PREFIX.iter().copied().map(OsString::from).collect();
+    prefix_args.push(ps1.as_path().as_os_str().to_owned());
+
+    Some((host.clone(), prefix_args))
+}
+
+#[cfg(any(windows, test))]
+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 rewrites_cmd_to_powershell_with_sibling_ps1() {
+        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 host = abs(root.as_path().join("powershell.exe"));
+        let resolved = abs(root.as_path().join("npm.cmd"));
+
+        let (program, prefix_args) = rewrite_with_host(&resolved, &host).expect("should rewrite");
+
+        assert_eq!(program.as_path(), host.as_path());
+        let as_strs: Vec<&str> = prefix_args.iter().filter_map(|a| a.to_str()).collect();
+        let ps1_path = root.as_path().join("npm.ps1");
+        let ps1_str = ps1_path.to_str().unwrap();
+        assert_eq!(
+            as_strs,
+            vec!["-NoProfile", "-NoLogo", "-ExecutionPolicy", "Bypass", "-File", ps1_str]
+        );
+    }
+
+    #[test]
+    fn rewrites_uppercase_cmd_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 host = abs(root.as_path().join("powershell.exe"));
+        let resolved = abs(root.as_path().join("pnpm.CMD"));
+
+        let result = rewrite_with_host(&resolved, &host);
+        assert!(result.is_some(), "case-insensitive .CMD should still rewrite");
+    }
+
+    #[test]
+    fn returns_none_when_no_ps1_sibling() {
+        let dir = tempdir().unwrap();
+        let root = abs(dir.path().canonicalize().unwrap());
+        fs::write(root.as_path().join("npm.cmd"), "").unwrap();
+
+        let host = abs(root.as_path().join("powershell.exe"));
+        let resolved = abs(root.as_path().join("npm.cmd"));
+
+        assert!(rewrite_with_host(&resolved, &host).is_none());
+    }
+
+    #[test]
+    fn returns_none_for_exe() {
+        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 host = abs(root.as_path().join("powershell.exe"));
+        let resolved = abs(root.as_path().join("bun.exe"));
+
+        assert!(rewrite_with_host(&resolved, &host).is_none());
+    }
+
+    #[test]
+    fn 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 host = abs(root.as_path().join("powershell.exe"));
+        let resolved = abs(root.as_path().join("node"));
+
+        assert!(rewrite_with_host(&resolved, &host).is_none());
+    }
+}