Handle SIGINT gracefully and add argv spawn mode for e2e tests

- Register a ctrlc no-op handler in vt before the tokio runtime starts,
  so Ctrl+C doesn't kill the runner via the default signal handler. Child
  tasks receive SIGINT directly from the terminal driver.
- Use std::process::exit to avoid non-zero exit codes from Rust runtime
  cleanup on Windows when background ctrlc threads are active.
- Add argv spawn mode for e2e steps: `{ argv = ["vt", "run", ...] }`
  spawns directly without a shell wrapper, avoiding bash's CTRL_C exit
  code interference on Windows.
- Clear Windows CTRL_C ignore flag in vtt exit-on-ctrlc before registering
  the handler (Rust runtime sets this flag and it persists to children).

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

Author: branchseer

crates/vite_task_bin/src/main.rs

@@ -1,13 +1,26 @@
-use std::process::ExitCode;
-
 use clap::Parser as _;
 use vite_task::{Command, ExitStatus, Session};
 use vite_task_bin::OwnedSessionConfig;
 
-#[tokio::main]
-async fn main() -> anyhow::Result<ExitCode> {
-    let exit_status = run().await?;
-    Ok(exit_status.0.into())
+fn main() -> ! {
+    // Ignore SIGINT/CTRL_C before the tokio runtime starts. Child tasks
+    // receive the signal directly from the terminal driver and handle it
+    // themselves. This lets the runner wait for tasks to exit and report
+    // their actual exit status rather than being killed mid-flight.
+    let _ = ctrlc::set_handler(|| {});
+
+    let exit_code: i32 =
+        tokio::runtime::Builder::new_multi_thread().enable_all().build().unwrap().block_on(async {
+            match run().await {
+                Ok(status) => i32::from(status.0),
+                Err(err) => {
+                    eprintln!("Error: {err:?}");
+                    1
+                }
+            }
+        });
+
+    std::process::exit(exit_code);
 }
 
 async fn run() -> anyhow::Result<ExitStatus> {

crates/vite_task_bin/src/vtt/exit_on_ctrlc.rs

@@ -3,6 +3,24 @@
 /// Sets up a Ctrl+C handler, emits a "ready" milestone, then waits.
 /// When Ctrl+C is received, prints "ctrl-c received" and exits.
 pub fn run() -> Result<(), Box<dyn std::error::Error>> {
+    // On Windows, Rust's runtime sets `SetConsoleCtrlHandler(NULL, TRUE)` which
+    // ignores CTRL_C_EVENT. This flag is inherited by child processes and takes
+    // precedence over registered handlers. Clear it before registering ours.
+    #[cfg(windows)]
+    {
+        // SAFETY: Passing (None, FALSE) removes the "ignore CTRL_C" flag.
+        unsafe extern "system" {
+            fn SetConsoleCtrlHandler(
+                handler: Option<unsafe extern "system" fn(u32) -> i32>,
+                add: i32,
+            ) -> i32;
+        }
+        // SAFETY: Clearing the Rust runtime's ignore flag.
+        unsafe {
+            SetConsoleCtrlHandler(None, 0);
+        }
+    }
+
     ctrlc::set_handler(move || {
         use std::io::Write;
         let _ = write!(std::io::stdout(), "ctrl-c received");

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/snapshots.toml

@@ -5,7 +5,12 @@
 [[e2e]]
 name = "ctrl-c terminates running tasks"
 steps = [
-  { command = "vt run -r dev", interactions = [
+  { argv = [
+    "vt",
+    "run",
+    "-r",
+    "dev",
+  ], interactions = [
     { "expect-milestone" = "ready" },
     { "expect-milestone" = "ready" },
     { "write-key" = "ctrl-c" },

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/snapshots/ctrl-c terminates running tasks.snap

@@ -2,7 +2,7 @@
 source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
 expression: e2e_outputs
 ---
-[1]> vt run -r dev
+> vt run -r dev
 @ expect-milestone: ready
 ~/packages/a$ vtt exit-on-ctrlc ⊘ cache disabled
 ~/packages/b$ vtt exit-on-ctrlc ⊘ cache disabled
@@ -13,3 +13,6 @@ expression: e2e_outputs
 ~/packages/a$ vtt exit-on-ctrlc ⊘ cache disabled
 ~/packages/b$ vtt exit-on-ctrlc ⊘ cache disabled
 ctrl-c received
+
+---
+vt run: 0/2 cache hit (0%). (Run `vt run --last-details` for full details)

crates/vite_task_bin/tests/e2e_snapshots/main.rs

@@ -64,16 +64,46 @@ enum Step {
 #[derive(serde::Deserialize, Debug)]
 #[serde(deny_unknown_fields)]
 struct StepConfig {
-    command: Str,
+    /// Shell command string (run via `sh -c`).
+    #[serde(default)]
+    command: Option<Str>,
+    /// Argument vector — spawned directly without a shell wrapper.
+    #[serde(default)]
+    argv: Option<Vec<Str>>,
     #[serde(default)]
     interactions: Vec<Interaction>,
 }
 
+/// How to spawn a step: either via shell or directly.
+enum StepSpawn<'a> {
+    /// Run through `sh -c "<command>"`.
+    Shell(&'a str),
+    /// Spawn directly with the given argv (first element is the program).
+    Direct(&'a [Str]),
+}
+
 impl Step {
-    fn command(&self) -> &str {
+    fn spawn_mode(&self) -> StepSpawn<'_> {
         match self {
-            Self::Command(command) => command.as_str(),
-            Self::Detailed(config) => config.command.as_str(),
+            Self::Command(command) => StepSpawn::Shell(command.as_str()),
+            Self::Detailed(config) => {
+                if let Some(argv) = &config.argv {
+                    StepSpawn::Direct(argv)
+                } else if let Some(command) = &config.command {
+                    StepSpawn::Shell(command.as_str())
+                } else {
+                    panic!("step must have either 'command' or 'argv'");
+                }
+            }
+        }
+    }
+
+    fn display_command(&self) -> String {
+        match self.spawn_mode() {
+            StepSpawn::Shell(cmd) => cmd.to_string(),
+            StepSpawn::Direct(argv) => {
+                argv.iter().map(|a| a.as_str()).collect::<Vec<_>>().join(" ")
+            }
         }
     }
 
@@ -284,10 +314,27 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
 
         let mut e2e_outputs = String::new();
         for step in &e2e.steps {
-            let step_command = step.command();
-            let mut cmd = CommandBuilder::new(&shell_exe);
-            cmd.arg("-c");
-            cmd.arg(step_command);
+            let step_display = step.display_command();
+            let mut cmd = match step.spawn_mode() {
+                StepSpawn::Shell(command) => {
+                    let mut cmd = CommandBuilder::new(&shell_exe);
+                    cmd.arg("-c");
+                    cmd.arg(command);
+                    cmd
+                }
+                StepSpawn::Direct(argv) => {
+                    // Resolve the program from CARGO_BIN_EXE_<name> if available,
+                    // since CommandBuilder doesn't do PATH lookup on all platforms.
+                    let program = argv[0].as_str();
+                    let exe_env = vite_str::format!("CARGO_BIN_EXE_{program}");
+                    let resolved = env::var_os(exe_env.as_str()).unwrap_or_else(|| program.into());
+                    let mut cmd = CommandBuilder::new(resolved);
+                    for arg in &argv[1..] {
+                        cmd.arg(arg.as_str());
+                    }
+                    cmd
+                }
+            };
             cmd.env_clear();
             cmd.env("PATH", &e2e_env_path);
             cmd.env("NO_COLOR", "1");
@@ -391,16 +438,14 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
                     e2e_outputs.push_str("[timeout]");
                 }
                 TerminationState::Exited(exit_code) => {
-                    // Normalize Windows CTRL_C exit code (512) to match Unix (1).
-                    let exit_code = if cfg!(windows) && *exit_code == 512 { 1 } else { *exit_code };
-                    if exit_code != 0 {
+                    if *exit_code != 0 {
                         e2e_outputs.push_str(vite_str::format!("[{exit_code}]").as_str());
                     }
                 }
             }
 
             e2e_outputs.push_str("> ");
-            e2e_outputs.push_str(step_command);
+            e2e_outputs.push_str(&step_display);
             e2e_outputs.push('\n');
 
             e2e_outputs.push_str(&redact_e2e_output(output, e2e_stage_path_str));