//! Utility to compute the current Git diff for the working directory.//!//! The implementation mirrors the behaviour of the TypeScript version in//! `codex-cli`: it returns the diff for tracked changes as well as any//! untracked files. When the current directory is not inside a Git//! repository, the function returns `Ok((false, String::new()))`.use std::path::Path;use std::time::Duration;use crate::workspace_command::WorkspaceCommand;use crate::workspace_command::WorkspaceCommandExecutor;use crate::workspace_command::WorkspaceCommandOutput;use codex_git_utils::FsmonitorOverride;use codex_git_utils::FsmonitorProbeRunner;use codex_git_utils::detect_fsmonitor_override;const DIFF_COMMAND_TIMEOUT: Duration = Duration::from_secs(/*secs*/ 30);const DISABLE_HOOKS_CONFIG: &str = if cfg!(windows) {    "core.hooksPath=NUL"} else {    "core.hooksPath=/dev/null"};const EXECUTABLE_FILTER_CONFIG_PATTERN: &str = r"^filter\..*\.(clean|process)$";// `/diff` may execute Git through a remote workspace, so git-utils owns the// probe policy while this adapter keeps command execution in the TUI layer.// WorkspaceCommand bounds each call; `/diff` has no aggregate command deadline.struct WorkspaceFsmonitorProbeRunner<'a> {    runner: &'a dyn WorkspaceCommandExecutor,    cwd: &'a Path,}impl FsmonitorProbeRunner for WorkspaceFsmonitorProbeRunner<'_> {    async fn run_probe(&mut self, args: &[&str]) -> Option<Vec<u8>> {        let argv = ["git"].into_iter().chain(args.iter().copied());        let command = WorkspaceCommand::new(argv).cwd(self.cwd.to_path_buf());        match self.runner.run(command).await {            Ok(output) if output.success() => Some(output.stdout.into_bytes()),            _ => None,        }    }}/// Return value of [`get_git_diff`].////// * `bool` – Whether the current working directory is inside a Git repo./// * `String` – The concatenated diff (may be empty).pub(crate) async fn get_git_diff(    runner: &dyn WorkspaceCommandExecutor,    cwd: &Path,) -> Result<(bool, String), String> {    // First check if we are inside a Git repository.    if !inside_git_repo(runner, cwd).await? {        return Ok((false, String::new()));    }    // Probe once per `/diff` and reuse the result for all subsequent Git commands.    let mut probe_runner = WorkspaceFsmonitorProbeRunner { runner, cwd };    let fsmonitor = detect_fsmonitor_override(&mut probe_runner).await;    // Keep `/diff` informational: repository configuration must not select executable diff helpers.    let diff_config_overrides = diff_filter_config_overrides(runner, cwd, fsmonitor).await?;    let (tracked_diff_res, untracked_output_res) = tokio::join!(        run_git_capture_diff(            runner,            cwd,            fsmonitor,            &diff_config_overrides,            &[                "diff",                "--no-textconv",                "--no-ext-diff",                "--submodule=short",                "--ignore-submodules=dirty",                "--color",            ]        ),        run_git_capture_stdout(            runner,            cwd,            fsmonitor,            &["ls-files", "--others", "--exclude-standard"]        ),    );    let tracked_diff = tracked_diff_res?;    let untracked_output = untracked_output_res?;    let mut untracked_diff = String::new();    let null_device: &Path = if cfg!(windows) {        Path::new("NUL")    } else {        Path::new("/dev/null")    };    let null_path = null_device.to_str().unwrap_or("/dev/null");    for file in untracked_output        .split('\n')        .map(str::trim)        .filter(|s| !s.is_empty())    {        let args = [            "diff",            "--no-textconv",            "--no-ext-diff",            "--submodule=short",            "--ignore-submodules=dirty",            "--color",            "--no-index",            "--",            null_path,            file,        ];        let diff =            run_git_capture_diff(runner, cwd, fsmonitor, &diff_config_overrides, &args).await?;        untracked_diff.push_str(&diff);    }    Ok((true, format!("{tracked_diff}{untracked_diff}")))}/// Helper that executes `git` with the given `args` and returns `stdout` as a/// UTF-8 string. Any non-zero exit status is considered an *error*.async fn run_git_capture_stdout(    runner: &dyn WorkspaceCommandExecutor,    cwd: &Path,    fsmonitor: FsmonitorOverride,    args: &[&str],) -> Result<String, String> {    let output = run_git_command(runner, cwd, fsmonitor, &[], args).await?;    if output.success() {        Ok(output.stdout)    } else {        Err(format!(            "git {:?} failed with status {}",            args, output.exit_code        ))    }}/// Like [`run_git_capture_stdout`] but treats exit status 1 as success and/// returns stdout. Git returns 1 for diffs when differences are present.async fn run_git_capture_diff(    runner: &dyn WorkspaceCommandExecutor,    cwd: &Path,    fsmonitor: FsmonitorOverride,    config_overrides: &[(String, String)],    args: &[&str],) -> Result<String, String> {    let output = run_git_command(runner, cwd, fsmonitor, config_overrides, args).await?;    if output.success() || output.exit_code == 1 {        Ok(output.stdout)    } else {        Err(format!(            "git {:?} failed with status {}",            args, output.exit_code        ))    }}/// Return Git configuration overrides that prevent configured filter drivers/// from executing while generating diffs.async fn diff_filter_config_overrides(    runner: &dyn WorkspaceCommandExecutor,    cwd: &Path,    fsmonitor: FsmonitorOverride,) -> Result<Vec<(String, String)>, String> {    let args = [        "config",        "--null",        "--name-only",        "--get-regexp",        EXECUTABLE_FILTER_CONFIG_PATTERN,    ];    let output = run_git_command(runner, cwd, fsmonitor, &[], &args).await?;    if output.exit_code != 0 && output.exit_code != 1 {        return Err(format!(            "git {:?} failed with status {}",            args, output.exit_code        ));    }    let mut drivers = output        .stdout        .split('\0')        .filter_map(|key| {            key.strip_suffix(".clean")                .or_else(|| key.strip_suffix(".process"))        })        .map(str::to_string)        .collect::<Vec<_>>();    drivers.sort();    drivers.dedup();    Ok(drivers        .into_iter()        .flat_map(|driver| {            [                (format!("{driver}.clean"), String::new()),                (format!("{driver}.process"), String::new()),                (format!("{driver}.required"), "false".to_string()),            ]        })        .collect())}/// Determine if the current directory is inside a Git repository.async fn inside_git_repo(    runner: &dyn WorkspaceCommandExecutor,    cwd: &Path,) -> Result<bool, String> {    // `rev-parse` does not inspect the worktree, and probing before this check    // would also run extra Git commands outside repositories.    let output = run_git_command(        runner,        cwd,        FsmonitorOverride::Disabled,        &[],        &["rev-parse", "--is-inside-work-tree"],    )    .await?;    Ok(output.success())}async fn run_git_command(    runner: &dyn WorkspaceCommandExecutor,    cwd: &Path,    fsmonitor: FsmonitorOverride,    config_overrides: &[(String, String)],    args: &[&str],) -> Result<WorkspaceCommandOutput, String> {    let argv = [        "git",        "-c",        fsmonitor.git_config_arg(),        "-c",        DISABLE_HOOKS_CONFIG,    ]    .into_iter()    .chain(args.iter().copied());    let mut command = WorkspaceCommand::new(argv)        .cwd(cwd.to_path_buf())        .timeout(DIFF_COMMAND_TIMEOUT)        .disable_output_cap();    if !config_overrides.is_empty() {        command = command.env("GIT_CONFIG_COUNT", config_overrides.len().to_string());        for (index, (key, value)) in config_overrides.iter().enumerate() {            command = command                .env(format!("GIT_CONFIG_KEY_{index}"), key)                .env(format!("GIT_CONFIG_VALUE_{index}"), value);        }    }    runner.run(command).await.map_err(|err| err.to_string())}#[cfg(test)]mod tests {    use super::*;    use crate::workspace_command::WorkspaceCommandError;    use pretty_assertions::assert_eq;    use std::collections::HashMap;    use std::collections::VecDeque;    #[cfg(unix)]    use std::fs;    use std::future::Future;    #[cfg(unix)]    use std::os::unix::fs::PermissionsExt;    use std::path::PathBuf;    use std::pin::Pin;    #[cfg(unix)]    use std::process::Command as ProcessCommand;    use std::sync::Mutex;    #[tokio::test]    async fn get_git_diff_returns_not_git_for_non_git_cwd() {        let cwd = PathBuf::from("/workspace");        let runner = FakeRunner::new(vec![response(            git_command(                FsmonitorOverride::Disabled,                &["rev-parse", "--is-inside-work-tree"],            ),            /*exit_code*/ 128,            "",        )]);        let result = get_git_diff(&runner, &cwd).await;        assert_eq!(result, Ok((false, String::new())));        assert_command_metadata(&runner.commands(), &cwd);    }    #[tokio::test]    async fn get_git_diff_disables_helpers_for_tracked_and_untracked_diffs() {        let cwd = PathBuf::from("/workspace");        let runner = FakeRunner::new(vec![            response(                git_command(                    FsmonitorOverride::Disabled,                    &["rev-parse", "--is-inside-work-tree"],                ),                /*exit_code*/ 0,                "true\n",            ),            response(                git_probe_command(&["config", "--null", "--get", "core.fsmonitor"]),                /*exit_code*/ 0,                "/tmp/fsmonitor-helper\0",            ),            response(                git_probe_command(&[                    "config",                    "--null",                    "--type=bool",                    "--fixed-value",                    "--get",                    "core.fsmonitor",                    "/tmp/fsmonitor-helper",                ]),                /*exit_code*/ 128,                "",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &[                        "config",                        "--null",                        "--name-only",                        "--get-regexp",                        EXECUTABLE_FILTER_CONFIG_PATTERN,                    ],                ),                /*exit_code*/ 0,                "filter.evil.clean\0filter.evil.process\0",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &[                        "diff",                        "--no-textconv",                        "--no-ext-diff",                        "--submodule=short",                        "--ignore-submodules=dirty",                        "--color",                    ],                ),                /*exit_code*/ 1,                "tracked\n",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &["ls-files", "--others", "--exclude-standard"],                ),                /*exit_code*/ 0,                "new.txt\n",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &[                        "diff",                        "--no-textconv",                        "--no-ext-diff",                        "--submodule=short",                        "--ignore-submodules=dirty",                        "--color",                        "--no-index",                        "--",                        null_device(),                        "new.txt",                    ],                ),                /*exit_code*/ 1,                "untracked\n",            ),        ]);        let result = get_git_diff(&runner, &cwd).await;        assert_eq!(result, Ok((true, "tracked\nuntracked\n".to_string())));        let commands = runner.commands();        assert_command_metadata(&commands, &cwd);        assert_eq!(commands[4].env, filter_override_env("filter.evil"));        assert_eq!(commands[6].env, filter_override_env("filter.evil"));    }    #[tokio::test]    async fn get_git_diff_preserves_builtin_fsmonitor_for_diff_workflow() {        let cwd = PathBuf::from("/workspace");        let runner = FakeRunner::new(vec![            response(                git_command(                    FsmonitorOverride::Disabled,                    &["rev-parse", "--is-inside-work-tree"],                ),                /*exit_code*/ 0,                "true\n",            ),            response(                git_probe_command(&["config", "--null", "--get", "core.fsmonitor"]),                /*exit_code*/ 0,                "true\0",            ),            response(                git_probe_command(&["version", "--build-options"]),                /*exit_code*/ 0,                "feature: fsmonitor--daemon\n",            ),            response(                git_command(                    FsmonitorOverride::BuiltIn,                    &[                        "config",                        "--null",                        "--name-only",                        "--get-regexp",                        EXECUTABLE_FILTER_CONFIG_PATTERN,                    ],                ),                /*exit_code*/ 1,                "",            ),            response(                git_command(                    FsmonitorOverride::BuiltIn,                    &[                        "diff",                        "--no-textconv",                        "--no-ext-diff",                        "--submodule=short",                        "--ignore-submodules=dirty",                        "--color",                    ],                ),                /*exit_code*/ 1,                "tracked\n",            ),            response(                git_command(                    FsmonitorOverride::BuiltIn,                    &["ls-files", "--others", "--exclude-standard"],                ),                /*exit_code*/ 0,                "new.txt\n",            ),            response(                git_command(                    FsmonitorOverride::BuiltIn,                    &[                        "diff",                        "--no-textconv",                        "--no-ext-diff",                        "--submodule=short",                        "--ignore-submodules=dirty",                        "--color",                        "--no-index",                        "--",                        null_device(),                        "new.txt",                    ],                ),                /*exit_code*/ 1,                "untracked\n",            ),        ]);        let result = get_git_diff(&runner, &cwd).await;        assert_eq!(result, Ok((true, "tracked\nuntracked\n".to_string())));        assert_command_metadata(&runner.commands(), &cwd);    }    #[tokio::test]    async fn get_git_diff_accepts_diff_exit_code_one() {        let cwd = PathBuf::from("/workspace");        let runner = FakeRunner::new(vec![            response(                git_command(                    FsmonitorOverride::Disabled,                    &["rev-parse", "--is-inside-work-tree"],                ),                /*exit_code*/ 0,                "true\n",            ),            response(                git_probe_command(&["config", "--null", "--get", "core.fsmonitor"]),                /*exit_code*/ 1,                "",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &[                        "config",                        "--null",                        "--name-only",                        "--get-regexp",                        EXECUTABLE_FILTER_CONFIG_PATTERN,                    ],                ),                /*exit_code*/ 1,                "",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &[                        "diff",                        "--no-textconv",                        "--no-ext-diff",                        "--submodule=short",                        "--ignore-submodules=dirty",                        "--color",                    ],                ),                /*exit_code*/ 1,                "tracked\n",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &["ls-files", "--others", "--exclude-standard"],                ),                /*exit_code*/ 0,                "",            ),        ]);        let result = get_git_diff(&runner, &cwd).await;        assert_eq!(result, Ok((true, "tracked\n".to_string())));        assert_command_metadata(&runner.commands(), &cwd);    }    #[tokio::test]    async fn get_git_diff_rejects_unexpected_git_diff_status() {        let cwd = PathBuf::from("/workspace");        let runner = FakeRunner::new(vec![            response(                git_command(                    FsmonitorOverride::Disabled,                    &["rev-parse", "--is-inside-work-tree"],                ),                /*exit_code*/ 0,                "true\n",            ),            response(                git_probe_command(&["config", "--null", "--get", "core.fsmonitor"]),                /*exit_code*/ 1,                "",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &[                        "config",                        "--null",                        "--name-only",                        "--get-regexp",                        EXECUTABLE_FILTER_CONFIG_PATTERN,                    ],                ),                /*exit_code*/ 1,                "",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &[                        "diff",                        "--no-textconv",                        "--no-ext-diff",                        "--submodule=short",                        "--ignore-submodules=dirty",                        "--color",                    ],                ),                /*exit_code*/ 2,                "",            ),            response(                git_command(                    FsmonitorOverride::Disabled,                    &["ls-files", "--others", "--exclude-standard"],                ),                /*exit_code*/ 0,                "",            ),        ]);        let error = get_git_diff(&runner, &cwd)            .await            .expect_err("unexpected git diff status should fail");        assert_eq!(            error,            "git [\"diff\", \"--no-textconv\", \"--no-ext-diff\", \"--submodule=short\", \"--ignore-submodules=dirty\", \"--color\"] failed with status 2"        );        assert_command_metadata(&runner.commands(), &cwd);    }    #[cfg(unix)]    #[tokio::test]    async fn get_git_diff_does_not_execute_configured_filters_fsmonitor_or_hooks() {        let tempdir = tempfile::tempdir().expect("create temp directory");        let repo = tempdir.path().join("repo");        fs::create_dir(&repo).expect("create test repository directory");        run_git_setup(&repo, &["init", "-q"]);        run_git_setup(&repo, &["config", "user.name", "test"]);        run_git_setup(&repo, &["config", "user.email", "test@example.com"]);        fs::write(repo.join(".gitattributes"), "*.txt filter=x=y\n").expect("write attributes");        fs::write(repo.join("tracked.txt"), "before\n").expect("write tracked file");        fs::write(repo.join("unchanged.txt"), "unchanged\n").expect("write unchanged file");        run_git_setup(            &repo,            &["add", ".gitattributes", "tracked.txt", "unchanged.txt"],        );        run_git_setup(&repo, &["commit", "-qm", "initial"]);        let filter_helper = tempdir.path().join("filter-helper.sh");        let fsmonitor_helper = tempdir.path().join("fsmonitor-helper.sh");        let hooks_dir = tempdir.path().join("hooks");        let hook_helper = hooks_dir.join("post-index-change");        fs::create_dir(&hooks_dir).expect("create hooks directory");        write_marker_helper(&filter_helper);        write_marker_helper(&fsmonitor_helper);        write_marker_helper(&hook_helper);        run_git_setup(            &repo,            &[                "config",                "filter.x=y.clean",                filter_helper.to_str().expect("filter helper path"),            ],        );        run_git_setup(            &repo,            &[                "config",                "filter.x=y.process",                filter_helper.to_str().expect("filter helper path"),            ],        );        run_git_setup(&repo, &["config", "filter.x=y.required", "true"]);        run_git_setup(            &repo,            &[                "config",                "core.fsmonitor",                fsmonitor_helper.to_str().expect("fsmonitor helper path"),            ],        );        run_git_setup(            &repo,            &[                "config",                "core.hooksPath",                hooks_dir.to_str().expect("hooks directory path"),            ],        );        std::thread::sleep(Duration::from_secs(/*secs*/ 1));        fs::write(repo.join("unchanged.txt"), "unchanged\n").expect("refresh unchanged file");        fs::write(repo.join("tracked.txt"), "after\n").expect("modify tracked file");        let result = get_git_diff(&LocalRunner, &repo)            .await            .expect("generate diff without invoking helpers");        assert_eq!(            (                result.1.contains("before"),                result.1.contains("after"),                filter_helper.with_extension("sh.ran").exists(),                fsmonitor_helper.with_extension("sh.ran").exists(),                hook_helper.with_extension("sh.ran").exists(),            ),            (true, true, false, false, false),            "diff:\n{}",            result.1        );    }    #[cfg(unix)]    #[tokio::test]    async fn get_git_diff_does_not_execute_helpers_while_checking_dirty_submodules() {        let tempdir = tempfile::tempdir().expect("create temp directory");        let child = tempdir.path().join("child");        let repo = tempdir.path().join("repo");        fs::create_dir(&child).expect("create child repository directory");        fs::create_dir(&repo).expect("create parent repository directory");        run_git_setup(&child, &["init", "-q"]);        run_git_setup(&child, &["config", "user.name", "test"]);        run_git_setup(&child, &["config", "user.email", "test@example.com"]);        fs::write(child.join(".gitattributes"), "*.txt filter=evil\n")            .expect("write child attributes");        fs::write(child.join("tracked.txt"), "before\n").expect("write child tracked file");        run_git_setup(&child, &["add", ".gitattributes", "tracked.txt"]);        run_git_setup(&child, &["commit", "-qm", "initial"]);        run_git_setup(&repo, &["init", "-q"]);        run_git_setup(&repo, &["config", "user.name", "test"]);        run_git_setup(&repo, &["config", "user.email", "test@example.com"]);        run_git_setup(            &repo,            &[                "-c",                "protocol.file.allow=always",                "submodule",                "add",                "-q",                child.to_str().expect("child repository path"),                "child",            ],        );        run_git_setup(&repo, &["commit", "-qm", "add submodule"]);        let helper = tempdir.path().join("submodule-helper.sh");        write_marker_helper(&helper);        let checkout = repo.join("child");        run_git_setup(            &checkout,            &[                "config",                "filter.evil.clean",                helper.to_str().expect("submodule helper path"),            ],        );        run_git_setup(&checkout, &["config", "filter.evil.required", "true"]);        std::thread::sleep(Duration::from_secs(/*secs*/ 1));        fs::write(checkout.join("tracked.txt"), "before\n").expect("refresh child tracked file");        let result = get_git_diff(&LocalRunner, &repo)            .await            .expect("generate diff without inspecting submodule worktrees");        assert_eq!(            (result.1, helper.with_extension("sh.ran").exists()),            (String::new(), false)        );    }    fn git_command(fsmonitor: FsmonitorOverride, args: &[&str]) -> Vec<String> {        [            "git",            "-c",            fsmonitor.git_config_arg(),            "-c",            DISABLE_HOOKS_CONFIG,        ]        .into_iter()        .chain(args.iter().copied())        .map(str::to_string)        .collect()    }    fn git_probe_command(args: &[&str]) -> Vec<String> {        ["git"]            .into_iter()            .chain(args.iter().copied())            .map(str::to_string)            .collect()    }    fn filter_override_env(driver: &str) -> HashMap<String, Option<String>> {        HashMap::from([            ("GIT_CONFIG_COUNT".to_string(), Some("3".to_string())),            (                "GIT_CONFIG_KEY_0".to_string(),                Some(format!("{driver}.clean")),            ),            ("GIT_CONFIG_VALUE_0".to_string(), Some(String::new())),            (                "GIT_CONFIG_KEY_1".to_string(),                Some(format!("{driver}.process")),            ),            ("GIT_CONFIG_VALUE_1".to_string(), Some(String::new())),            (                "GIT_CONFIG_KEY_2".to_string(),                Some(format!("{driver}.required")),            ),            ("GIT_CONFIG_VALUE_2".to_string(), Some("false".to_string())),        ])    }    fn response(argv: Vec<String>, exit_code: i32, stdout: &str) -> FakeResponse {        FakeResponse {            argv,            output: WorkspaceCommandOutput {                exit_code,                stdout: stdout.to_string(),                stderr: String::new(),            },        }    }    fn null_device() -> &'static str {        if cfg!(windows) { "NUL" } else { "/dev/null" }    }    #[cfg(unix)]    fn run_git_setup(cwd: &Path, args: &[&str]) {        let output = ProcessCommand::new("git")            .args(args)            .current_dir(cwd)            .output()            .expect("run git setup command");        assert_eq!(            output.status.code(),            Some(0),            "git setup command failed: {args:?}\nstdout:\n{}\nstderr:\n{}",            String::from_utf8_lossy(&output.stdout),            String::from_utf8_lossy(&output.stderr)        );    }    #[cfg(unix)]    fn write_marker_helper(path: &Path) {        fs::write(path, "#!/bin/sh\nprintf ran >> \"$0.ran\"\nexit 1\n")            .expect("write helper script");        let mut permissions = fs::metadata(path)            .expect("read helper metadata")            .permissions();        permissions.set_mode(/*mode*/ 0o755);        fs::set_permissions(path, permissions).expect("make helper executable");    }    fn assert_command_metadata(commands: &[WorkspaceCommand], cwd: &Path) {        for command in commands {            assert_eq!(command.cwd.as_deref(), Some(cwd));            if matches!(                command.argv.get(1).map(String::as_str),                Some("config" | "version")            ) {                assert_eq!(command.env, HashMap::new());                assert_eq!(command.timeout, Duration::from_secs(/*secs*/ 5));                assert_eq!(command.output_bytes_cap, 64 * 1024);                assert_eq!(command.disable_output_cap, false);            } else {                assert_eq!(command.timeout, DIFF_COMMAND_TIMEOUT);                assert_eq!(command.disable_output_cap, true);            }        }    }    struct FakeResponse {        argv: Vec<String>,        output: WorkspaceCommandOutput,    }    struct FakeRunner {        responses: Mutex<VecDeque<FakeResponse>>,        commands: Mutex<Vec<WorkspaceCommand>>,    }    impl FakeRunner {        fn new(responses: Vec<FakeResponse>) -> Self {            Self {                responses: Mutex::new(responses.into()),                commands: Mutex::new(Vec::new()),            }        }        fn commands(&self) -> Vec<WorkspaceCommand> {            assert_eq!(                self.responses.lock().expect("responses lock").len(),                0,                "unused fake responses"            );            self.commands.lock().expect("commands lock").clone()        }    }    impl WorkspaceCommandExecutor for FakeRunner {        fn run(            &self,            command: WorkspaceCommand,        ) -> Pin<            Box<                dyn Future<Output = Result<WorkspaceCommandOutput, WorkspaceCommandError>>                    + Send                    + '_,            >,        > {            Box::pin(async move {                let mut responses = self.responses.lock().expect("responses lock");                let response = responses.pop_front().expect("missing fake response");                assert_eq!(command.argv, response.argv);                self.commands.lock().expect("commands lock").push(command);                Ok(response.output)            })        }    }    #[cfg(unix)]    struct LocalRunner;    #[cfg(unix)]    impl WorkspaceCommandExecutor for LocalRunner {        fn run(            &self,            command: WorkspaceCommand,        ) -> Pin<            Box<                dyn Future<Output = Result<WorkspaceCommandOutput, WorkspaceCommandError>>                    + Send                    + '_,            >,        > {            Box::pin(async move {                let mut process = ProcessCommand::new(&command.argv[0]);                process                    .args(&command.argv[1..])                    .current_dir(command.cwd.expect("test command cwd"));                for (key, value) in command.env {                    match value {                        Some(value) => {                            process.env(key, value);                        }                        None => {                            process.env_remove(key);                        }                    }                }                let output = process.output().expect("run test command");                Ok(WorkspaceCommandOutput {                    exit_code: output.status.code().expect("test command exit code"),                    stdout: String::from_utf8(output.stdout).expect("utf8 stdout"),                    stderr: String::from_utf8(output.stderr).expect("utf8 stderr"),                })            })        }    }}