Handle SIGINT gracefully so vt exits with correct status

Register a ctrlc handler before task execution so SIGINT doesn't kill the
process via the default handler. Child tasks receive SIGINT directly from
the terminal driver (same process group) and handle it themselves. This
lets vt wait for tasks to exit and report their actual exit status (0 when
tasks handle ctrl-c).

Also strip ^C terminal echo in e2e redaction for cross-platform consistency.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: branchseer

Cargo.lock

@@ -46,10 +46,11 @@ wax = { workspace = true }
 tempfile = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
+libc = { workspace = true }
 nix = { workspace = true }
 
 [target.'cfg(windows)'.dependencies]
-winapi = { workspace = true, features = ["handleapi", "jobapi2", "winnt"] }
+winapi = { workspace = true, features = ["consoleapi", "handleapi", "jobapi2", "winnt"] }
 
 [lib]
 doctest = false

crates/vite_task/Cargo.toml

@@ -538,8 +538,8 @@ async fn spawn_inherited(
     // the child process calls exec(). Without this fix, the child's fds 0-2 are
     // closed after exec and Node.js reopens them as /dev/null, losing all output.
     // See: https://github.com/libuv/libuv/issues/2062
-    // SAFETY: The pre_exec closure only performs fcntl operations to clear
-    // FD_CLOEXEC flags on stdio fds, which is safe in a post-fork context.
+    // SAFETY: The pre_exec closure performs fcntl operations and signal reset,
+    // both of which are async-signal-safe and valid in a post-fork context.
     #[cfg(unix)]
     unsafe {
         tokio_cmd.pre_exec(|| {
@@ -549,6 +549,13 @@ async fn spawn_inherited(
                 fcntl::{FcntlArg, FdFlag, fcntl},
                 libc::{STDERR_FILENO, STDIN_FILENO, STDOUT_FILENO},
             };
+
+            // Clear FD_CLOEXEC on stdio fds before exec. libuv (used by Node.js)
+            // marks stdin/stdout/stderr as close-on-exec, which causes them to be
+            // closed when the child process calls exec(). Without this fix, the
+            // child's fds 0-2 are closed after exec and Node.js reopens them as
+            // /dev/null, losing all output.
+            // See: https://github.com/libuv/libuv/issues/2062
             for fd in [STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO] {
                 // SAFETY: fds 0-2 are always valid in a post-fork context
                 let borrowed = BorrowedFd::borrow_raw(fd);
@@ -560,6 +567,12 @@ async fn spawn_inherited(
                     }
                 }
             }
+
+            // Restore default SIGINT behavior for the child. The parent sets
+            // SIG_IGN so it survives Ctrl+C, but children must be able to
+            // install their own handlers (SIG_IGN persists across exec).
+            libc::signal(libc::SIGINT, libc::SIG_DFL);
+
             Ok(())
         });
     }
@@ -712,6 +725,32 @@ impl Session<'_> {
 
         let reporter = RefCell::new(builder.build());
 
+        // Ignore SIGINT so that Ctrl+C does not kill this process. Child tasks
+        // receive SIGINT directly from the terminal driver (same process group)
+        // and handle it themselves. This lets the runner wait for tasks to exit
+        // and report their actual status.
+        #[cfg(unix)]
+        // SAFETY: SIG_IGN is a valid signal disposition.
+        // Child processes inherit SIG_IGN, but we reset to SIG_DFL in pre_exec
+        // (see spawn_inherited) so children can set their own handlers.
+        unsafe {
+            libc::signal(libc::SIGINT, libc::SIG_IGN);
+        }
+        #[cfg(windows)]
+        {
+            // Register a handler that swallows the event. Unlike (None, TRUE)
+            // which sets an inheritable "ignore" flag, a registered handler is
+            // per-process and child processes keep the default behavior.
+            // SAFETY: The handler is a valid extern "system" fn with the correct signature.
+            const unsafe extern "system" fn ctrl_handler(_ctrl_type: u32) -> i32 {
+                1 // TRUE = handled
+            }
+            // SAFETY: Registering a valid handler function pointer with add=TRUE.
+            unsafe {
+                winapi::um::consoleapi::SetConsoleCtrlHandler(Some(ctrl_handler), 1);
+            }
+        }
+
         let execution_context = ExecutionContext {
             reporter: &reporter,
             cache,

crates/vite_task/src/session/execute/mod.rs

@@ -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
@@ -12,4 +12,7 @@ expression: e2e_outputs
 @ write-key: ctrl-c
 ~/packages/a$ vtt exit-on-ctrlc ⊘ cache disabled
 ~/packages/b$ vtt exit-on-ctrlc ⊘ cache disabled
-^Cctrl-c receivedctrl-c received
+ctrl-c receivedctrl-c received
+
+---
+vt run: 0/2 cache hit (0%). (Run `vt run --last-details` for full details)

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

@@ -101,6 +101,15 @@ pub fn redact_e2e_output(mut output: String, workspace_root: &str) -> String {
     let mise_warning_regex = regex::Regex::new(r"(?m)^mise WARN\s+.*\n?").unwrap();
     output = mise_warning_regex.replace_all(&output, "").into_owned();
 
+    // Remove ^C echo that Unix terminal drivers emit when ETX (0x03) is written
+    // to the PTY. Windows ConPTY does not echo it.
+    {
+        use cow_utils::CowUtils as _;
+        if let Cow::Owned(replaced) = output.as_str().cow_replace("^C", "") {
+            output = replaced;
+        }
+    }
+
     // Sort consecutive diagnostic blocks to handle non-deterministic tool output
     // (e.g., oxlint reports warnings in arbitrary order due to multi-threading).
     // Each block starts with "  ! " and ends at the next empty line.