test(e2e): add ctrl-c propagation test for SIGINT handling (#303)

Add a `vtt exit-on-ctrlc` subcommand and e2e fixture that verifies
SIGINT
propagates to concurrent tasks when the user presses Ctrl+C. The test
runs
two packages with `vt run -r dev` (using argv spawn mode), synchronizes
via milestone protocol, then sends ctrl-c and verifies both tasks handle
it.

Changes:
- `vtt exit-on-ctrlc`: sets up ctrl-c handler, emits "ready" milestone,
  prints "ctrl-c received" and exits on SIGINT. On Windows, clears the
  inherited CONSOLE_IGNORE_CTRL_C flag (set by an ancestor process via
  CREATE_NEW_PROCESS_GROUP) before registering the handler.
- `vt main.rs`: register no-op ctrlc handler before tokio runtime so vt
  survives Ctrl+C and reports actual task exit status. Use process::exit
  to avoid Windows runtime cleanup issues.
- `ctrl-c` WriteKey variant for e2e test interactions (rename_all
kebab-case)
- Fix `expect_milestone` to preserve unmatched milestones in a local
buffer
  instead of dropping them via `take_unhandled_osc_sequences`
- Strip `^C` terminal echo and normalize `ctrl-c received` count in e2e
  redaction for cross-platform consistency
- Fix incorrect comment in pty_terminal test about CTRL_C ignore flag
source

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

---------

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

Author: branchseer

Cargo.lock

@@ -305,8 +305,12 @@ fn send_ctrl_c_interrupts_process() {
         // On macOS/Windows, use ctrlc which works fine (no .init_array/musl issue).
         #[cfg(not(target_os = "linux"))]
         {
-            // On Windows, clear the "ignore CTRL_C" flag set by Rust runtime
-            // so that CTRL_C_EVENT reaches the ctrlc handler.
+            // On Windows, an ancestor process may have been created with
+            // CREATE_NEW_PROCESS_GROUP, which implicitly sets the per-process
+            // CTRL_C ignore flag (CONSOLE_IGNORE_CTRL_C in PEB ConsoleFlags).
+            // This flag is inherited by all descendants and silently drops
+            // CTRL_C_EVENT before it reaches registered handlers. Clear it.
+            // Ref: https://learn.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
             #[cfg(windows)]
             {
                 // SAFETY: Declaring correct signature for SetConsoleCtrlHandler from kernel32.

crates/pty_terminal/tests/terminal.rs

@@ -16,8 +16,10 @@ path = "src/vtt/main.rs"
 
 [dependencies]
 anyhow = { workspace = true }
+ctrlc = { workspace = true }
 libc = { workspace = true }
 notify = { workspace = true }
+pty_terminal_test_client = { workspace = true, features = ["testing"] }
 async-trait = { workspace = true }
 clap = { workspace = true, features = ["derive"] }
 jsonc-parser = { workspace = true }

crates/vite_task_bin/Cargo.toml

@@ -1,13 +1,27 @@
-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),
+                #[expect(clippy::print_stderr, reason = "top-level error reporting")]
+                Err(err) => {
+                    eprintln!("Error: {err:?}");
+                    1
+                }
+            }
+        });
+
+    std::process::exit(exit_code);
 }
 
 async fn run() -> anyhow::Result<ExitStatus> {

crates/vite_task_bin/src/main.rs

@@ -0,0 +1,40 @@
+/// exit-on-ctrlc
+///
+/// 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, an ancestor process (e.g. cargo, the test harness) may have
+    // been created with CREATE_NEW_PROCESS_GROUP, which implicitly calls
+    // SetConsoleCtrlHandler(NULL, TRUE) and sets CONSOLE_IGNORE_CTRL_C in the
+    // PEB's ConsoleFlags. This flag is inherited by all descendants and takes
+    // precedence over registered handlers — CTRL_C_EVENT is silently dropped.
+    // Clear it so our handler can fire.
+    // Ref: https://learn.microsoft.com/en-us/windows/win32/procthread/process-creation-flags
+    #[cfg(windows)]
+    {
+        // SAFETY: Passing (None, FALSE) clears the per-process CTRL_C ignore flag.
+        unsafe extern "system" {
+            fn SetConsoleCtrlHandler(
+                handler: Option<unsafe extern "system" fn(u32) -> i32>,
+                add: i32,
+            ) -> i32;
+        }
+        // SAFETY: Clearing the inherited ignore flag.
+        unsafe {
+            SetConsoleCtrlHandler(None, 0);
+        }
+    }
+
+    ctrlc::set_handler(move || {
+        use std::io::Write;
+        let _ = write!(std::io::stdout(), "ctrl-c received");
+        let _ = std::io::stdout().flush();
+        std::process::exit(0);
+    })?;
+
+    pty_terminal_test_client::mark_milestone("ready");
+
+    loop {
+        std::thread::park();
+    }
+}

