Function runSpawnedCommand

src/utils/exec.ts:112–207

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

}

function runSpawnedCommand(
  cmd: string,
  args: string[],
  options: ExecStreamOptions = {},
): Promise<ExecResult> {
  const executable = normalizeExecutableCommand(cmd);
  const execTrace = createExecTraceContext();
  return new Promise((resolve, reject) => {
    const child = spawn(executable, args, {
      cwd: options.cwd,
      env: options.env,
      stdio: ['pipe', 'pipe', 'pipe'],
      detached: options.detached,
      windowsHide: true,
      shell: false,
    });
    options.onSpawn?.(child);

    let stdout = '';
    const stdoutChunks: Buffer[] | undefined = options.binaryStdout ? [] : undefined;
    let stderr = '';
    let didTimeout = false;
    const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
    const timeoutHandle = timeoutMs
      ? setTimeout(() => {
          didTimeout = true;
          killProcessTree(child, options.detached);
        }, timeoutMs)
      : null;
    const abort = watchCommandAbort(child, options);

    if (!options.binaryStdout) child.stdout.setEncoding('utf8');
    child.stderr.setEncoding('utf8');

    void writeChildStdin(child, options.stdin).catch((err: unknown) => {
      if (abort.didAbort || didTimeout) return;
      if (isEpipeError(err)) return;
      reject(createStdinError(executable, cmd, args, err));
      killProcessTree(child, options.detached);
    });

    child.stdout.on('data', (chunk) => {
      if (options.binaryStdout) {
        stdoutChunks?.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
        return;
      }
      const text = String(chunk);
      stdout += text;
      options.onStdoutChunk?.(text);
    });

    child.stderr.on('data', (chunk) => {
      const text = String(chunk);
      stderr += text;
      options.onStderrChunk?.(text);
    });

    child.on('error', (err) => {