Function invokeEngineAsync

src/engine.ts:426–538

(engine: ResolvedEngine, prompt: string, opts: InvokeOptions = {})

 * `spawn` we get direct control and can `child.stdin.end()` immediately.
 */
export function invokeEngineAsync(engine: ResolvedEngine, prompt: string, opts: InvokeOptions = {}): Promise<string> {
  const { bin, args } = engine.config;
  const timeout   = opts.timeout   ?? DEFAULT_TIMEOUT;
  const maxBuffer = opts.maxBuffer ?? DEFAULT_MAXBUF;

  return new Promise((resolve, reject) => {
    const child = spawn(bin, args(prompt, engine), {
      stdio: ['pipe', 'pipe', 'pipe'],
    });

    // Close stdin immediately with EOF so `claude -p` doesn't wait on it.
    // If spawn itself failed (ENOENT etc) `child.stdin` may be null — guard.
    try { child.stdin?.end(); } catch { /* spawn error will surface below */ }

    const stdoutChunks: Buffer[] = [];
    const stderrChunks: Buffer[] = [];
    let stdoutBytes = 0;
    let stderrBytes = 0;
    let settled = false;
    let timer: ReturnType<typeof setTimeout> | undefined;

    /** Compute the redacted tail of buffered stderr for error reporting. */
    const stderrTail = () =>
      redactSecrets(tailString(Buffer.concat(stderrChunks), STDERR_TAIL_BYTES));

    /** Send SIGTERM, then escalate to SIGKILL after a grace period in case
     *  the child traps SIGTERM. `.unref()` so the escalation timer does not
     *  keep the event loop alive past shutdown. */
    const killChild = () => {
      try { child.kill('SIGTERM'); } catch { /* already dead */ }
      const escalate = setTimeout(() => {
        try { child.kill('SIGKILL'); } catch { /* already dead */ }
      }, SIGKILL_GRACE_MS);
      escalate.unref();
    };

    const fail = (err: EngineInvocationError) => {
      if (settled) return;
      settled = true;
      if (timer !== undefined) clearTimeout(timer);
      killChild();
      reject(err);
    };

    const succeed = (out: string) => {
      if (settled) return;
      settled = true;
      if (timer !== undefined) clearTimeout(timer);
      resolve(out);
    };

    child.stdout?.on('data', (d: Buffer) => {
      stdoutBytes += d.length;
      if (stdoutBytes > maxBuffer) {
        const stderr = stderrTail();
        fail(new EngineInvocationError({
          engine: engine.name, bin, stderr,
          killed: true, code: null, signal: null, reason: 'maxbuffer',