Add e2e snapshot test for ctrl-c propagation to running tasks

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`, synchronizes them via a filesystem barrier,
then sends ctrl-c and verifies both tasks receive and handle it.

Also adds `ctrl-c` as a new `write-key` interaction type for e2e snapshot tests.

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

Author: branchseer

Cargo.lock

@@ -1,4 +1,7 @@
-use std::io::{BufReader, Read};
+use std::{
+    collections::VecDeque,
+    io::{BufReader, Read},
+};
 
 pub use portable_pty::CommandBuilder;
 use pty_terminal::terminal::{PtyReader, Terminal};
@@ -25,6 +28,8 @@ pub struct TestTerminal {
 pub struct Reader {
     pty: BufReader<PtyReader>,
     child_handle: ChildHandle,
+    /// OSC sequences taken from the PTY but not yet consumed by `expect_milestone`.
+    pending_osc: VecDeque<Vec<Vec<u8>>>,
 }
 
 impl TestTerminal {
@@ -37,7 +42,11 @@ impl TestTerminal {
         let Terminal { pty_reader, pty_writer, child_handle, .. } = Terminal::spawn(size, cmd)?;
         Ok(Self {
             writer: pty_writer,
-            reader: Reader { pty: BufReader::new(pty_reader), child_handle: child_handle.clone() },
+            reader: Reader {
+                pty: BufReader::new(pty_reader),
+                child_handle: child_handle.clone(),
+                pending_osc: VecDeque::new(),
+            },
             child_handle,
         })
     }
@@ -71,15 +80,24 @@ impl Reader {
         let mut buf = [0u8; 4096];
 
         loop {
-            let found = self
-                .pty
-                .get_ref()
-                .take_unhandled_osc_sequences()
-                .into_iter()
-                .filter_map(|params| {
-                    pty_terminal_test_client::decode_milestone_from_osc8_params(&params)
-                })
-                .any(|decoded| decoded == name);
+            // Drain new sequences from the PTY into our local buffer.
+            self.pending_osc.append(&mut self.pty.get_ref().take_unhandled_osc_sequences());
+
+            // Scan for the first matching milestone, keeping the rest.
+            let mut found = false;
+            let mut remaining = VecDeque::with_capacity(self.pending_osc.len());
+            for params in self.pending_osc.drain(..) {
+                if !found
+                    && pty_terminal_test_client::decode_milestone_from_osc8_params(&params)
+                        .is_some_and(|decoded| decoded == name)
+                {
+                    found = true;
+                    continue;
+                }
+                remaining.push_back(params);
+            }
+            self.pending_osc = remaining;
+
             if found {
                 return self.screen_contents();
             }

crates/pty_terminal_test/src/lib.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

@@ -0,0 +1,18 @@
+/// 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>> {
+    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

@@ -8,6 +8,7 @@
 
 mod barrier;
 mod check_tty;
+mod exit_on_ctrlc;
 mod print;
 mod print_cwd;
 mod print_env;
@@ -21,7 +22,7 @@ fn main() {
     if args.len() < 2 {
         eprintln!("Usage: vtt <subcommand> [args...]");
         eprintln!(
-            "Subcommands: barrier, check-tty, print, print-cwd, print-env, print-file, read-stdin, replace-file-content, touch-file"
+            "Subcommands: barrier, check-tty, exit-on-ctrlc, print, print-cwd, print-env, print-file, read-stdin, replace-file-content, touch-file"
         );
         std::process::exit(1);
     }
@@ -32,6 +33,7 @@ fn main() {
             check_tty::run();
             Ok(())
         }
+        "exit-on-ctrlc" => exit_on_ctrlc::run(),
         "print" => {
             print::run(&args[2..]);
             Ok(())

crates/vite_task_bin/src/vtt/main.rs

@@ -0,0 +1,4 @@
+{
+  "name": "ctrl-c-test",
+  "private": true
+}

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

@@ -0,0 +1,6 @@
+{
+  "name": "@ctrl-c/a",
+  "scripts": {
+    "dev": "vtt exit-on-ctrlc"
+  }
+}

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

@@ -0,0 +1,6 @@
+{
+  "name": "@ctrl-c/b",
+  "scripts": {
+    "dev": "vtt exit-on-ctrlc"
+  }
+}

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

@@ -0,0 +1,2 @@
+packages:
+  - packages/*

crates/vite_task_bin/tests/e2e_snapshots/fixtures/ctrl-c/pnpm-workspace.yaml

@@ -0,0 +1,13 @@
+# Tests that Ctrl+C (SIGINT) propagates to and terminates running tasks.
+# Two packages run concurrently; both set up ctrl-c handlers and emit
+# a "ready" milestone. After both are ready, ctrl-c is sent.
+
+[[e2e]]
+name = "ctrl-c terminates running tasks"
+steps = [
+  { command = "vt run -r dev", interactions = [
+    { "expect-milestone" = "ready" },
+    { "expect-milestone" = "ready" },
+    { "write-key" = "ctrl-c" },
+  ] },
+]