feat(env): use trampoline exe instead of .cmd wrappers on Windows

Replace Windows .cmd shim wrappers with lightweight trampoline .exe
binaries to eliminate the "Terminate batch job (Y/N)?" prompt on Ctrl+C.

The trampoline binary detects its tool name from its own filename,
sets VITE_PLUS_SHIM_TOOL env var, and spawns vp.exe. It installs a
Ctrl+C handler that ignores the signal (the child process handles it),
avoiding the batch file prompt entirely.

- Add crates/vite_trampoline/ with minimal Windows trampoline binary
- Update shim detection to check env var before argv[0]
- Replace .cmd/.sh wrapper creation with trampoline .exe copying
- Add legacy .cmd cleanup during setup --refresh
- Update CI to build and distribute vp-shim.exe for Windows targets
- Add RFC document with feasibility study

Closes #835

Author: fengmk2

.github/actions/build-upstream/action.yml

@@ -40,6 +40,7 @@ runs:
           packages/cli/binding/index.d.cts
           target/${{ inputs.target }}/release/vp
           target/${{ inputs.target }}/release/vp.exe
+          target/${{ inputs.target }}/release/vp-shim.exe
         key: ${{ steps.cache-key.outputs.key }}
 
     # Apply Vite+ branding patches to rolldown-vite source (CI checks out
@@ -111,6 +112,11 @@ runs:
       shell: bash
       run: cargo build --release --target ${{ inputs.target }} -p vite_global_cli
 
+    - name: Build trampoline shim binary (Windows only)
+      if: steps.cache-restore.outputs.cache-hit != 'true' && contains(inputs.target, 'windows')
+      shell: bash
+      run: cargo build --release --target ${{ inputs.target }} -p vite_trampoline
+
     - name: Save NAPI binding cache
       if: steps.cache-restore.outputs.cache-hit != 'true'
       uses: actions/cache/save@94b89442628ad1d101e352b7ee38f30e1bef108e # v5
@@ -123,6 +129,7 @@ runs:
           packages/cli/binding/index.d.cts
           target/${{ inputs.target }}/release/vp
           target/${{ inputs.target }}/release/vp.exe
+          target/${{ inputs.target }}/release/vp-shim.exe
         key: ${{ steps.cache-key.outputs.key }}
 
     # Build vite-plus TypeScript after native bindings are ready

.github/workflows/release.yml

@@ -124,6 +124,7 @@ jobs:
           path: |
             ./target/${{ matrix.settings.target }}/release/vp
             ./target/${{ matrix.settings.target }}/release/vp.exe
+            ./target/${{ matrix.settings.target }}/release/vp-shim.exe
           if-no-files-found: error
 
       - name: Remove .node files before upload dist

.github/workflows/test-standalone-install.yml

@@ -233,7 +233,7 @@ jobs:
             exit 1
           }
 
