fix: make interactions-no-vp work in cargo xtest

Author: branchseer

crates/vite_task_bin/src/main.rs

@@ -112,11 +112,15 @@ impl Drop for RawModeGuard {
 
 fn run_interact() -> anyhow::Result<ExitStatus> {
     let stdin_is_tty = std::io::stdin().is_terminal();
-    let mut raw_mode = RawModeGuard::new(stdin_is_tty)?;
+    let enable_raw_mode = if cfg!(windows) { true } else { stdin_is_tty };
+    let mut raw_mode = RawModeGuard::new(enable_raw_mode)?;
 
     let mut stdin = std::io::stdin();
     let mut stdout = std::io::stdout();
     let mut text_buffer = Vec::<u8>::new();
+    let mut ansi_escape_pending = false;
+    let mut ansi_csi_pending = false;
+    let mut windows_extended_key_pending = false;
 
     write_line(&mut stdout, b"START")?;
     write_milestone(&mut stdout, "ready")?;
@@ -129,19 +133,50 @@ fn run_interact() -> anyhow::Result<ExitStatus> {
         }
 
         let byte = byte[0];
-        if byte == 0x1b {
-            let mut seq = [0u8; 2];
-            if stdin.read_exact(&mut seq).is_err() {
-                break;
+        if ansi_escape_pending {
+            ansi_escape_pending = false;
+
+            if byte == b'[' || byte == b'O' {
+                ansi_csi_pending = true;
+                continue;
+            }
+        }
+
+        if ansi_csi_pending {
+            ansi_csi_pending = false;
+
+            if byte == b'A' {
+                write_milestone(&mut stdout, "after-up")?;
+                continue;
+            }
+
+            if byte == b'B' {
+                write_milestone(&mut stdout, "after-down")?;
+                continue;
             }
+        }
+
+        if windows_extended_key_pending {
+            windows_extended_key_pending = false;
 
-            if seq == [b'[', b'A'] {
-                write_line(&mut stdout, b"KEY:UP")?;
+            if byte == 72 {
                 write_milestone(&mut stdout, "after-up")?;
-            } else if seq == [b'[', b'B'] {
-                write_line(&mut stdout, b"KEY:DOWN")?;
+                continue;
+            }
+
+            if byte == 80 {
                 write_milestone(&mut stdout, "after-down")?;
+                continue;
             }
+        }
+
+        if byte == 0x1b {
+            ansi_escape_pending = true;
+            continue;
+        }
+
+        if byte == 0x00 || byte == 0xe0 {
+            windows_extended_key_pending = true;
             continue;
         }
 

crates/vite_task_bin/tests/e2e_snapshots/fixtures/interactions-no-vp/snapshots.toml

@@ -1,6 +1,6 @@
 [[e2e]]
 name = "interactions without vp"
 steps = [
-  { command = "vp interact", interactions = [{ "expect-milestone" = "ready" }, { "write" = "hello" }, { "write-line" = "hello" }, { "expect-milestone" = "after-line" }, { "write-key" = "up" }, { "expect-milestone" = "after-up" }, { "write-key" = "down" }, { "expect-milestone" = "after-down" }, { "write-key" = "enter" }, { "expect-milestone" = "after-enter" }] },
+  { command = "vp interact", interactions = [{ "expect-milestone" = "ready" }, { "write" = "hello" }, { "write-line" = "hello" }, { "expect-milestone" = "after-line" }, { "write-key" = "up" }, { "write-key" = "down" }, { "write" = "x" }, { "write-key" = "enter" }, { "expect-milestone" = "after-line" }, { "write-key" = "enter" }, { "expect-milestone" = "after-enter" }] },
   { command = "node -e \"console.log('PIPE_STDIN_IS_TTY:' + String(Boolean(process.stdin.isTTY)))\"", pty = false },
 ]

crates/vite_task_bin/tests/e2e_snapshots/fixtures/interactions-no-vp/snapshots/interactions without vp.snap

@@ -1,7 +1,6 @@
 ---
 source: crates/vite_task_bin/tests/e2e_snapshots/main.rs
 expression: e2e_outputs
-input_file: crates/vite_task_bin/tests/e2e_snapshots/fixtures/interactions-no-vp
 ---
 > vp interact
 @ expect-milestone: ready
@@ -22,22 +21,10 @@ CHAR:l
 CHAR:o
 LINE:hellohello
 @ write-key: up
-@ expect-milestone: after-up
-START
-CHAR:h
-CHAR:e
-CHAR:l
-CHAR:l
-CHAR:o
-CHAR:h
-CHAR:e
-CHAR:l
-CHAR:l
-CHAR:o
-LINE:hellohello
-KEY:UP
 @ write-key: down
-@ expect-milestone: after-down
+@ write: x
+@ write-key: enter
+@ expect-milestone: after-line
 START
 CHAR:h
 CHAR:e
@@ -50,8 +37,8 @@ CHAR:l
 CHAR:l
 CHAR:o
 LINE:hellohello
-KEY:UP
-KEY:DOWN
+CHAR:x
+LINE:x
 @ write-key: enter
 @ expect-milestone: after-enter
 START
@@ -66,8 +53,8 @@ CHAR:l
 CHAR:l
 CHAR:o
 LINE:hellohello
-KEY:UP
-KEY:DOWN
+CHAR:x
+LINE:x
 KEY:ENTER
 DONE
 START
@@ -82,8 +69,8 @@ CHAR:l
 CHAR:l
 CHAR:o
 LINE:hellohello
-KEY:UP
-KEY:DOWN
+CHAR:x
+LINE:x
 KEY:ENTER
 DONE
 > node -e "console.log('PIPE_STDIN_IS_TTY:' + String(Boolean(process.stdin.isTTY)))"

crates/vite_task_bin/tests/e2e_snapshots/main.rs

@@ -9,7 +9,6 @@ use std::{
     time::{Duration, Instant},
 };
 
-use copy_dir::copy_dir;
 use pty_terminal::{geo::ScreenSize, terminal::CommandBuilder};
 use pty_terminal_test::TestTerminal;
 use redact::redact_e2e_output;
@@ -23,6 +22,9 @@ const STEP_TIMEOUT: Duration = Duration::from_secs(20);
 /// Screen size for the PTY terminal. Large enough to avoid line wrapping.
 const SCREEN_SIZE: ScreenSize = ScreenSize { rows: 500, cols: 500 };
 
+const COMPILE_TIME_CARGO_BIN_EXE_VP: &str = env!("CARGO_BIN_EXE_vp");
+const COMPILE_TIME_CARGO_MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
+
 /// Get the shell executable for running e2e test steps.
 /// On Unix, uses /bin/sh.
 /// On Windows, uses BASH env var or falls back to Git Bash.
@@ -53,6 +55,65 @@ fn get_shell_exe() -> std::path::PathBuf {
     }
 }
 
+#[expect(
+    clippy::disallowed_types,
+    reason = "Path types required for runtime path remapping between compile and runtime roots"
+)]
+fn runtime_manifest_dir() -> std::path::PathBuf {
+    std::env::var_os("CARGO_MANIFEST_DIR").map_or_else(
+        || std::path::PathBuf::from(COMPILE_TIME_CARGO_MANIFEST_DIR),
+        std::path::PathBuf::from,
+    )
+}
+
+#[expect(
+    clippy::disallowed_types,
+    reason = "Path types required for runtime path remapping between compile and runtime roots"
+)]
+fn relative_path_from(path: &std::path::Path, base: &std::path::Path) -> std::path::PathBuf {
+    use std::path::{Component, PathBuf};
+
+    let path_components = path.components().collect::<Vec<_>>();
+    let base_components = base.components().collect::<Vec<_>>();
+
+    let common_prefix_len = path_components
+        .iter()
+        .zip(base_components.iter())
+        .take_while(|(path_comp, base_comp)| path_comp == base_comp)
+        .count();
+
+    let mut relative_path = PathBuf::new();
+
+    for base_comp in &base_components[common_prefix_len..] {
+        match base_comp {
+            Component::Normal(_) | Component::CurDir | Component::ParentDir => {
+                relative_path.push("..");
+            }
+            Component::RootDir | Component::Prefix(_) => {}
+        }
+    }
+
+    for path_comp in &path_components[common_prefix_len..] {
+        relative_path.push(path_comp.as_os_str());
+    }
+
+    relative_path
+}
+
+#[expect(
+    clippy::disallowed_types,
+    reason = "Path types required for runtime path remapping between compile and runtime roots"
+)]
+fn resolve_runtime_vp_path() -> AbsolutePathBuf {
+    let compile_time_vp = std::path::Path::new(COMPILE_TIME_CARGO_BIN_EXE_VP);
+    let compile_time_manifest = std::path::Path::new(COMPILE_TIME_CARGO_MANIFEST_DIR);
+    let vp_relative_path = relative_path_from(compile_time_vp, compile_time_manifest);
+
+    let runtime_manifest = runtime_manifest_dir();
+    let runtime_vp = runtime_manifest.join(vp_relative_path);
+    AbsolutePathBuf::new(runtime_vp).unwrap()
+}
+
 const fn default_true() -> bool {
     true
 }
