YeonGyu-Kim
9dd0e14733
Address cubic and oracle review feedback to make the Node/Electron fallback faithful to Bun.spawn behavior so cross-runtime callers behave identically. Changes: - resolveStdio() default stdio is now ["ignore", "pipe", "inherit"] to match Bun.spawn defaults (was ["pipe", "pipe", "pipe"]). Prevents hangs in dispatcher and on-complete-hook callers that did not explicitly set stdin and would otherwise wait forever for input on Node. - spawn-with-windows-hide.ts uses the same defaults so the Windows Node helper aligns with the rest of the shim. - wrapNodeProcess now rejects proc.exited with the original error on "error" events (previously swallowed the error and resolved to exit code 1, hiding ENOENT and friends). - spawnSync result returns the real result.pid instead of -1 and exposes stdout/stderr as Buffer | undefined to match Node's spawnSync result shape when those streams are not piped. Tests cover the new defaults, real pid surfacing, and missing executable error propagation. Refs cubic review and oracle audit on #3798.
85 lines
2.1 KiB
TypeScript
85 lines
2.1 KiB
TypeScript
import { spawn as bunSpawn } from "./bun-spawn-shim"
|
|
import { spawn as nodeSpawn, type ChildProcess } from "node:child_process"
|
|
import { Readable } from "node:stream"
|
|
|
|
export interface SpawnOptions {
|
|
cwd?: string
|
|
env?: Record<string, string | undefined>
|
|
stdin?: "pipe" | "inherit" | "ignore"
|
|
stdout?: "pipe" | "inherit" | "ignore"
|
|
stderr?: "pipe" | "inherit" | "ignore"
|
|
}
|
|
|
|
export interface SpawnedProcess {
|
|
readonly exitCode: number | null
|
|
readonly exited: Promise<number>
|
|
readonly stdout: ReadableStream<Uint8Array> | undefined
|
|
readonly stderr: ReadableStream<Uint8Array> | undefined
|
|
kill(signal?: NodeJS.Signals): void
|
|
}
|
|
|
|
function toReadableStream(stream: NodeJS.ReadableStream | null): ReadableStream<Uint8Array> | undefined {
|
|
if (!stream) {
|
|
return undefined
|
|
}
|
|
|
|
return Readable.toWeb(stream as Readable) as ReadableStream<Uint8Array>
|
|
}
|
|
|
|
function wrapNodeProcess(proc: ChildProcess): SpawnedProcess {
|
|
let resolveExited: (exitCode: number) => void
|
|
let exitCode: number | null = null
|
|
|
|
const exited = new Promise<number>((resolve) => {
|
|
resolveExited = resolve
|
|
})
|
|
|
|
proc.on("exit", (code) => {
|
|
exitCode = code ?? 1
|
|
resolveExited(exitCode)
|
|
})
|
|
|
|
proc.on("error", () => {
|
|
if (exitCode === null) {
|
|
exitCode = 1
|
|
resolveExited(1)
|
|
}
|
|
})
|
|
|
|
return {
|
|
get exitCode() {
|
|
return exitCode
|
|
},
|
|
exited,
|
|
stdout: toReadableStream(proc.stdout),
|
|
stderr: toReadableStream(proc.stderr),
|
|
kill(signal?: NodeJS.Signals): void {
|
|
try {
|
|
if (!signal) {
|
|
proc.kill()
|
|
return
|
|
}
|
|
|
|
proc.kill(signal)
|
|
} catch {}
|
|
},
|
|
}
|
|
}
|
|
|
|
export function spawnWithWindowsHide(command: string[], options: SpawnOptions): SpawnedProcess {
|
|
if (process.platform !== "win32") {
|
|
return bunSpawn(command, options)
|
|
}
|
|
|
|
const [cmd, ...args] = command
|
|
const proc = nodeSpawn(cmd, args, {
|
|
cwd: options.cwd,
|
|
env: options.env,
|
|
stdio: [options.stdin ?? "ignore", options.stdout ?? "pipe", options.stderr ?? "inherit"],
|
|
windowsHide: true,
|
|
shell: true,
|
|
})
|
|
|
|
return wrapNodeProcess(proc)
|
|
}
|