evolcore 0.0.24 → 0.0.25

package/bin/ec-safe-output.js

@@ -1,327 +1,327 @@
-#!/usr/bin/env node
-import fs from 'fs';
-import path from 'path';
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-
-const MAX_OUTPUT_BYTES = 1024 * 1024;
-const EC_EXECUTABLES = new Set(['ec']);
-const HOST_PROCESS_EXECUTABLES = new Set(['ps', 'pgrep', 'pidof', 'kill', 'pkill', 'killall']);
-const IS_WINDOWS = process.platform === 'win32';
-const HELPER_DIR = path.dirname(fileURLToPath(import.meta.url));
-// A rooted POSIX path is not absolute on Windows: Node resolves `/usr/bin/head`
-// onto the current drive as `C:\usr\bin\head`. Keep these fixed candidates as
-// the trusted fast path where they are genuinely absolute, and discover the
-// executable through PATH everywhere else.
-const POSIX_HEAD_CANDIDATES = ['/usr/bin/head', '/bin/head'];
-
-function isRegularFile(candidate) {
-  try {
-    return fs.statSync(candidate).isFile();
-  } catch {
-    return false;
-  }
-}
-
-function pathExtensionCandidates() {
-  if (!IS_WINDOWS) return [''];
-  const configured = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
-    .split(';')
-    .map(value => value.trim())
-    .filter(Boolean);
-  // The extensionless name is tried first so an explicitly named file wins over
-  // a same-named shim; npm publishes both `ec` (sh) and `ec.cmd` on Windows.
-  return ['', ...configured];
-}
-
-/**
- * Resolve one executable to an absolute path without invoking a shell.
- * `spawn` performs no PATH or PATHEXT lookup on Windows, which is why a bare
- * command name has to be materialized here before the child is started.
- */
-function resolveExecutablePath(executable) {
-  if (executable.includes('/') || executable.includes('\\')) {
-    return isRegularFile(executable) ? path.resolve(executable) : undefined;
-  }
-  const entries = (process.env.PATH || '').split(path.delimiter).filter(Boolean);
-  for (const entry of entries) {
-    for (const extension of pathExtensionCandidates()) {
-      const candidate = path.join(entry, `${executable}${extension}`);
-      if (isRegularFile(candidate)) return path.resolve(candidate);
-    }
-  }
-  return undefined;
-}
-
-function resolveHeadExecutable() {
-  if (!IS_WINDOWS) {
-    const fixed = POSIX_HEAD_CANDIDATES.find(isRegularFile);
-    if (fixed) return fixed;
-  }
-  return resolveExecutablePath('head');
-}
-
-const HEAD_EXECUTABLE = resolveHeadExecutable();
-
-/**
- * Resolve the concrete process for a validated payload.
- *
- * For `ec`, prefer this package's own Node entrypoint next to the helper. It is
- * the same installation that published this file, needs no PATH lookup, and
- * avoids the Windows batch shim entirely — `CreateProcess` cannot execute a
- * `.cmd` wrapper, so `spawn('ec')` fails with ENOENT there.
- */
-function resolveChildProcessCommand(payload) {
-  if (payload.kind === 'ec') {
-    const nodeEntrypoint = path.join(HELPER_DIR, 'ec.js');
-    // On Windows CreateProcess cannot execute the npm `.cmd` shim reliably,
-    // so prefer this package's Node entrypoint. POSIX hosts can resolve the
-    // trusted `ec` executable normally; this also preserves caller-provided
-    // PATH shims used by isolated runtimes and tests.
-    if (IS_WINDOWS && isRegularFile(nodeEntrypoint)) {
-      return { file: process.execPath, args: [nodeEntrypoint, ...payload.argv.slice(1)] };
-    }
-  }
-  const resolved = resolveExecutablePath(payload.argv[0]);
-  if (!resolved) fail(`unable to resolve executable: ${payload.argv[0]}`);
-  // Quoting rules for batch files differ from CreateProcess argument parsing,
-  // so a `.cmd`/`.bat` target could execute something other than this argv.
-  if (IS_WINDOWS && /\.(?:cmd|bat)$/i.test(resolved)) {
-    fail(`refusing to run a batch wrapper: ${resolved}`);
-  }
-  return { file: resolved, args: payload.argv.slice(1) };
-}
-
-function fail(message) {
-  process.stderr.write(`ec-safe-output: ${message}\n`);
-  process.exit(2);
-}
-
-function sameOrDescendant(candidate, parent) {
-  const relative = path.relative(parent, candidate);
-  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
-}
-
-function decodePayload(encoded) {
-  try {
-    const value = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
-    if (!value || value.v !== 1 || !Array.isArray(value.argv) || value.argv.some(arg => typeof arg !== 'string')) return null;
-    return value;
-  } catch {
-    return null;
-  }
-}
-
-function validateCommand(payload) {
-  const executable = path.basename(payload.argv[0] ?? '').toLowerCase();
-  if (payload.kind === 'ec') return EC_EXECUTABLES.has(executable);
-  if (payload.kind !== 'host-process' || !HOST_PROCESS_EXECUTABLES.has(executable)) return false;
-  return !payload.argv.some(arg => /\bnode(?:js|\.exe)?\b/i.test(arg));
-}
-
-function validateStdinOnlyHeadArgs(args) {
-  if (args === undefined) return true;
-  if (!Array.isArray(args) || args.some(arg => typeof arg !== 'string')) return false;
-  let optionsEnded = false;
-  let expectsOptionValue = false;
-  for (const arg of args) {
-    if (expectsOptionValue) {
-      expectsOptionValue = false;
-      continue;
-    }
-    if (optionsEnded) {
-      if (arg !== '-') return false;
-      continue;
-    }
-    if (arg === '--') {
-      optionsEnded = true;
-      continue;
-    }
-    if (arg === '-') continue;
-    if (!arg.startsWith('-')) return false;
-    if (arg === '-n' || arg === '-c' || arg === '--lines' || arg === '--bytes') {
-      expectsOptionValue = true;
-    }
-  }
-  return true;
-}
-
-function resolveExecutionPaths(payload) {
-  if (typeof payload.workspace !== 'string' || typeof payload.cwd !== 'string') fail('invalid workspace');
-  let workspace;
-  let cwd;
-  try {
-    workspace = fs.realpathSync(payload.workspace);
-    cwd = fs.realpathSync(payload.cwd);
-  } catch {
-    fail('workspace or cwd does not exist');
-  }
-  if (!sameOrDescendant(cwd, workspace)) fail('cwd escapes workspace');
-  return { workspace, cwd };
-}
-
-function resolveManagedTempRoot() {
-  const raw = typeof process.env.TMPDIR === 'string' ? process.env.TMPDIR.trim() : '';
-  if (!raw || !path.isAbsolute(raw)) fail('managed TMPDIR is unavailable');
-  try {
-    const root = fs.realpathSync(raw);
-    if (!fs.statSync(root).isDirectory()) fail('managed TMPDIR is not a directory');
-    return root;
-  } catch {
-    fail('managed TMPDIR is unavailable');
-  }
-}
-
-function openOutputFile(payload, paths) {
-  if (payload.outputPath === undefined) return undefined;
-  if (typeof payload.outputPath !== 'string' || !payload.outputPath) fail('output path is invalid');
-
-  const isManagedTempOutput = path.isAbsolute(payload.outputPath);
-  const outputRoot = isManagedTempOutput ? resolveManagedTempRoot() : paths.workspace;
-  const target = isManagedTempOutput
-    ? path.resolve(payload.outputPath)
-    : path.resolve(paths.cwd, payload.outputPath);
-  const parent = path.dirname(target);
-  let realParent;
-  try {
-    realParent = fs.realpathSync(parent);
-    if (!fs.statSync(realParent).isDirectory()) fail('output parent is not a directory');
-  } catch {
-    fail('output parent does not exist');
-  }
-  const canonicalTarget = path.join(realParent, path.basename(target));
-  if (!sameOrDescendant(canonicalTarget, outputRoot)) {
-    fail(isManagedTempOutput ? 'output path escapes managed TMPDIR' : 'output path escapes workspace');
-  }
-  if (!isManagedTempOutput) {
-    const relative = path.relative(paths.workspace, canonicalTarget);
-    if (relative === '.git' || relative.startsWith(`.git${path.sep}`)) fail('output path may not target Git metadata');
-  }
-
-  const noFollow = fs.constants.O_NOFOLLOW ?? 0;
-  try {
-    const fd = fs.openSync(
-      canonicalTarget,
-      fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | noFollow,
-      0o600,
-    );
-    if (!fs.fstatSync(fd).isFile()) {
-      fs.closeSync(fd);
-      fail('output target is not a regular file');
-    }
-    return { fd, target: canonicalTarget };
-  } catch (error) {
-    fail(error?.code === 'EEXIST' ? 'output file already exists' : 'unable to create output file');
-  }
-}
-
-const payload = decodePayload(process.argv[2]);
-if (!payload) fail('invalid payload');
-if (!validateCommand(payload)) fail('command is not permitted');
-if (!validateStdinOnlyHeadArgs(payload.headArgs)) fail('head may only consume stdin');
-if (payload.headArgs !== undefined && !HEAD_EXECUTABLE) fail('trusted head executable is unavailable');
-
-// Resolve the child executable before anything with a side effect: an
-// unresolvable command must not leave an empty create-only output file behind.
-const childCommand = resolveChildProcessCommand(payload);
-const paths = resolveExecutionPaths(payload);
-const output = openOutputFile(payload, paths);
-let bytesWritten = 0;
-let limitReached = false;
-let writeFailed = false;
-
-function writeLimited(chunk) {
-  if (limitReached || writeFailed) return;
-  const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-  const allowed = Math.min(buffer.length, MAX_OUTPUT_BYTES - bytesWritten);
-  if (allowed <= 0) {
-    limitReached = true;
-    return;
-  }
-  const slice = buffer.subarray(0, allowed);
-  try {
-    if (output) fs.writeSync(output.fd, slice);
-    else process.stdout.write(slice);
-    bytesWritten += slice.length;
-    if (bytesWritten >= MAX_OUTPUT_BYTES) limitReached = true;
-  } catch {
-    writeFailed = true;
-  }
-}
-
-const head = payload.headArgs === undefined
-  ? undefined
-  : spawn(HEAD_EXECUTABLE, payload.headArgs, {
-      cwd: paths.cwd,
-      env: process.env,
-      stdio: ['pipe', 'pipe', 'inherit'],
-    });
-if (head) {
-  head.stdout.on('data', writeLimited);
-  // Early-exit options such as --help or a small -n/-c close stdin before the
-  // EC process finishes. Ignore EPIPE and keep draining EC output below.
-  head.stdin.on('error', () => {});
-}
-
-const child = spawn(childCommand.file, childCommand.args, {
-  cwd: paths.cwd,
-  env: process.env,
-  stdio: ['ignore', 'pipe', payload.mergeStderr ? 'pipe' : 'inherit'],
-  windowsHide: IS_WINDOWS,
-});
-const sourceStreams = [child.stdout, ...(payload.mergeStderr ? [child.stderr] : [])];
-if (head) {
-  for (const stream of sourceStreams) {
-    // The no-op data listener keeps draining the source if head exits early.
-    stream.on('data', () => {});
-    stream.pipe(head.stdin, { end: false });
-  }
-} else {
-  for (const stream of sourceStreams) stream.on('data', writeLimited);
-}
-
-child.once('error', error => {
-  if (output) {
-    try { fs.closeSync(output.fd); } catch {}
-    try { fs.unlinkSync(output.target); } catch {}
-  }
-  fail(`unable to start command: ${error.message}`);
-});
-
-let sourceClosed = false;
-let sourceCode = 1;
-let headClosed = !head;
-let headCode = 1;
-
-function finish() {
-  if (!sourceClosed || !headClosed) return;
-  if (output) {
-    try { fs.closeSync(output.fd); } catch { writeFailed = true; }
-  }
-  if (writeFailed) {
-    if (output) try { fs.unlinkSync(output.target); } catch {}
-    fail('failed to write command output');
-  }
-  if (output) process.stderr.write(`Saved output to ${output.target}\n`);
-  process.exitCode = head ? headCode : sourceCode;
-}
-
-if (head) {
-  head.once('error', error => {
-    writeFailed = true;
-    process.stderr.write(`ec-safe-output: unable to start head: ${error.message}\n`);
-  });
-  head.once('close', code => {
-    headCode = code ?? 1;
-    headClosed = true;
-    for (const stream of sourceStreams) stream.unpipe(head.stdin);
-    finish();
-  });
-}
-
-child.once('close', code => {
-  sourceCode = code ?? 1;
-  sourceClosed = true;
-  if (head && !head.stdin.destroyed) head.stdin.end();
-  finish();
-});
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const MAX_OUTPUT_BYTES = 1024 * 1024;
+const EC_EXECUTABLES = new Set(['ec']);
+const HOST_PROCESS_EXECUTABLES = new Set(['ps', 'pgrep', 'pidof', 'kill', 'pkill', 'killall']);
+const IS_WINDOWS = process.platform === 'win32';
+const HELPER_DIR = path.dirname(fileURLToPath(import.meta.url));
+// A rooted POSIX path is not absolute on Windows: Node resolves `/usr/bin/head`
+// onto the current drive as `C:\usr\bin\head`. Keep these fixed candidates as
+// the trusted fast path where they are genuinely absolute, and discover the
+// executable through PATH everywhere else.
+const POSIX_HEAD_CANDIDATES = ['/usr/bin/head', '/bin/head'];
+
+function isRegularFile(candidate) {
+  try {
+    return fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function pathExtensionCandidates() {
+  if (!IS_WINDOWS) return [''];
+  const configured = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+    .split(';')
+    .map(value => value.trim())
+    .filter(Boolean);
+  // The extensionless name is tried first so an explicitly named file wins over
+  // a same-named shim; npm publishes both `ec` (sh) and `ec.cmd` on Windows.
+  return ['', ...configured];
+}
+
+/**
+ * Resolve one executable to an absolute path without invoking a shell.
+ * `spawn` performs no PATH or PATHEXT lookup on Windows, which is why a bare
+ * command name has to be materialized here before the child is started.
+ */
+function resolveExecutablePath(executable) {
+  if (executable.includes('/') || executable.includes('\\')) {
+    return isRegularFile(executable) ? path.resolve(executable) : undefined;
+  }
+  const entries = (process.env.PATH || '').split(path.delimiter).filter(Boolean);
+  for (const entry of entries) {
+    for (const extension of pathExtensionCandidates()) {
+      const candidate = path.join(entry, `${executable}${extension}`);
+      if (isRegularFile(candidate)) return path.resolve(candidate);
+    }
+  }
+  return undefined;
+}
+
+function resolveHeadExecutable() {
+  if (!IS_WINDOWS) {
+    const fixed = POSIX_HEAD_CANDIDATES.find(isRegularFile);
+    if (fixed) return fixed;
+  }
+  return resolveExecutablePath('head');
+}
+
+const HEAD_EXECUTABLE = resolveHeadExecutable();
+
+/**
+ * Resolve the concrete process for a validated payload.
+ *
+ * For `ec`, prefer this package's own Node entrypoint next to the helper. It is
+ * the same installation that published this file, needs no PATH lookup, and
+ * avoids the Windows batch shim entirely — `CreateProcess` cannot execute a
+ * `.cmd` wrapper, so `spawn('ec')` fails with ENOENT there.
+ */
+function resolveChildProcessCommand(payload) {
+  if (payload.kind === 'ec') {
+    const nodeEntrypoint = path.join(HELPER_DIR, 'ec.js');
+    // On Windows CreateProcess cannot execute the npm `.cmd` shim reliably,
+    // so prefer this package's Node entrypoint. POSIX hosts can resolve the
+    // trusted `ec` executable normally; this also preserves caller-provided
+    // PATH shims used by isolated runtimes and tests.
+    if (IS_WINDOWS && isRegularFile(nodeEntrypoint)) {
+      return { file: process.execPath, args: [nodeEntrypoint, ...payload.argv.slice(1)] };
+    }
+  }
+  const resolved = resolveExecutablePath(payload.argv[0]);
+  if (!resolved) fail(`unable to resolve executable: ${payload.argv[0]}`);
+  // Quoting rules for batch files differ from CreateProcess argument parsing,
+  // so a `.cmd`/`.bat` target could execute something other than this argv.
+  if (IS_WINDOWS && /\.(?:cmd|bat)$/i.test(resolved)) {
+    fail(`refusing to run a batch wrapper: ${resolved}`);
+  }
+  return { file: resolved, args: payload.argv.slice(1) };
+}
+
+function fail(message) {
+  process.stderr.write(`ec-safe-output: ${message}\n`);
+  process.exit(2);
+}
+
+function sameOrDescendant(candidate, parent) {
+  const relative = path.relative(parent, candidate);
+  return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+
+function decodePayload(encoded) {
+  try {
+    const value = JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
+    if (!value || value.v !== 1 || !Array.isArray(value.argv) || value.argv.some(arg => typeof arg !== 'string')) return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+
+function validateCommand(payload) {
+  const executable = path.basename(payload.argv[0] ?? '').toLowerCase();
+  if (payload.kind === 'ec') return EC_EXECUTABLES.has(executable);
+  if (payload.kind !== 'host-process' || !HOST_PROCESS_EXECUTABLES.has(executable)) return false;
+  return !payload.argv.some(arg => /\bnode(?:js|\.exe)?\b/i.test(arg));
+}
+
+function validateStdinOnlyHeadArgs(args) {
+  if (args === undefined) return true;
+  if (!Array.isArray(args) || args.some(arg => typeof arg !== 'string')) return false;
+  let optionsEnded = false;
+  let expectsOptionValue = false;
+  for (const arg of args) {
+    if (expectsOptionValue) {
+      expectsOptionValue = false;
+      continue;
+    }
+    if (optionsEnded) {
+      if (arg !== '-') return false;
+      continue;
+    }
+    if (arg === '--') {
+      optionsEnded = true;
+      continue;
+    }
+    if (arg === '-') continue;
+    if (!arg.startsWith('-')) return false;
+    if (arg === '-n' || arg === '-c' || arg === '--lines' || arg === '--bytes') {
+      expectsOptionValue = true;
+    }
+  }
+  return true;
+}
+
+function resolveExecutionPaths(payload) {
+  if (typeof payload.workspace !== 'string' || typeof payload.cwd !== 'string') fail('invalid workspace');
+  let workspace;
+  let cwd;
+  try {
+    workspace = fs.realpathSync(payload.workspace);
+    cwd = fs.realpathSync(payload.cwd);
+  } catch {
+    fail('workspace or cwd does not exist');
+  }
+  if (!sameOrDescendant(cwd, workspace)) fail('cwd escapes workspace');
+  return { workspace, cwd };
+}
+
+function resolveManagedTempRoot() {
+  const raw = typeof process.env.TMPDIR === 'string' ? process.env.TMPDIR.trim() : '';
+  if (!raw || !path.isAbsolute(raw)) fail('managed TMPDIR is unavailable');
+  try {
+    const root = fs.realpathSync(raw);
+    if (!fs.statSync(root).isDirectory()) fail('managed TMPDIR is not a directory');
+    return root;
+  } catch {
+    fail('managed TMPDIR is unavailable');
+  }
+}
+
+function openOutputFile(payload, paths) {
+  if (payload.outputPath === undefined) return undefined;
+  if (typeof payload.outputPath !== 'string' || !payload.outputPath) fail('output path is invalid');
+
+  const isManagedTempOutput = path.isAbsolute(payload.outputPath);
+  const outputRoot = isManagedTempOutput ? resolveManagedTempRoot() : paths.workspace;
+  const target = isManagedTempOutput
+    ? path.resolve(payload.outputPath)
+    : path.resolve(paths.cwd, payload.outputPath);
+  const parent = path.dirname(target);
+  let realParent;
+  try {
+    realParent = fs.realpathSync(parent);
+    if (!fs.statSync(realParent).isDirectory()) fail('output parent is not a directory');
+  } catch {
+    fail('output parent does not exist');
+  }
+  const canonicalTarget = path.join(realParent, path.basename(target));
+  if (!sameOrDescendant(canonicalTarget, outputRoot)) {
+    fail(isManagedTempOutput ? 'output path escapes managed TMPDIR' : 'output path escapes workspace');
+  }
+  if (!isManagedTempOutput) {
+    const relative = path.relative(paths.workspace, canonicalTarget);
+    if (relative === '.git' || relative.startsWith(`.git${path.sep}`)) fail('output path may not target Git metadata');
+  }
+
+  const noFollow = fs.constants.O_NOFOLLOW ?? 0;
+  try {
+    const fd = fs.openSync(
+      canonicalTarget,
+      fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | noFollow,
+      0o600,
+    );
+    if (!fs.fstatSync(fd).isFile()) {
+      fs.closeSync(fd);
+      fail('output target is not a regular file');
+    }
+    return { fd, target: canonicalTarget };
+  } catch (error) {
+    fail(error?.code === 'EEXIST' ? 'output file already exists' : 'unable to create output file');
+  }
+}
+
+const payload = decodePayload(process.argv[2]);
+if (!payload) fail('invalid payload');
+if (!validateCommand(payload)) fail('command is not permitted');
+if (!validateStdinOnlyHeadArgs(payload.headArgs)) fail('head may only consume stdin');
+if (payload.headArgs !== undefined && !HEAD_EXECUTABLE) fail('trusted head executable is unavailable');
+
+// Resolve the child executable before anything with a side effect: an
+// unresolvable command must not leave an empty create-only output file behind.
+const childCommand = resolveChildProcessCommand(payload);
+const paths = resolveExecutionPaths(payload);
+const output = openOutputFile(payload, paths);
+let bytesWritten = 0;
+let limitReached = false;
+let writeFailed = false;
+
+function writeLimited(chunk) {
+  if (limitReached || writeFailed) return;
+  const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+  const allowed = Math.min(buffer.length, MAX_OUTPUT_BYTES - bytesWritten);
+  if (allowed <= 0) {
+    limitReached = true;
+    return;
+  }
+  const slice = buffer.subarray(0, allowed);
+  try {
+    if (output) fs.writeSync(output.fd, slice);
+    else process.stdout.write(slice);
+    bytesWritten += slice.length;
+    if (bytesWritten >= MAX_OUTPUT_BYTES) limitReached = true;
+  } catch {
+    writeFailed = true;
+  }
+}
+
+const head = payload.headArgs === undefined
+  ? undefined
+  : spawn(HEAD_EXECUTABLE, payload.headArgs, {
+      cwd: paths.cwd,
+      env: process.env,
+      stdio: ['pipe', 'pipe', 'inherit'],
+    });
+if (head) {
+  head.stdout.on('data', writeLimited);
+  // Early-exit options such as --help or a small -n/-c close stdin before the
+  // EC process finishes. Ignore EPIPE and keep draining EC output below.
+  head.stdin.on('error', () => {});
+}
+
+const child = spawn(childCommand.file, childCommand.args, {
+  cwd: paths.cwd,
+  env: process.env,
+  stdio: ['ignore', 'pipe', payload.mergeStderr ? 'pipe' : 'inherit'],
+  windowsHide: IS_WINDOWS,
+});
+const sourceStreams = [child.stdout, ...(payload.mergeStderr ? [child.stderr] : [])];
+if (head) {
+  for (const stream of sourceStreams) {
+    // The no-op data listener keeps draining the source if head exits early.
+    stream.on('data', () => {});
+    stream.pipe(head.stdin, { end: false });
+  }
+} else {
+  for (const stream of sourceStreams) stream.on('data', writeLimited);
+}
+
+child.once('error', error => {
+  if (output) {
+    try { fs.closeSync(output.fd); } catch {}
+    try { fs.unlinkSync(output.target); } catch {}
+  }
+  fail(`unable to start command: ${error.message}`);
+});
+
+let sourceClosed = false;
+let sourceCode = 1;
+let headClosed = !head;
+let headCode = 1;
+
+function finish() {
+  if (!sourceClosed || !headClosed) return;
+  if (output) {
+    try { fs.closeSync(output.fd); } catch { writeFailed = true; }
+  }
+  if (writeFailed) {
+    if (output) try { fs.unlinkSync(output.target); } catch {}
+    fail('failed to write command output');
+  }
+  if (output) process.stderr.write(`Saved output to ${output.target}\n`);
+  process.exitCode = head ? headCode : sourceCode;
+}
+
+if (head) {
+  head.once('error', error => {
+    writeFailed = true;
+    process.stderr.write(`ec-safe-output: unable to start head: ${error.message}\n`);
+  });
+  head.once('close', code => {
+    headCode = code ?? 1;
+    headClosed = true;
+    for (const stream of sourceStreams) stream.unpipe(head.stdin);
+    finish();
+  });
+}
+
+child.once('close', code => {
+  sourceCode = code ?? 1;
+  sourceClosed = true;
+  if (head && !head.stdin.destroyed) head.stdin.end();
+  finish();
+});