Add argv step spawn mode and cross-platform snapshot support for e2e tests

Add `argv` field to e2e step config that spawns the process directly
without a shell wrapper (`sh -c`). This avoids shell interference with
signal handling and exit codes on Windows where bash intercepts CTRL_C.

The program is resolved from `CARGO_BIN_EXE_<name>` env vars since
CommandBuilder doesn't do PATH lookup on all platforms.

Also:
- Use staged temp dir for insta snapshot paths so writes work on
  read-only filesystems (e.g. WebDAV mount during cargo-xtest)
- Skip INSTA_REQUIRE_FULL_MATCH when INSTA_UPDATE is set, allowing
  cross-platform runs to accept metadata-only snapshot changes

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

Author: branchseer

CLAUDE.md

@@ -38,6 +38,8 @@ just doc           # Documentation generation
 
 If `gt` (Graphite CLI) is available in PATH, use it instead of `gh` to create pull requests.
 
+PR titles must use [Conventional Commits](https://www.conventionalcommits.org) format: `type(scope): summary` (scope is optional), e.g. `feat(cache): add LRU eviction`, `fix: handle symlink loops`, `test(e2e): add ctrl-c propagation test`.
+
 ## Tests
 
 ```bash

crates/vite_task_bin/tests/e2e_snapshots/main.rs

@@ -64,16 +64,48 @@ 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) => config.argv.as_deref().map_or_else(
+                || {
+                    StepSpawn::Shell(
+                        config
+                            .command
+                            .as_ref()
+                            .expect("step must have either 'command' or 'argv'")
+                            .as_str(),
+                    )
+                },
+                StepSpawn::Direct,
+            ),
+        }
+    }
+
+    #[expect(clippy::disallowed_types, reason = "String required by join")]
+    fn display_command(&self) -> String {
+        match self.spawn_mode() {
+            StepSpawn::Shell(cmd) => cmd.to_string(),
+            StepSpawn::Direct(argv) => argv.iter().map(Str::as_str).collect::<Vec<_>>().join(" "),
         }
     }
 
@@ -187,9 +219,7 @@ fn run_case(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, filter: Optio
     {
         println!("{fixture_name}");
     }
-    // Configure insta to write snapshots to fixture directory
     let mut settings = insta::Settings::clone_current();
-    settings.set_snapshot_path(fixture_path.join("snapshots"));
     settings.set_prepend_module_to_snapshot(false);
     settings.remove_snapshot_suffix();
 
@@ -214,6 +244,13 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
     let stage_path = tmpdir.join(fixture_name);
     CopyOptions::new().copy_tree(fixture_path, stage_path.as_path()).unwrap();
 
+    // Point insta at the staged copy's snapshot dir (which is writable). The
+    // original fixture_path may be on a read-only filesystem (e.g. WebDAV mount
+    // during cross-platform testing via cargo-xtest).
+    let mut settings = insta::Settings::clone_current();
+    settings.set_snapshot_path(stage_path.as_path().join("snapshots"));
+    let _guard = settings.bind_to_scope();
+
     let (workspace_root, _cwd) = find_workspace_root(&stage_path).unwrap();
 
     assert_eq!(
@@ -276,10 +313,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");
@@ -390,7 +444,7 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
             }
 
             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));
@@ -412,8 +466,14 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
 }
 
 fn main() {
-    // SAFETY: Called before any threads are spawned; insta reads this lazily on first assertion.
-    unsafe { std::env::set_var("INSTA_REQUIRE_FULL_MATCH", "1") };
+    // Skip INSTA_REQUIRE_FULL_MATCH when running cross-platform (via cargo-xtest): the snapshot
+    // source metadata changes when the test binary runs on a remote machine, causing insta to
+    // write .snap.new even when content matches. INSTA_UPDATE=always in this mode accepts
+    // metadata-only changes.
+    if std::env::var_os("INSTA_UPDATE").is_none() {
+        // SAFETY: Called before any threads are spawned; insta reads this lazily on first assertion.
+        unsafe { std::env::set_var("INSTA_REQUIRE_FULL_MATCH", "1") };
+    }
 
     let filter = std::env::args().nth(1);
 
@@ -430,7 +490,7 @@ fn main() {
 
         // Copy .node-version to the tmp dir so version manager shims can resolve the correct
         // Node.js binary when running task commands.
-        let repo_root = manifest_dir.join("../..").canonicalize().unwrap();
+        let repo_root = manifest_dir.parent().unwrap().parent().unwrap();
         std::fs::copy(repo_root.join(".node-version"), tmp_dir.path().join(".node-version"))
             .unwrap();