feat: run command with fspy

Author: fengmk2

Cargo.lock

@@ -41,6 +41,7 @@ criterion = { version = "0.7", features = ["html_reports"] }
 crossterm = { version = "0.29.0", features = ["event-stream"] }
 directories = "6.0.0"
 flate2 = "1.0.35"
+fspy = { git = "https://github.com/voidzero-dev/vite-task", rev = "d66556ab090fb5c5d85ecc7798a0fe9b6f1f26da" }
 futures-util = "0.3.31"
 hex = "0.4.3"
 httpmock = "0.7"

Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "vite_command"
+version = "0.0.0"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+fspy = { workspace = true }
+tokio = { workspace = true }
+tracing = { workspace = true }
+vite_error = { workspace = true }
+vite_path = { workspace = true }
+which = { workspace = true, features = ["tracing"] }
+
+[target.'cfg(not(target_os = "windows"))'.dependencies]
+nix = { workspace = true }
+
+[dev-dependencies]
+tempfile = { workspace = true }
+
+[lints]
+workspace = true

crates/vite_command/Cargo.toml

@@ -0,0 +1,263 @@
+use std::{
+    collections::HashMap,
+    process::{ExitStatus, Stdio},
+};
+
+use fspy::AccessMode;
+use tokio::process::Command;
+use vite_error::Error;
+use vite_path::AbsolutePath;
+
+/// Result of running a command with fspy tracking.
+#[derive(Debug)]
+pub struct FspyCommandResult {
+    /// The termination status of the command.
+    pub status: ExitStatus,
+    /// The filtered list of path accesses (path, mode).
+    pub path_accesses: Vec<(String, AccessMode)>,
+}
+
+/// Run a command with the given bin name, arguments, environment variables, and current working directory.
+///
+/// # Arguments
+///
+/// * `bin_name`: The name of the binary to run.
+/// * `args`: The arguments to pass to the binary.
+/// * `envs`: The custom environment variables to set for the command, will be merged with the system environment variables.
+/// * `cwd`: The current working directory for the command.
+///
+/// # Returns
+///
+/// Returns the exit status of the command.
+pub async fn run_command(
+    bin_name: &str,
+    args: &[&str],
+    envs: &HashMap<String, String>,
+    cwd: impl AsRef<AbsolutePath>,
+) -> Result<ExitStatus, Error> {
+    tracing::debug!("Running: {} {}", bin_name, args.join(" "));
+
+    // Resolve the command path using which crate
+    // If PATH is provided in envs, use which_in to search in custom paths
+    // Otherwise, use which to search in system PATH
+    let paths = envs.get("PATH");
+    let cwd = cwd.as_ref();
+    let bin_path = which::which_in(bin_name, paths, cwd)
+        .map_err(|_| Error::CannotFindBinaryPath(bin_name.into()))?;
+
+    let mut cmd = Command::new(bin_path);
+    cmd.args(args)
+        .envs(envs)
+        .current_dir(cwd)
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit());
+
+    // fix stdio streams on unix
+    #[cfg(unix)]
+    unsafe {
+        cmd.pre_exec(|| {
+            fix_stdio_streams();
+            Ok(())
+        });
+    }
+
+    let status = cmd.status().await?;
+    Ok(status)
+}
+
+/// Run a command with fspy tracking and filter the path accesses.
+///
+/// # Arguments
+///
+/// * `bin_name`: The name of the binary to run.
+/// * `args`: The arguments to pass to the binary.
+/// * `envs`: The custom environment variables to set for the command.
+/// * `cwd`: The current working directory for the command.
+/// * `filter`: A function that takes path string and access mode and returns true if it should be included.
+///
+/// # Returns
+///
+/// Returns a FspyCommandResult containing the exit status and filtered path accesses.
+pub async fn run_command_with_fspy<F>(
+    bin_name: &str,
+    args: &[&str],
+    envs: &HashMap<String, String>,
+    cwd: impl AsRef<AbsolutePath>,
+    filter: F,
+) -> Result<FspyCommandResult, Error>
+where
+    F: Fn(&str, AccessMode) -> bool,
+{
+    let mut cmd = fspy::Spy::global()?.new_command(bin_name);
+    cmd.args(args)
+        .envs(envs)
+        .current_dir(cwd.as_ref())
+        .stdin(Stdio::inherit())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit());
+
+    let child = cmd.spawn().await.map_err(|e| Error::Anyhow(e.into()))?;
+    let termination = child.wait_handle.await?;
+
+    // Filter path accesses using the provided filter function
+    let path_accesses: Vec<(String, AccessMode)> = termination
+        .path_accesses
+        .iter()
+        .filter_map(|access| {
+            tracing::debug!("Path access: {:?}", access);
+            // Convert NativeStr to OsStr to String
+            let path_os_str = access.path.to_cow_os_str();
+            let path_str = path_os_str.to_string_lossy();
+
+            if filter(&path_str, access.mode) {
+                Some((path_str.into_owned(), access.mode))
+            } else {
+                None
+            }
+        })
+        .collect();
+
+    Ok(FspyCommandResult { status: termination.status, path_accesses })
+}
+
+#[cfg(unix)]
+fn fix_stdio_streams() {
+    // libuv may mark stdin/stdout/stderr as close-on-exec, which interferes with Rust's subprocess spawning.
+    // As a workaround, we clear the FD_CLOEXEC flag on these file descriptors to prevent them from being closed when spawning child processes.
+    //
+    // For details see https://github.com/libuv/libuv/issues/2062
+    // Fixed by reference from https://github.com/electron/electron/pull/15555
+
+    use std::os::fd::BorrowedFd;
+
+    use nix::{
+        fcntl::{FcntlArg, FdFlag, fcntl},
+        libc::{STDERR_FILENO, STDIN_FILENO, STDOUT_FILENO},
+    };
+
+    // Safe function to clear FD_CLOEXEC flag
+    fn clear_cloexec(fd: BorrowedFd<'_>) {
+        // Borrow RawFd as BorrowedFd to satisfy AsFd constraint
+        if let Ok(flags) = fcntl(fd, FcntlArg::F_GETFD) {
+            let mut fd_flags = FdFlag::from_bits_retain(flags);
+            if fd_flags.contains(FdFlag::FD_CLOEXEC) {
+                fd_flags.remove(FdFlag::FD_CLOEXEC);
+                // Ignore errors: some fd may be closed
+                let _ = fcntl(fd, FcntlArg::F_SETFD(fd_flags));
+            }
+        }
+    }
+
+    // Clear FD_CLOEXEC on stdin, stdout, stderr
+    clear_cloexec(unsafe { BorrowedFd::borrow_raw(STDIN_FILENO) });
+    clear_cloexec(unsafe { BorrowedFd::borrow_raw(STDOUT_FILENO) });
+    clear_cloexec(unsafe { BorrowedFd::borrow_raw(STDERR_FILENO) });
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::{TempDir, tempdir};
+    use vite_path::AbsolutePathBuf;
+
+    use super::*;
+
+    fn create_temp_dir() -> TempDir {
+        tempdir().expect("Failed to create temp directory")
+    }
+
+    mod run_command_tests {
+
+        use super::*;
+
+        #[tokio::test]
+        async fn test_run_command_and_find_binary_path() {
+            let temp_dir = create_temp_dir();
+            let temp_dir_path = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
+            let envs = HashMap::from([(
+                "PATH".to_string(),
+                std::env::var_os("PATH").unwrap_or_default().into_string().unwrap(),
+            )]);
+            let result = run_command("npm", &["--version"], &envs, &temp_dir_path).await;
+            assert!(result.is_ok(), "Should run command successfully, but got error: {:?}", result);
+        }
+
+        #[tokio::test]
+        async fn test_run_command_and_not_find_binary_path() {
+            let temp_dir = create_temp_dir();
+            let temp_dir_path = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
+            let envs = HashMap::from([(
+                "PATH".to_string(),
+                std::env::var_os("PATH").unwrap_or_default().into_string().unwrap(),
+            )]);
+            let result = run_command("npm-not-exists", &["--version"], &envs, &temp_dir_path).await;
+            assert!(result.is_err(), "Should not find binary path, but got: {:?}", result);
+            assert_eq!(
+                result.unwrap_err().to_string(),
+                "Cannot find binary path for command 'npm-not-exists'"
+            );
+        }
+    }
+
+    mod run_command_with_fspy_tests {
+        use super::*;
+
+        #[tokio::test]
+        async fn test_run_command_with_fspy_with_path_filter() {
+            let temp_dir = create_temp_dir();
+            let temp_dir_path = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
+            let envs = HashMap::from([(
+                "PATH".to_string(),
+                std::env::var_os("PATH").unwrap_or_default().into_string().unwrap(),
+            )]);
+            // Test with a filter that only accepts paths containing "foo"
+            let result = run_command_with_fspy(
+                "node",
+                &["-e", "require('fs').mkdirSync('foo/bar/baz', { recursive: true }); require('fs').writeFileSync('foo/bar/baz/package.json', '{}');" ],
+                &envs,
+                &temp_dir_path,
+                |path, _| path.contains("foo/bar/baz/package.json"),
+            )
+            .await;
+            assert!(result.is_ok(), "Should run command successfully, but got error: {:?}", result);
+            let cmd_result = result.unwrap();
+            assert!(cmd_result.status.success());
+            // Verify that only paths containing "foo" are included
+            for (path, _) in &cmd_result.path_accesses {
+                assert!(
+                    path.contains("foo/bar/baz/package.json"),
+                    "Path {} should contain 'foo/bar/baz/package.json'",
+                    path
+                );
+            }
+            println!("cmd_result: {:?}", cmd_result);
+            assert_eq!(cmd_result.path_accesses.len(), 1);
+        }
+
+        #[tokio::test]
+        async fn test_run_command_with_fspy_and_not_find_binary_path() {
+            let temp_dir = create_temp_dir();
+            let temp_dir_path = AbsolutePathBuf::new(temp_dir.path().to_path_buf()).unwrap();
+            let envs = HashMap::from([(
+                "PATH".to_string(),
+                std::env::var_os("PATH").unwrap_or_default().into_string().unwrap(),
+            )]);
+            let result = run_command_with_fspy(
+                "npm-not-exists",
+                &["--version"],
+                &envs,
+                &temp_dir_path,
+                |_, _| true,
+            )
+            .await;
+            assert!(result.is_err(), "Should not find binary path, but got: {:?}", result);
+            assert!(
+                result
+                    .err()
+                    .unwrap()
+                    .to_string()
+                    .contains("could not resolve the full path of program '\"npm-not-exists\"'")
+            );
+        }
+    }
+}