execa child processes with errors, timeouts and input: working versions (tested 2026-10-15)

{
  "name": "execa-child-processes",
  "private": true,
  "type": "module",
  "scripts": {
    "test": "node --import tsx --test test/*.test.ts"
  },
  "dependencies": {
    "execa": "10.1.1"
  },
  "devDependencies": {
    "@types/node": "26.6.5",
    "tsx": "4.23.15"
  }
}

import { execa, ExecaError } from "execa";

const node = process.execPath;

/** Run a small Node script as a subprocess (stands in for any CLI tool). */
export function runScript(code: string, opts: { input?: string; timeout?: number; env?: Record<string, string> } = {}) {
  return execa(node, ["-e", code], { input: opts.input, timeout: opts.timeout, env: opts.env });
}

export async function upperCase(text: string): Promise<string> {
  const { stdout } = await runScript("process.stdin.on('data', d => process.stdout.write(String(d).toUpperCase()))", { input: text });
  return stdout;
}

export async function listLines(count: number): Promise<string[]> {
  const { stdout } = await execa(node, ["-e", `for (let i = 1; i <= ${count}; i++) console.log("line " + i)`], { lines: true });
  return stdout;
}

export async function exitInfo(code: string) {
  const r = await execa(node, ["-e", code], { reject: false });
  return { exitCode: r.exitCode, failed: r.failed, stderr: r.stderr };
}

export async function tryRun(code: string, timeout?: number) {
  try {
    await runScript(code, { timeout });
    return { ok: true as const };
  } catch (e) {
    if (e instanceof ExecaError) return { ok: false as const, exitCode: e.exitCode, timedOut: e.timedOut, stderr: e.stderr, short: e.shortMessage };
    throw e;
  }
}

import { test } from "node:test";
import assert from "node:assert/strict";
import { runScript, upperCase, listLines, exitInfo, tryRun } from "../src/proc.ts";

test("captures stdout, stderr and env", async () => {
  const r = await runScript("console.log(process.env.GREETING); console.error('warn')", { env: { GREETING: "hello" } });
  assert.equal(r.stdout, "hello");
  assert.equal(r.stderr, "warn");
  assert.equal(r.exitCode, 0);
});

test("pipes input to stdin", async () => {
  assert.equal(await upperCase("abc"), "ABC");
});

test("splits output into lines", async () => {
  assert.deepEqual(await listLines(3), ["line 1", "line 2", "line 3"]);
});

test("reject: false returns the exit code instead of throwing", async () => {
  const r = await exitInfo("console.error('boom'); process.exit(3)");
  assert.deepEqual(r, { exitCode: 3, failed: true, stderr: "boom" });
});

test("non-zero exits throw ExecaError with details", async () => {
  const r = await tryRun("process.exit(2)");
  assert.equal(r.ok, false);
  if (!r.ok) {
    assert.equal(r.exitCode, 2);
    assert.equal(r.timedOut, false);
  }
});

test("timeouts kill hung commands", async () => {
  const r = await tryRun("setTimeout(() => {}, 10000)", 200);
  assert.equal(r.ok, false);
  if (!r.ok) assert.equal(r.timedOut, true);
});