crates/vite_task_bin/src/vtt/exit_on_ctrlc.rs

@@ -10,6 +10,7 @@ mod barrier;
 mod check_tty;
 mod cp;
 mod exit;
+mod exit_on_ctrlc;
 mod mkdir;
 mod pipe_stdin;
 mod print;
@@ -27,7 +28,7 @@ fn main() {
     if args.len() < 2 {
         eprintln!("Usage: vtt <subcommand> [args...]");
         eprintln!(
-            "Subcommands: barrier, check-tty, cp, exit, mkdir, pipe-stdin, print, print-cwd, print-env, print-file, read-stdin, replace-file-content, rm, touch-file, write-file"
+            "Subcommands: barrier, check-tty, cp, exit, exit-on-ctrlc, mkdir, pipe-stdin, print, print-cwd, print-env, print-file, read-stdin, replace-file-content, rm, touch-file, write-file"
         );
         std::process::exit(1);
     }
@@ -40,7 +41,9 @@ fn main() {
         }
         "cp" => cp::run(&args[2..]),
         "exit" => exit::run(&args[2..]),
+        "exit-on-ctrlc" => exit_on_ctrlc::run(),
         "mkdir" => mkdir::run(&args[2..]),
+        "pipe-stdin" => pipe_stdin::run(&args[2..]),
         "print" => {
             print::run(&args[2..]);
             Ok(())
@@ -50,7 +53,6 @@ fn main() {
         "print-file" => print_file::run(&args[2..]),
         "read-stdin" => read_stdin::run(),
         "replace-file-content" => replace_file_content::run(&args[2..]),
-        "pipe-stdin" => pipe_stdin::run(&args[2..]),
         "rm" => rm::run(&args[2..]),
         "touch-file" => touch_file::run(&args[2..]),
         "write-file" => write_file::run(&args[2..]),

crates/vite_task_bin/src/vtt/main.rs

@@ -0,0 +1,3 @@
+{
+  "name": "ctrl-c-test"
+}

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/package.json

@@ -0,0 +1,14 @@
+# Tests that Ctrl+C (SIGINT) propagates to and terminates a running task.
+
+[[e2e]]
+name = "ctrl-c terminates running tasks"
+steps = [
+  { argv = [
+    "vt",
+    "run",
+    "dev",
+  ], interactions = [
+    { "expect-milestone" = "ready" },
+    { "write-key" = "ctrl-c" },
+  ] },
+]

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

@@ -0,0 +1,10 @@
+---
+source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
+expression: e2e_outputs
+---
+> vt run dev
+@ expect-milestone: ready
+$ vtt exit-on-ctrlc ⊘ cache disabled
+@ write-key: ctrl-c
+$ vtt exit-on-ctrlc ⊘ cache disabled
+ctrl-c received

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

@@ -0,0 +1,8 @@
+{
+  "cache": false,
+  "tasks": {
+    "dev": {
+      "command": "vtt exit-on-ctrlc"
+    }
+  }
+}