-          $expectedShims = @("node.cmd", "npm.cmd", "npx.cmd")
+          $expectedShims = @("node.exe", "npm.exe", "npx.exe")
           foreach ($shim in $expectedShims) {
             $shimFile = Join-Path $binPath $shim
             if (-not (Test-Path $shimFile)) {
@@ -300,7 +300,7 @@ jobs:
             exit 1
           }
 
-          $expectedShims = @("node.cmd", "npm.cmd", "npx.cmd")
+          $expectedShims = @("node.exe", "npm.exe", "npx.exe")
           foreach ($shim in $expectedShims) {
             $shimFile = Join-Path $binPath $shim
             if (-not (Test-Path $shimFile)) {
@@ -380,8 +380,8 @@ jobs:
             exit 1
           }
 
-          # Verify shim executables exist (all use .cmd wrappers on Windows)
-          $expectedShims = @("node.cmd", "npm.cmd", "npx.cmd")
+          # Verify shim executables exist (trampoline .exe files on Windows)
+          $expectedShims = @("node.exe", "npm.exe", "npx.exe")
           foreach ($shim in $expectedShims) {
             $shimFile = Join-Path $binPath $shim
             if (-not (Test-Path $shimFile)) {
@@ -419,8 +419,8 @@ jobs:
           set "BIN_PATH=%USERPROFILE%\.vite-plus\bin"
           dir "%BIN_PATH%"
 
-          REM Verify shim executables exist (Windows uses .cmd wrappers)
-          for %%s in (node.cmd npm.cmd npx.cmd vp.cmd) do (
+          REM Verify shim executables exist (Windows uses trampoline .exe files)
+          for %%s in (node.exe npm.exe npx.exe vp.exe) do (
             if not exist "%BIN_PATH%\%%s" (
               echo Error: Shim not found: %BIN_PATH%\%%s
               exit /b 1
@@ -462,22 +462,13 @@ jobs:
             exit 1
           fi
 
-          # Verify .cmd wrappers exist (for cmd.exe/PowerShell)
-          for shim in node.cmd npm.cmd npx.cmd vp.cmd; do
+          # Verify trampoline .exe files exist
+          for shim in node.exe npm.exe npx.exe vp.exe; do
             if [ ! -f "$BIN_PATH/$shim" ]; then
-              echo "Error: .cmd wrapper not found: $BIN_PATH/$shim"
+              echo "Error: Trampoline shim not found: $BIN_PATH/$shim"
               exit 1
             fi
-            echo "Found .cmd wrapper: $BIN_PATH/$shim"
-          done
-
-          # Verify shell scripts exist (for Git Bash)
-          for shim in node npm npx vp; do
-            if [ ! -f "$BIN_PATH/$shim" ]; then
-              echo "Error: Shell script not found: $BIN_PATH/$shim"
-              exit 1
-            fi
-            echo "Found shell script: $BIN_PATH/$shim"
+            echo "Found trampoline shim: $BIN_PATH/$shim"
           done
 
           # Verify vp env doctor works

Cargo.lock

@@ -239,8 +239,8 @@ async fn check_bin_dir() -> bool {
 fn shim_filename(tool: &str) -> String {
     #[cfg(windows)]
     {
-        // All tools use .cmd wrappers on Windows (including node)
-        format!("{tool}.cmd")
+        // All tools use trampoline .exe files on Windows
+        format!("{tool}.exe")
     }
 
     #[cfg(not(windows))]
@@ -739,10 +739,10 @@ mod tests {
 
         #[cfg(windows)]
         {
-            // All shims should use .cmd on Windows (matching setup.rs)
-            assert_eq!(node, "node.cmd");
-            assert_eq!(npm, "npm.cmd");
-            assert_eq!(npx, "npx.cmd");
+            // All shims should use .exe on Windows (trampoline executables)
+            assert_eq!(node, "node.exe");
+            assert_eq!(npm, "npm.exe");
+            assert_eq!(npx, "npx.exe");
         }
 
         #[cfg(not(windows))]

crates/vite_global_cli/src/commands/env/doctor.rs

@@ -368,7 +368,7 @@ pub(crate) const CORE_SHIMS: &[&str] = &["node", "npm", "npx", "vp"];
 /// Create a shim for a package binary.
 ///
 /// On Unix: Creates a symlink to ../current/bin/vp
-/// On Windows: Creates a .cmd wrapper that calls `vp env exec <bin_name>`
+/// On Windows: Creates a trampoline .exe that forwards to vp.exe
 async fn create_package_shim(
     bin_dir: &vite_path::AbsolutePath,
     bin_name: &str,
@@ -406,40 +406,25 @@ async fn create_package_shim(
 
     #[cfg(windows)]
     {
-        let cmd_path = bin_dir.join(format!("{}.cmd", bin_name));
+        let shim_path = bin_dir.join(format!("{}.exe", bin_name));
 
         // Skip if already exists (e.g., re-installing the same package)
-        if tokio::fs::try_exists(&cmd_path).await.unwrap_or(false) {
+        if tokio::fs::try_exists(&shim_path).await.unwrap_or(false) {
             return Ok(());
         }
 
-        // Create .cmd wrapper that calls vp env exec <bin_name>.
-        // Use `--` so args like `--help` are forwarded to the package binary,
-        // not consumed by clap while parsing `vp env exec`.
-        // Set VITE_PLUS_HOME using %~dp0.. which resolves to the parent of bin/
-        // This ensures the vp binary knows its home directory
-        let wrapper_content = format!(
-            "@echo off\r\nset VITE_PLUS_HOME=%~dp0..\r\nset VITE_PLUS_SHIM_WRAPPER=1\r\n\"%VITE_PLUS_HOME%\\current\\bin\\vp.exe\" env exec {} -- %*\r\nexit /b %ERRORLEVEL%\r\n",
-            bin_name
-        );
-        tokio::fs::write(&cmd_path, wrapper_content).await?;
-
-        // Also create shell script for Git Bash (bin_name without extension)
-        // Uses explicit "vp env exec <bin_name>" instead of symlink+argv[0] because
-        // Windows symlinks require admin privileges
-        let sh_path = bin_dir.join(bin_name);
-        let sh_content = format!(
-            r#"#!/bin/sh
-VITE_PLUS_HOME="$(dirname "$(dirname "$(readlink -f "$0" 2>/dev/null || echo "$0")")")"
-export VITE_PLUS_HOME
-export VITE_PLUS_SHIM_WRAPPER=1
-exec "$VITE_PLUS_HOME/current/bin/vp.exe" env exec {} -- "$@"
-"#,
-            bin_name
-        );
-        tokio::fs::write(&sh_path, sh_content).await?;
+        // Copy the trampoline binary as <bin_name>.exe.
+        // The trampoline detects the tool name from its own filename and sets
+        // VITE_PLUS_SHIM_TOOL env var before spawning vp.exe.
+        let trampoline_src = super::setup::get_trampoline_path()?;
+        tokio::fs::copy(trampoline_src.as_path(), &shim_path).await?;
+
+        // Remove legacy .cmd and shell script wrappers from previous versions.
+        // In Git Bash/MSYS, the extensionless script takes precedence over .exe,
+        // so leftover wrappers would bypass the trampoline.
+        super::setup::cleanup_legacy_windows_shim(bin_dir, bin_name).await;
 
-        tracing::debug!("Created package shim wrappers for {} (.cmd and shell script)", bin_name);
+        tracing::debug!("Created package trampoline shim {:?}", shim_path);
     }
 
     Ok(())
@@ -466,16 +451,15 @@ async fn remove_package_shim(
 
     #[cfg(windows)]
     {
-        // Remove .cmd wrapper
-        let cmd_path = bin_dir.join(format!("{}.cmd", bin_name));
-        if tokio::fs::try_exists(&cmd_path).await.unwrap_or(false) {
-            tokio::fs::remove_file(&cmd_path).await?;
-        }
-
-        // Also remove shell script (for Git Bash)
-        let sh_path = bin_dir.join(bin_name);
-        if tokio::fs::try_exists(&sh_path).await.unwrap_or(false) {
-            tokio::fs::remove_file(&sh_path).await?;
+        // Remove trampoline .exe shim and legacy .cmd / shell script wrappers.
+        // Best-effort: ignore NotFound errors for files that don't exist.
+        for suffix in &[".exe", ".cmd", ""] {
+            let path = if suffix.is_empty() {
+                bin_dir.join(bin_name)
+            } else {
+                bin_dir.join(format!("{bin_name}{suffix}"))
+            };
+            let _ = tokio::fs::remove_file(&path).await;
         }
     }
 
@@ -486,13 +470,42 @@ async fn remove_package_shim(
 mod tests {
     use super::*;
 
+    /// RAII guard that sets `VITE_PLUS_TRAMPOLINE_PATH` to a fake binary on creation
+    /// and clears it on drop. Ensures cleanup even on test panics.
+    #[cfg(windows)]
+    struct FakeTrampolineGuard;
+
+    #[cfg(windows)]
+    impl FakeTrampolineGuard {
+        fn new(dir: &std::path::Path) -> Self {
+            let trampoline = dir.join("vp-shim.exe");
+            std::fs::write(&trampoline, b"fake-trampoline").unwrap();
+            unsafe {
+                std::env::set_var(vite_shared::env_vars::VITE_PLUS_TRAMPOLINE_PATH, &trampoline);
+            }
+            Self
+        }
+    }
+
+    #[cfg(windows)]
+    impl Drop for FakeTrampolineGuard {
+        fn drop(&mut self) {
+            unsafe {
+                std::env::remove_var(vite_shared::env_vars::VITE_PLUS_TRAMPOLINE_PATH);
+            }
+        }
+    }
+
     #[tokio::test]
+    #[cfg_attr(windows, serial_test::serial)]
     async fn test_create_package_shim_creates_bin_dir() {
         use tempfile::TempDir;
         use vite_path::AbsolutePathBuf;
 
         // Create a temp directory but don't create the bin subdirectory
         let temp_dir = TempDir::new().unwrap();
+        #[cfg(windows)]
+        let _guard = FakeTrampolineGuard::new(temp_dir.path());
         let bin_dir = temp_dir.path().join("bin");
         let bin_dir = AbsolutePathBuf::new(bin_dir).unwrap();
 
@@ -505,7 +518,7 @@ mod tests {
         // Verify bin directory was created
         assert!(bin_dir.as_path().exists());
 
-        // Verify shim file was created (on Windows, shims have .cmd extension)
+        // Verify shim file was created (on Windows, shims have .exe extension)
         // On Unix, symlinks may be broken (target doesn't exist), so use symlink_metadata
         #[cfg(unix)]
         {
@@ -517,7 +530,7 @@ mod tests {
         }
         #[cfg(windows)]
         {
-            let shim_path = bin_dir.join("test-shim.cmd");
+            let shim_path = bin_dir.join("test-shim.exe");
             assert!(shim_path.as_path().exists());
         }
     }
@@ -537,16 +550,19 @@ mod tests {
         #[cfg(unix)]
         let shim_path = bin_dir.join("node");
         #[cfg(windows)]
-        let shim_path = bin_dir.join("node.cmd");
+        let shim_path = bin_dir.join("node.exe");
         assert!(!shim_path.as_path().exists());
     }
 
     #[tokio::test]
+    #[cfg_attr(windows, serial_test::serial)]
     async fn test_remove_package_shim_removes_shim() {
         use tempfile::TempDir;
         use vite_path::AbsolutePathBuf;
 
         let temp_dir = TempDir::new().unwrap();
+        #[cfg(windows)]
+        let _guard = FakeTrampolineGuard::new(temp_dir.path());
         let bin_dir = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
 
         // Create a shim
@@ -573,7 +589,7 @@ mod tests {
         }
         #[cfg(windows)]
         {
-            let shim_path = bin_dir.join("tsc.cmd");
+            let shim_path = bin_dir.join("tsc.exe");
             assert!(shim_path.as_path().exists(), "Shim should exist after creation");
 
             // Remove the shim
@@ -597,12 +613,15 @@ mod tests {
     }
 
     #[tokio::test]
+    #[cfg_attr(windows, serial_test::serial)]
     async fn test_uninstall_removes_shims_from_metadata() {
         use tempfile::TempDir;
         use vite_path::AbsolutePathBuf;
 
         let temp_dir = TempDir::new().unwrap();
         let temp_path = temp_dir.path().to_path_buf();
+        #[cfg(windows)]
+        let _guard = FakeTrampolineGuard::new(&temp_path);
         let _guard = vite_shared::EnvConfig::test_guard(
             vite_shared::EnvConfig::for_test_with_home(&temp_path),
         );
@@ -630,10 +649,10 @@ mod tests {
         }
         #[cfg(windows)]
         {
-            assert!(bin_dir.join("tsc.cmd").as_path().exists(), "tsc.cmd shim should exist");
+            assert!(bin_dir.join("tsc.exe").as_path().exists(), "tsc.exe shim should exist");
             assert!(
-                bin_dir.join("tsserver.cmd").as_path().exists(),
-                "tsserver.cmd shim should exist"
+                bin_dir.join("tsserver.exe").as_path().exists(),
+                "tsserver.exe shim should exist"
             );
         }
 
@@ -674,10 +693,10 @@ mod tests {
         }
         #[cfg(windows)]
         {
-            assert!(!bin_dir.join("tsc.cmd").as_path().exists(), "tsc.cmd shim should be removed");
+            assert!(!bin_dir.join("tsc.exe").as_path().exists(), "tsc.exe shim should be removed");
             assert!(
-                !bin_dir.join("tsserver.cmd").as_path().exists(),
-                "tsserver.cmd shim should be removed"
+                !bin_dir.join("tsserver.exe").as_path().exists(),
+                "tsserver.exe shim should be removed"
             );
         }
     }