@@ -207,6 +268,29 @@ enum TerminationState {
     TimedOut,
 }
 
+#[expect(
+    clippy::disallowed_types,
+    reason = "Path required for recursive fixture copy in test harness"
+)]
+fn copy_dir_recursive(src: &std::path::Path, dst: &std::path::Path) -> std::io::Result<()> {
+    std::fs::create_dir_all(dst)?;
+
+    for entry in std::fs::read_dir(src)? {
+        let entry = entry?;
+        let source_path = entry.path();
+        let target_path = dst.join(entry.file_name());
+        let file_type = entry.file_type()?;
+
+        if file_type.is_dir() {
+            copy_dir_recursive(&source_path, &target_path)?;
+        } else if file_type.is_file() {
+            std::fs::copy(&source_path, &target_path)?;
+        }
+    }
+
+    Ok(())
+}
+
 fn kill_process(child: &mut std::process::Child) {
     let _ = child.kill();
 }
@@ -222,7 +306,7 @@ fn kill_process(child: &mut std::process::Child) {
 fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture_name: &str) {
     // Copy the case directory to a temporary directory to avoid discovering workspace outside of the test case.
     let stage_path = tmpdir.join(fixture_name);
-    copy_dir(fixture_path, &stage_path).unwrap();
+    copy_dir_recursive(fixture_path, stage_path.as_path()).unwrap();
 
     let (workspace_root, _cwd) = find_workspace_root(&stage_path).unwrap();
 
@@ -238,13 +322,9 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
         Err(err) => panic!("Failed to read cases.toml for fixture {fixture_name}: {err}"),
     };
 
