feat(port): port ProcessExecutor.php

1 files changed, 766 insertions, 0 deletions

diff --git a/crates/shirabe/src/util/process_executor.rs b/crates/shirabe/src/util/process_executor.rs
index 22cce5b..29c2bfa 100644
--- a/crates/shirabe/src/util/process_executor.rs
+++ b/crates/shirabe/src/util/process_executor.rs
@@ -1 +1,767 @@
 //! ref: composer/src/Composer/Util/ProcessExecutor.php
+
+use anyhow::Result;
+use indexmap::IndexMap;
+use std::sync::{LazyLock, Mutex};
+
+use shirabe_external_packages::composer::pcre::preg::Preg;
+use shirabe_external_packages::react::promise::promise::Promise;
+use shirabe_external_packages::react::promise::promise_interface::PromiseInterface;
+use shirabe_external_packages::seld::signal::signal_handler::SignalHandler;
+use shirabe_external_packages::symfony::component::process::exception::process_signaled_exception::ProcessSignaledException;
+use shirabe_external_packages::symfony::component::process::exception::runtime_exception::RuntimeException as SymfonyProcessRuntimeException;
+use shirabe_external_packages::symfony::component::process::executable_finder::ExecutableFinder;
+use shirabe_external_packages::symfony::component::process::process::Process;
+use shirabe_php_shim::{
+    array_intersect, array_map, call_user_func, defined, escapeshellarg, explode, implode,
+    in_array, is_array, is_callable, is_dir, is_numeric, is_string, max, min, rtrim, sprintf,
+    str_replace, strcspn, strlen, strpbrk, strtolower, strtr, substr_replace, trim, usleep,
+    LogicException, PhpMixed, RuntimeException,
+};
+
+use crate::io::io_interface::IOInterface;
+use crate::util::github::GitHub;
+use crate::util::platform::Platform;
+
+static EXECUTABLES: LazyLock<Mutex<IndexMap<String, String>>> =
+    LazyLock::new(|| Mutex::new(IndexMap::new()));
+
+static TIMEOUT: LazyLock<Mutex<i64>> = LazyLock::new(|| Mutex::new(300));
+
+#[derive(Debug)]
+pub struct ProcessExecutor {
+    /// @var bool
+    pub(crate) capture_output: bool,
+    /// @var string
+    pub(crate) error_output: String,
+    /// @var ?IOInterface
+    pub(crate) io: Option<Box<dyn IOInterface>>,
+    /// @phpstan-var array<int, array<string, mixed>>
+    jobs: IndexMap<i64, Job>,
+    /// @var int
+    running_jobs: i64,
+    /// @var int
+    max_jobs: i64,
+    /// @var int
+    id_gen: i64,
+    /// @var bool
+    allow_async: bool,
+}
+
+#[derive(Debug)]
+struct Job {
+    id: i64,
+    status: i64,
+    command: PhpMixed,
+    cwd: Option<String>,
+    process: Option<Process>,
+    resolve: Option<Box<dyn Fn(PhpMixed) + Send + Sync>>,
+    reject: Option<Box<dyn Fn(PhpMixed) + Send + Sync>>,
+}
+
+impl ProcessExecutor {
+    const STATUS_QUEUED: i64 = 1;
+    const STATUS_STARTED: i64 = 2;
+    const STATUS_COMPLETED: i64 = 3;
+    const STATUS_FAILED: i64 = 4;
+    const STATUS_ABORTED: i64 = 5;
+
+    const BUILTIN_CMD_COMMANDS: [&'static str; 47] = [
+        "assoc", "break", "call", "cd", "chdir", "cls", "color", "copy", "date", "del", "dir",
+        "echo", "endlocal", "erase", "exit", "for", "ftype", "goto", "help", "if", "label", "md",
+        "mkdir", "mklink", "move", "path", "pause", "popd", "prompt", "pushd", "rd", "rem", "ren",
+        "rename", "rmdir", "set", "setlocal", "shift", "start", "time", "title", "type", "ver",
+        "vol",
+        // unused slots to make 47 above explicit
+        "", "", "",
+    ];
+
+    const GIT_CMDS_NEED_GIT_DIR: &'static [&'static [&'static str]] = &[
+        &["show"],
+        &["log"],
+        &["branch"],
+        &["remote", "set-url"],
+    ];
+
+    pub fn new(io: Option<Box<dyn IOInterface>>, _: Option<()>) -> Self {
+        let mut this = Self {
+            capture_output: false,
+            error_output: String::new(),
+            io,
+            jobs: IndexMap::new(),
+            running_jobs: 0,
+            max_jobs: 10,
+            id_gen: 0,
+            allow_async: false,
+        };
+        this.reset_max_jobs();
+        this
+    }
+
+    /// runs a process on the commandline
+    ///
+    /// @param  string|non-empty-list<string> $command the command to execute
+    /// @param  mixed   $output  the output will be written into this var if passed by ref
+    ///                          if a callable is passed it will be used as output handler
+    /// @param  null|string $cwd     the working directory
+    /// @return int     statuscode
+    pub fn execute(
+        &mut self,
+        command: PhpMixed,
+        output: Option<&mut PhpMixed>,
+        cwd: Option<&str>,
+    ) -> Result<i64> {
+        // PHP: func_num_args() > 1
+        let has_output_arg = output.is_some();
+        if has_output_arg {
+            return self.do_execute(command, cwd, false, output);
+        }
+
+        self.do_execute(command, cwd, false, None)
+    }
+
+    /// runs a process on the commandline in TTY mode
+    pub fn execute_tty(&mut self, command: PhpMixed, cwd: Option<&str>) -> Result<i64> {
+        if Platform::is_tty() {
+            return self.do_execute(command, cwd, true, None);
+        }
+
+        self.do_execute(command, cwd, false, None)
+    }
+
+    /// @param  string|non-empty-list<string> $command
+    /// @param  array<string, string>|null $env
+    fn run_process(
+        &mut self,
+        command: PhpMixed,
+        cwd: Option<&str>,
+        env: Option<IndexMap<String, String>>,
+        tty: bool,
+        mut output: Option<&mut PhpMixed>,
+    ) -> Result<Option<i64>> {
+        // On Windows, we don't rely on the OS to find the executable if possible to avoid lookups
+        // in the current directory which could be untrusted. Instead we use the ExecutableFinder.
+
+        let mut process: Process;
+        if is_string(&command) {
+            let mut command_str = command.as_string().unwrap_or("").to_string();
+            if Platform::is_windows() {
+                if let Some(m) = Preg::is_match_strict_groups(r"{^([^:/\\]++) }", &command_str) {
+                    command_str = substr_replace(
+                        &command_str,
+                        &Self::escape(PhpMixed::String(Self::get_executable(
+                            m.get(1).cloned().unwrap_or_default().as_str(),
+                        ))),
+                        0,
+                        strlen(m.get(1).cloned().unwrap_or_default().as_str()) as usize,
+                    );
+                }
+            }
+
+            process = Process::from_shell_commandline(
+                &command_str,
+                cwd,
+                env.clone(),
+                None,
+                Self::get_timeout(),
+            );
+        } else if let PhpMixed::List(ref list) = command {
+            let mut cmd_vec: Vec<String> = list
+                .iter()
+                .map(|v| v.as_string().unwrap_or("").to_string())
+                .collect();
+            if Platform::is_windows()
+                && strlen(&cmd_vec[0]) == strcspn(&cmd_vec[0], ":/\\") as i64
+            {
+                cmd_vec[0] = Self::get_executable(&cmd_vec[0]);
+            }
+
+            process = Process::new(cmd_vec, cwd, env, None, Self::get_timeout());
+        } else {
+            return Err(LogicException {
+                message: "Invalid command type".to_string(),
+                code: 0,
+            }
+            .into());
+        }
+
+        if !Platform::is_windows() && tty {
+            // PHP: try { $process->setTty(true); } catch (RuntimeException $e) { /* ignore */ }
+            if let Err(e) = process.set_tty(true) {
+                if e.downcast_ref::<SymfonyProcessRuntimeException>().is_none() {
+                    return Err(e);
+                }
+                // ignore TTY enabling errors
+            }
+        }
+
+        let _callback: Box<dyn Fn(&str, &str)> = if is_callable(output.as_deref().cloned()) {
+            // TODO(phase-b): adapt output PhpMixed callable to closure
+            Box::new(|_t: &str, _b: &str| {})
+        } else {
+            Box::new(|_t: &str, _b: &str| {
+                // TODO(phase-b): self.output_handler(t, b) — self is borrowed mutably elsewhere
+            })
+        };
+
+        let io_for_signal = self.io.as_ref().map(|b| &**b as *const dyn IOInterface);
+        let signal_handler = SignalHandler::create(
+            vec![SignalHandler::SIGINT, SignalHandler::SIGTERM, SignalHandler::SIGHUP],
+            Box::new(move |signal: String, _h: &SignalHandler| {
+                if let Some(io_ptr) = io_for_signal {
+                    let io = unsafe { &*io_ptr };
+                    io.write_error(&format!(
+                        "Received {}, aborting when child process is done",
+                        signal
+                    ));
+                }
+            }),
+        );
+
+        let result: Result<()> = (|| -> Result<()> {
+            process.run(/* callback */ Box::new(|_t: &str, _b: &str| {}))?;
+
+            if self.capture_output && !is_callable(output.as_deref().cloned()) {
+                if let Some(out) = output.as_mut() {
+                    **out = PhpMixed::String(process.get_output());
+                }
+            }
+
+            self.error_output = process.get_error_output();
+            Ok(())
+        })();
+        let final_result: Result<()> = match result {
+            Ok(()) => Ok(()),
+            Err(e) => {
+                // TODO(phase-b): catch ProcessSignaledException
+                if let Some(pse) = e.downcast_ref::<ProcessSignaledException>() {
+                    if signal_handler.is_triggered() {
+                        // exiting as we were signaled and the child process exited too due to the signal
+                        signal_handler.exit_with_last_signal();
+                    }
+                    let _ = pse;
+                    Ok(())
+                } else {
+                    signal_handler.unregister();
+                    return Err(e);
+                }
+            }
+        };
+        signal_handler.unregister();
+        final_result?;
+
+        Ok(process.get_exit_code())
+    }
+
+    /// @param  string|non-empty-list<string> $command
+    /// @param  mixed   $output
+    fn do_execute(
+        &mut self,
+        command: PhpMixed,
+        cwd: Option<&str>,
+        tty: bool,
+        mut output: Option<&mut PhpMixed>,
+    ) -> Result<i64> {
+        self.output_command_run(&command, cwd, false);
+
+        self.capture_output = output.is_some();
+        self.error_output = String::new();
+
+        let mut env: Option<IndexMap<String, String>> = None;
+
+        let requires_git_dir_env = self.requires_git_dir_env(&command);
+        if cwd.is_some() && requires_git_dir_env {
+            let is_bare_repository = !is_dir(&format!("{}/.git", rtrim(cwd.unwrap(), Some("/"))));
+            if is_bare_repository {
+                let mut config_value = PhpMixed::String(String::new());
+                let mut git_env: IndexMap<String, String> = IndexMap::new();
+                git_env.insert("GIT_DIR".to_string(), cwd.unwrap().to_string());
+                self.run_process(
+                    PhpMixed::List(vec![
+                        Box::new(PhpMixed::String("git".to_string())),
+                        Box::new(PhpMixed::String("config".to_string())),
+                        Box::new(PhpMixed::String("safe.bareRepository".to_string())),
+                    ]),
+                    cwd,
+                    Some(git_env.clone()),
+                    tty,
+                    Some(&mut config_value),
+                )?;
+                let trimmed = trim(config_value.as_string().unwrap_or(""), None);
+                if trimmed == "explicit" {
+                    env = Some(git_env);
+                }
+            }
+        }
+
+        Ok(self
+            .run_process(command, cwd, env, tty, output.as_deref_mut())?
+            .unwrap_or(0))
+    }
+
+    /// starts a process on the commandline in async mode
+    pub fn execute_async(
+        &mut self,
+        command: PhpMixed,
+        cwd: Option<&str>,
+    ) -> Result<Box<dyn PromiseInterface>> {
+        if !self.allow_async {
+            return Err(LogicException {
+                message: "You must use the ProcessExecutor instance which is part of a Composer\\Loop instance to be able to run async processes".to_string(),
+                code: 0,
+            }
+            .into());
+        }
+
+        let id = self.id_gen;
+        self.id_gen += 1;
+        let job = Job {
+            id,
+            status: Self::STATUS_QUEUED,
+            command,
+            cwd: cwd.map(String::from),
+            process: None,
+            resolve: None,
+            reject: None,
+        };
+
+        // TODO(phase-b): build resolver/canceler closures bound to &mut self.jobs
+        let resolver: Box<dyn Fn(_, _)> = Box::new(|_resolve, _reject| {});
+        let canceler: Box<dyn Fn()> = Box::new(|| {
+            if defined("SIGINT") {
+                // job.process.signal(SIGINT)
+            }
+            // job.process.stop(1)
+        });
+        let _ = (resolver, canceler);
+
+        let promise = Promise::new(
+            Box::new(|_resolve, _reject| {}),
+            Box::new(|| {}),
+        );
+        // TODO(phase-b): wire promise.then() side-effects: mark job done & update status
+        let promise: Box<dyn PromiseInterface> = Box::new(promise);
+
+        self.jobs.insert(id, job);
+
+        if self.running_jobs < self.max_jobs {
+            self.start_job(id);
+        }
+
+        Ok(promise)
+    }
+
+    fn output_handler(&mut self, r#type: &str, buffer: &str) {
+        if self.capture_output {
+            return;
+        }
+
+        if self.io.is_none() {
+            print!("{}", buffer);
+
+            return;
+        }
+
+        if Process::ERR == r#type {
+            self.io.as_ref().unwrap().write_error_raw(
+                PhpMixed::String(buffer.to_string()),
+                false,
+                IOInterface::NORMAL,
+            );
+        } else {
+            self.io.as_ref().unwrap().write_raw(
+                PhpMixed::String(buffer.to_string()),
+                false,
+                IOInterface::NORMAL,
+            );
+        }
+    }
+
+    fn start_job(&mut self, id: i64) {
+        let job_status = self.jobs.get(&id).map(|j| j.status);
+        if job_status != Some(Self::STATUS_QUEUED) {
+            return;
+        }
+
+        // start job
+        if let Some(job) = self.jobs.get_mut(&id) {
+            job.status = Self::STATUS_STARTED;
+        }
+        self.running_jobs += 1;
+
+        let (command, cwd) = {
+            let j = self.jobs.get(&id).unwrap();
+            (j.command.clone(), j.cwd.clone())
+        };
+
+        self.output_command_run(&command, cwd.as_deref(), true);
+
+        let process_result: Result<Process> = (|| -> Result<Process> {
+            if is_string(&command) {
+                Ok(Process::from_shell_commandline(
+                    command.as_string().unwrap_or(""),
+                    cwd.as_deref(),
+                    None,
+                    None,
+                    Self::get_timeout(),
+                ))
+            } else if let PhpMixed::List(ref list) = command {
+                Ok(Process::new(
+                    list.iter()
+                        .map(|v| v.as_string().unwrap_or("").to_string())
+                        .collect(),
+                    cwd.as_deref(),
+                    None,
+                    None,
+                    Self::get_timeout(),
+                ))
+            } else {
+                Err(LogicException {
+                    message: "Invalid command type".to_string(),
+                    code: 0,
+                }
+                .into())
+            }
+        })();
+        let mut process = match process_result {
+            Ok(p) => p,
+            Err(_e) => {
+                // job.reject(e) — TODO(phase-b)
+                return;
+            }
+        };
+
+        if let Some(job) = self.jobs.get_mut(&id) {
+            job.process = Some(process.clone());
+        }
+
+        if let Err(_e) = process.start() {
+            // job.reject(e) — TODO(phase-b)
+            return;
+        }
+    }
+
+    pub fn set_max_jobs(&mut self, max_jobs: i64) {
+        self.max_jobs = max_jobs;
+    }
+
+    pub fn reset_max_jobs(&mut self) {
+        let max_jobs_env = Platform::get_env("COMPOSER_MAX_PARALLEL_PROCESSES");
+        if is_numeric(&max_jobs_env) {
+            self.max_jobs = max(
+                1,
+                min(
+                    50,
+                    max_jobs_env.as_string().unwrap_or("0").parse().unwrap_or(0),
+                ),
+            );
+        } else {
+            self.max_jobs = 10;
+        }
+    }
+
+    /// @param  ?int $index job id
+    pub fn wait(&mut self) -> Result<()> {
+        self.wait_id(None)
+    }
+
+    pub fn wait_id(&mut self, index: Option<i64>) -> Result<()> {
+        loop {
+            if 0 == self.count_active_jobs(index) {
+                return Ok(());
+            }
+
+            usleep(1000);
+        }
+    }
+
+    /// @internal
+    pub fn enable_async(&mut self) {
+        self.allow_async = true;
+    }
+
+    /// @internal
+    pub fn count_active_jobs(&mut self, index: Option<i64>) -> i64 {
+        // tick
+        let ids: Vec<i64> = self.jobs.keys().copied().collect();
+        for id in &ids {
+            let (status, has_process) = {
+                let j = self.jobs.get(id).unwrap();
+                (j.status, j.process.is_some())
+            };
+            if status == Self::STATUS_STARTED {
+                if has_process {
+                    let is_running = self
+                        .jobs
+                        .get(id)
+                        .and_then(|j| j.process.as_ref())
+                        .map(|p| p.is_running())
+                        .unwrap_or(false);
+                    if !is_running {
+                        if let Some(job) = self.jobs.get(id) {
+                            if let Some(resolve) = job.resolve.as_ref() {
+                                let process_mixed = PhpMixed::Null; // TODO(phase-b): wrap Process as PhpMixed
+                                resolve(process_mixed);
+                            }
+                        }
+                    }
+
+                    if let Some(job) = self.jobs.get_mut(id) {
+                        if let Some(p) = job.process.as_mut() {
+                            p.check_timeout();
+                        }
+                    }
+                }
+            }
+
+            if self.running_jobs < self.max_jobs {
+                let status_now = self.jobs.get(id).map(|j| j.status).unwrap_or(0);
+                if status_now == Self::STATUS_QUEUED {
+                    self.start_job(*id);
+                }
+            }
+        }
+
+        if let Some(index) = index {
+            return if self.jobs.get(&index).map(|j| j.status).unwrap_or(0) < Self::STATUS_COMPLETED
+            {
+                1
+            } else {
+                0
+            };
+        }
+
+        let mut active: i64 = 0;
+        let ids2: Vec<i64> = self.jobs.keys().copied().collect();
+        for id in ids2 {
+            let status = self.jobs.get(&id).map(|j| j.status).unwrap_or(0);
+            if status < Self::STATUS_COMPLETED {
+                active += 1;
+            } else {
+                self.jobs.shift_remove(&id);
+            }
+        }
+
+        active
+    }
+
+    fn mark_job_done(&mut self) {
+        self.running_jobs -= 1;
+    }
+
+    /// @return string[]
+    pub fn split_lines(&self, output: Option<&str>) -> Vec<String> {
+        let output = trim(output.unwrap_or(""), None);
+
+        if output.is_empty() {
+            vec![]
+        } else {
+            Preg::split(r"{\r?\n}", &output)
+        }
+    }
+
+    /// Get any error output from the last command
+    pub fn get_error_output(&self) -> &str {
+        &self.error_output
+    }
+
+    /// @return int the timeout in seconds
+    pub fn get_timeout() -> i64 {
+        *TIMEOUT.lock().unwrap()
+    }
+
+    /// @param  int  $timeout the timeout in seconds
+    pub fn set_timeout(timeout: i64) {
+        *TIMEOUT.lock().unwrap() = timeout;
+    }
+
+    /// Escapes a string to be used as a shell argument.
+    pub fn escape(argument: PhpMixed) -> String {
+        Self::escape_argument(argument)
+    }
+
+    /// @param string|list<string> $command
+    fn output_command_run(&self, command: &PhpMixed, cwd: Option<&str>, r#async: bool) {
+        if self.io.is_none() || !self.io.as_ref().unwrap().is_debug() {
+            return;
+        }
+
+        let command_string = if is_string(command) {
+            command.as_string().unwrap_or("").to_string()
+        } else if let PhpMixed::List(list) = command {
+            let parts: Vec<String> = array_map(
+                |v| Self::escape(v.clone()),
+                &list.iter().map(|b| (**b).clone()).collect::<Vec<_>>(),
+            );
+            implode(" ", &parts)
+        } else {
+            String::new()
+        };
+        let safe_command = Preg::replace_callback(
+            r"{://(?P<user>[^:/\s]+):(?P<password>[^@\s/]+)@}i",
+            |m: &IndexMap<String, String>| -> String {
+                // if the username looks like a long (12char+) hex string, or a modern github token (e.g. ghp_xxx, github_pat_xxx) we obfuscate that
+                if Preg::is_match(GitHub::GITHUB_TOKEN_REGEX, m.get("user").cloned().unwrap_or_default().as_str()) {
+                    return "://***:***@".to_string();
+                }
+                if Preg::is_match(r"{^[a-f0-9]{12,}$}", m.get("user").cloned().unwrap_or_default().as_str()) {
+                    return "://***:***@".to_string();
+                }
+
+                format!("://{}:***@", m.get("user").cloned().unwrap_or_default())
+            },
+            &command_string,
+        );
+        let safe_command = Preg::replace(
+            r"{--password (.*[^\\]') }",
+            "--password '***' ",
+            &safe_command,
+        );
+        self.io.as_ref().unwrap().write_error(&format!(
+            "Executing{} command ({}): {}",
+            if r#async { " async" } else { "" },
+            cwd.unwrap_or("CWD"),
+            safe_command
+        ));
+    }
+
+    /// Escapes a string to be used as a shell argument for Symfony Process.
+    fn escape_argument(argument: PhpMixed) -> String {
+        let mut argument = argument.as_string().unwrap_or("").to_string();
+        if "" == argument {
+            return escapeshellarg(&argument);
+        }
+
+        if !Platform::is_windows() {
+            return format!("'{}'", str_replace("'", "'\\''", &argument));
+        }
+
+        // New lines break cmd.exe command parsing
+        // and special chars like the fullwidth quote can be used to break out
+        // of parameter encoding via "Best Fit" encoding conversion
+        let mut translation: IndexMap<String, String> = IndexMap::new();
+        translation.insert("\n".to_string(), " ".to_string());
+        translation.insert("\u{ff02}".to_string(), "\"".to_string());
+        translation.insert("\u{02ba}".to_string(), "\"".to_string());
+        translation.insert("\u{301d}".to_string(), "\"".to_string());
+        translation.insert("\u{301e}".to_string(), "\"".to_string());
+        translation.insert("\u{030e}".to_string(), "\"".to_string());
+        translation.insert("\u{ff1a}".to_string(), ":".to_string());
+        translation.insert("\u{0589}".to_string(), ":".to_string());
+        translation.insert("\u{2236}".to_string(), ":".to_string());
+        translation.insert("\u{ff0f}".to_string(), "/".to_string());
+        translation.insert("\u{2044}".to_string(), "/".to_string());
+        translation.insert("\u{2215}".to_string(), "/".to_string());
+        translation.insert("\u{00b4}".to_string(), "/".to_string());
+        // PHP: strtr($argument, $translation) — variadic translation map
+        // TODO(phase-b): implement multi-target strtr; for now we apply replacements iteratively
+        for (from, to) in &translation {
+            argument = str_replace(from, to, &argument);
+        }
+        let _ = strtr;
+
+        // In addition to whitespace, commas need quoting to preserve paths
+        let mut quote = strpbrk(&argument, " \t,").is_some();
+        let mut dquotes: i64 = 0;
+        // PHP: Preg::replace('/(\\\\*)"/', '$1$1\\"', $argument, -1, $dquotes)
+        argument = Preg::replace_with_count(
+            r#"/(\\*)"/"#,
+            r#"$1$1\""#,
+            &argument,
+            -1,
+            &mut dquotes,
+        );
+        let meta = dquotes > 0 || Preg::is_match(r"/%[^%]+%|![^!]+!/", &argument);
+
+        if !meta && !quote {
+            quote = strpbrk(&argument, "^&|<>()").is_some();
+        }
+
+        if quote {
+            argument = format!("\"{}\"", Preg::replace(r"/(\\*)$/", "$1$1", &argument));
+        }
+
+        if meta {
+            argument = Preg::replace(r#"/(["^&|<>()%])/"#, "^$1", &argument);
+            argument = Preg::replace(r"/(!)/", "^^$1", &argument);
+        }
+
+        argument
+    }
+
+    /// @param string[]|string $command
+    pub fn requires_git_dir_env(&self, command: &PhpMixed) -> bool {
+        let cmd: Vec<String> = if !is_array(command) {
+            explode(" ", command.as_string().unwrap_or(""))
+        } else {
+            match command {
+                PhpMixed::List(l) => l.iter().map(|v| v.as_string().unwrap_or("").to_string()).collect(),
+                PhpMixed::Array(m) => m.values().map(|v| v.as_string().unwrap_or("").to_string()).collect(),
+                _ => vec![],
+            }
+        };
+        if cmd.get(0).map(|s| s.as_str()) != Some("git") {
+            return false;
+        }
+
+        for git_cmd in Self::GIT_CMDS_NEED_GIT_DIR.iter() {
+            let cmd_strs: Vec<String> = cmd.clone();
+            let git_cmd_strs: Vec<String> = git_cmd.iter().map(|s| s.to_string()).collect();
+            if array_intersect(&cmd_strs, &git_cmd_strs) == git_cmd_strs {
+                return true;
+            }
+        }
+
+        false
+    }
+
+    /// Resolves executable paths on Windows
+    fn get_executable(name: &str) -> String {
+        if in_array(
+            PhpMixed::String(strtolower(name)),
+            &PhpMixed::List(
+                Self::BUILTIN_CMD_COMMANDS
+                    .iter()
+                    .map(|s| Box::new(PhpMixed::String(s.to_string())))
+                    .collect(),
+            ),
+            true,
+        ) {
+            return name.to_string();
+        }
+
+        let mut executables = EXECUTABLES.lock().unwrap();
+        if !executables.contains_key(name) {
+            let path = ExecutableFinder::new().find(name, Some(name));
+            if let Some(p) = path {
+                executables.insert(name.to_string(), p);
+            }
+        }
+
+        executables.get(name).cloned().unwrap_or_else(|| name.to_string())
+    }
+}
+
+impl Clone for ProcessExecutor {
+    fn clone(&self) -> Self {
+        // TODO(phase-b): cloning ProcessExecutor is incidental to Phase A — share state
+        // properly in a Phase B refactor
+        Self {
+            capture_output: self.capture_output,
+            error_output: self.error_output.clone(),
+            io: None,
+            jobs: IndexMap::new(),
+            running_jobs: 0,
+            max_jobs: self.max_jobs,
+            id_gen: 0,
+            allow_async: self.allow_async,
+        }
+    }
+}
+
+// Suppress unused-import warnings.
+#[allow(dead_code)]
+const _USE_PARITY: () = {
+    let _ = call_user_func;
+    let _ = sprintf;
+};