Function execCommand

projects/electron/src/modules/code/subprocess.ts:184–245

(cmd: string, args: string[], options: ExecOptions = {})

 * 2. options.env (call-specific env vars)
 */
export async function execCommand(cmd: string, args: string[], options: ExecOptions = {}): Promise<ExecResult> {
    const { cwd, timeout = 30000, maxBuffer = 50 * 1024 * 1024, env: callEnv } = options

    const mergedEnv = { ...process.env, ...callEnv }

    return new Promise((resolve) => {
        let stdout = ""
        let stderr = ""
        let killed = false
        let resolved = false

        const child = spawn(cmd, args, {
            cwd,
            env: mergedEnv,
            stdio: ["ignore", "pipe", "pipe"],
        })

        const timeoutId =
            timeout > 0
                ? setTimeout(() => {
                      killed = true
                      child.kill("SIGTERM")
                  }, timeout)
                : null

        child.stdout?.on("data", (data) => {
            if (stdout.length < maxBuffer) {
                stdout += data.toString()
            }
        })

        child.stderr?.on("data", (data) => {
            if (stderr.length < maxBuffer) {
                stderr += data.toString()
            }
        })

        child.on("error", (err) => {
            if (resolved) return
            resolved = true
            if (timeoutId) clearTimeout(timeoutId)
            resolve({
                stdout: "",
                stderr: err.message,
                success: false,
                code: null,
            })
        })

        child.on("close", (code) => {
            if (resolved) return
            resolved = true
            if (timeoutId) clearTimeout(timeoutId)
            resolve({
                stdout: stdout.replace(/\r\n/g, "\n"),
                stderr: stderr.replace(/\r\n/g, "\n"),
                success: code === 0 && !killed,
                code,