Function execFileAsync

src/node/utils/disposableExec.ts:285–380

(
  file: string,
  args: string[],
  options?: ExecFileAsyncOptions
)

 * const { stdout } = await proc.result;
 */
export function execFileAsync(
  file: string,
  args: string[],
  options?: ExecFileAsyncOptions
): DisposableExec {
  if (options?.signal?.aborted) {
    const error = new Error("Command aborted before execution") as Error & {
      code: number | null;
      signal: string | null;
      stdout: string;
      stderr: string;
    };
    error.code = null;
    error.signal = null;
    error.stdout = "";
    error.stderr = "";
    const result = Promise.reject(error);
    void result.catch(() => undefined);
    return new DisposableExec(result);
  }

  const child = spawn(file, args, {
    stdio: ["ignore", "pipe", "pipe"],
    env: options?.env ? { ...process.env, ...options.env } : undefined,
  });
  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
  const cleanup = () => {
    if (timeoutHandle) clearTimeout(timeoutHandle);
    options?.signal?.removeEventListener("abort", onAbort);
  };
  const killChild = () => {
    if (child.exitCode === null && child.signalCode === null) {
      child.kill();
    }
  };
  const onAbort = () => killChild();
  if (options?.timeoutMs != null && options.timeoutMs > 0) {
    timeoutHandle = setTimeout(killChild, options.timeoutMs);
    timeoutHandle.unref?.();
  }
  options?.signal?.addEventListener("abort", onAbort, { once: true });
  if (options?.signal?.aborted) {
    onAbort();
  }
  const promise = new Promise<{ stdout: string; stderr: string }>((resolve, reject) => {
    let stdout = "";
    let stderr = "";
    let exitCode: number | null = null;
    let exitSignal: string | null = null;

    child.stdout?.on("data", (data) => {
      stdout += data;
    });
    child.stderr?.on("data", (data: Buffer) => {
      const chunk = data.toString();
      stderr += chunk;
      options?.onStderrData?.(chunk);
    });