-    // Navigate from CARGO_MANIFEST_DIR to packages/tools at the repo root
-    #[expect(
-        clippy::disallowed_types,
-        reason = "Path required for CARGO_MANIFEST_DIR path manipulation via env! macro"
-    )]
-    let repo_root =
-        std::path::Path::new(env!("CARGO_MANIFEST_DIR")).parent().unwrap().parent().unwrap();
+    // Navigate from runtime CARGO_MANIFEST_DIR to packages/tools at the repo root.
+    let repo_root = runtime_manifest_dir();
+    let repo_root = repo_root.parent().unwrap().parent().unwrap();
     let test_bin_path = Arc::<OsStr>::from(
         repo_root.join("packages").join("tools").join("node_modules").join(".bin").into_os_string(),
     );
@@ -257,7 +337,7 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
         [
             // Include vp binary path to PATH so that e2e tests can run "vp ..." commands.
             {
-                let vp_path = AbsolutePath::new(env!("CARGO_BIN_EXE_vp")).unwrap();
+                let vp_path = resolve_runtime_vp_path();
                 let vp_dir = vp_path.parent().unwrap();
                 vp_dir.as_path().as_os_str().into()
             },
@@ -289,7 +369,7 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
 
         let e2e_stage_path = tmpdir.join(vite_str::format!("{fixture_name}_e2e_stage_{e2e_count}"));
         e2e_count += 1;
-        assert!(copy_dir(fixture_path, &e2e_stage_path).unwrap().is_empty());
+        copy_dir_recursive(fixture_path, e2e_stage_path.as_path()).unwrap();
 
         let e2e_stage_path_str = e2e_stage_path.as_path().to_str().unwrap();
 
@@ -530,20 +610,20 @@ fn run_case_inner(tmpdir: &AbsolutePath, fixture_path: &std::path::Path, fixture
     }
 }
 
-#[expect(clippy::disallowed_types, reason = "Path required by insta::glob! macro callback")]
-#[expect(
-    clippy::disallowed_methods,
-    reason = "current_dir needed because insta::glob! requires std PathBuf"
-)]
 fn main() {
     let filter = std::env::args().nth(1);
 
     let tmp_dir = tempfile::tempdir().unwrap();
-    let tmp_dir_path = AbsolutePathBuf::new(tmp_dir.path().canonicalize().unwrap()).unwrap();
+    let tmp_dir_path = AbsolutePathBuf::new(tmp_dir.path().to_path_buf()).unwrap();
 
-    let tests_dir = std::env::current_dir().unwrap().join("tests");
+    let fixtures_dir = runtime_manifest_dir().join("tests").join("e2e_snapshots").join("fixtures");
+    let mut fixture_paths = std::fs::read_dir(fixtures_dir)
+        .unwrap()
+        .map(|entry| entry.unwrap().path())
+        .collect::<Vec<_>>();
+    fixture_paths.sort();
 
-    insta::glob!(tests_dir, "e2e_snapshots/fixtures/*", |case_path| {
+    for case_path in &fixture_paths {
         run_case(&tmp_dir_path, case_path, filter.as_deref());
-    });
+    }
 }

crates/vite_task_bin/tests/e2e_snapshots/redact.rs

@@ -60,6 +60,10 @@ pub fn redact_e2e_output(mut output: String, workspace_root: &str) -> String {
     .unwrap();
     output = node_trace_warning_regex.replace_all(&output, "").into_owned();
 
+    // Remove nondeterministic mise warnings from shell startup in cross-platform runners.
+    let mise_warning_regex = regex::Regex::new(r"(?m)^mise WARN\s+.*\n?").unwrap();
+    output = mise_warning_regex.replace_all(&output, "").into_owned();
+
     // 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.