cli-jaw 2.2.12 → 2.2.14

package/dist/src/agent/spawn.js

@@ -52,14 +52,48 @@ import { getEmployeeMcpServers } from './mcp-passthrough.js';
 // ─── State ───────────────────────────────────────────
 export let activeProcess = null;
 export const activeProcesses = new Map(); // agentId → child process
+/** Kill reason recorded when a duplicate registration reaps the previous child. */
+const DUP_REGISTRATION_KILL_REASON = 'dup-registration';
+/** Grace before escalating that kill to SIGKILL, matching the sibling kill paths. */
+const DUP_REGISTRATION_KILL_GRACE_MS = 2_000;
 function registerActiveProcess(agentLabel, child) {
     const prev = activeProcesses.get(agentLabel);
     if (prev && prev !== child) {
-        if (prev.exitCode !== null || prev.killed) {
+        // `killed` only records that a signal was delivered, so it is not a
+        // liveness test: a CLI that traps SIGTERM stays alive with killed set.
+        // Treating it as exited would drop that survivor from the map without
+        // even scheduling the escalation below — the exact invisible process
+        // this branch exists to prevent.
+        if (hasChildExited(prev)) {
             activeProcesses.delete(agentLabel);
         }
         else {
-            console.warn(`[spawn:dup] activeProcesses already has child for ${agentLabel} — orphaning previous reference`);
+            // Dropping a live child from the map makes it invisible to
+            // killAllAgents, so it survives stop, shutdown, and restart while
+            // still holding its own memory. Reap it instead of leaking it.
+            console.warn(`[spawn:dup] activeProcesses already has a live child for ${agentLabel} — killing it before overwrite (pid=${prev.pid ?? 'unknown'})`);
+            if (prev.pid) {
+                const prevPid = prev.pid;
+                // Record a kill reason so the stale exit handler classifies this
+                // as an intentional kill rather than a genuine agent error.
+                killReasons.set(prevPid, DUP_REGISTRATION_KILL_REASON);
+                try {
+                    killProcessTree(prevPid, 'SIGTERM');
+                }
+                catch (error) {
+                    console.warn(`[spawn:dup] failed to kill previous child for ${agentLabel}:`, error?.message ?? error);
+                }
+                // Escalate like every sibling kill path does: a CLI that traps
+                // SIGTERM would otherwise survive with no map entry to find it.
+                // Route through killProcessTreeIfAlive so a child that exited
+                // during the grace period cannot have its recycled PID killed:
+                // killProcessTree walks `pgrep -P`, so a blind escalation would
+                // take an unrelated process tree down with it.
+                const escalate = setTimeout(() => {
+                    killProcessTreeIfAlive(prev, prevPid);
+                }, DUP_REGISTRATION_KILL_GRACE_MS);
+                escalate.unref?.();
+            }
         }
     }
     activeProcesses.set(agentLabel, child);
@@ -90,7 +124,10 @@ export function buildAiERuntimeStatusMeta(cli, provider, model) {
         },
     };
 }
-import { killProcessTree } from './spawn/process-kill.js';
+import { hasChildExited, killProcessTree, killProcessTreeIfAlive } from './spawn/process-kill.js';
+import { releaseChildOutputAfterExit } from './spawn/exit-drain.js';
+import { clampPendingLine } from './spawn/line-buffer.js';
+import { appendBoundedFullText } from './events/fulltext-bound.js';
 /** Single choke point for streamed assistant text: appends to the live-run
  *  accumulator and broadcasts agent_output tagged with the owning trace run
  *  id plus the cumulative text length (`textLen`). The web UI uses the pair
@@ -174,9 +211,9 @@ export function killAgentById(agentId) {
         setTimeout(() => {
             try {
                 if (proc.pid) {
-                    killProcessTree(proc.pid, 'SIGKILL');
+                    killProcessTreeIfAlive(proc);
                 }
-                else {
+                else if (proc.exitCode === null && proc.signalCode === null) {
                     proc.kill('SIGKILL');
                 }
             }
@@ -1425,10 +1462,21 @@ export function spawnAgent(prompt, opts = {}) {
                 const delta = String(event.text || '');
                 if (!delta)
                     return;
-                ctx.fullText += delta;
+                {
+                    // D3: bound fullText — see events/fulltext-bound.ts.
+                    const bounded = appendBoundedFullText(ctx.fullText, delta);
+                    ctx.fullText = bounded.text;
+                    if (bounded.truncated)
+                        ctx.fullTextTruncated = true;
+                }
                 const displayDelta = normalizeAssistantDisplayText(delta);
-                if (ctx.liveOutputText !== undefined)
-                    ctx.liveOutputText += displayDelta;
+                if (ctx.liveOutputText !== undefined) {
+                    // Bound this too: it is promoted into fullText at close.
+                    const live = appendBoundedFullText(ctx.liveOutputText, displayDelta);
+                    ctx.liveOutputText = live.text;
+                    if (live.truncated)
+                        ctx.fullTextTruncated = true;
+                }
                 if (!ctx.outputTextStarted)
                     ctx.outputTextStarted = true;
                 broadcastAgentOutput(ctx, agentLabel, cli, displayDelta, empTag, traceAudience);
@@ -1456,10 +1504,7 @@ export function spawnAgent(prompt, opts = {}) {
                         const pid = child.pid;
                         killProcessTree(pid, 'SIGTERM');
                         setTimeout(() => {
-                            try {
-                                killProcessTree(pid, 'SIGKILL');
-                            }
-                            catch { /* already dead */ }
+                            killProcessTreeIfAlive(child, pid);
                         }, 5_000);
                     }
                     else
@@ -1515,7 +1560,10 @@ export function spawnAgent(prompt, opts = {}) {
                 opts.lifecycle?.onExit?.(result.code);
                 const killReason = consumeKillReason(child.pid);
                 const wasKilled = !!killReason;
-                const wasSteer = killReason === 'steer';
+                // 'dup-registration' behaves like a steer for cleanup purposes: a
+                // replacement child already owns this label, so the stale exit handler
+                // must not delete the new child's map entry.
+                const wasSteer = killReason === 'steer' || killReason === DUP_REGISTRATION_KILL_REASON;
                 const smokeResult = detectSmokeResponse(ctx.fullText, ctx.toolLog, result.code, cli);
                 return handleAgentExit({
                     ctx, code: result.code, cli, model: runtimeModel, effectiveProvider: profile.id, agentLabel, mainManaged, origin,
@@ -1879,7 +1927,8 @@ export function spawnAgent(prompt, opts = {}) {
                 console.warn(`[codex-app:unexpected-exit] code=${processExit.value.code} signal=${processExit.value.signal} threadId=${ctx.sessionId || 'none'}`);
             }
             const wasKilled = !!killReason;
-            const wasSteer = killReason === 'steer';
+            // See above: a dup-registration kill must not clobber the replacement.
+            const wasSteer = killReason === 'steer' || killReason === DUP_REGISTRATION_KILL_REASON;
             flushCodexAppThinking();
             const smokeResult = detectSmokeResponse(ctx.fullText, ctx.toolLog, exitCode, cli);
             await handleAgentExit({
@@ -1961,6 +2010,14 @@ export function spawnAgent(prompt, opts = {}) {
         broadcast('agent_status', { running: true, agentId: agentLabel, cli, ...runtimeStatusMeta, ...empTag });
     if (mainManaged && !opts.internal)
         beginLiveRun(liveScope, cli);
+    // The turn settles on 'close', which waits for every stdio stream to close.
+    // A descendant that inherited these pipes can outlive the child and hold
+    // them open forever, so bound that wait while still draining short tails.
+    const releaseExitDrain = releaseChildOutputAfterExit(child, {
+        onRelease: (reason) => {
+            console.warn(`[jaw:drain] ${agentLabel} exited but output stayed open — released after ${reason}`);
+        },
+    });
     // ─── DIFF-A: error guard — prevent uncaught ENOENT crash ───
     let stdSettled = false; // guard: error→close can fire sequentially
     let lastOpencodeIoAt = Date.now();
@@ -1981,6 +2038,7 @@ export function spawnAgent(prompt, opts = {}) {
     child.on('error', (err) => {
         clearOpencodeIdleTimer();
         clearAgyQuietCompletionTimer();
+        releaseExitDrain();
         if (stdSettled)
             return;
         stdSettled = true;
@@ -2089,11 +2147,7 @@ export function spawnAgent(prompt, opts = {}) {
             try {
                 killProcessTree(child.pid, 'SIGTERM');
                 setTimeout(() => {
-                    try {
-                        if (child.pid)
-                            killProcessTree(child.pid, 'SIGKILL');
-                    }
-                    catch { /* already dead */ }
+                    killProcessTreeIfAlive(child);
                 }, DEFAULT_KILL_ESCALATION_MS);
             }
             catch (e) {
@@ -2129,10 +2183,7 @@ export function spawnAgent(prompt, opts = {}) {
         if (child.pid) {
             killProcessTree(child.pid, 'SIGTERM');
             setTimeout(() => {
-                try {
-                    killProcessTree(child.pid, 'SIGKILL');
-                }
-                catch { /* already dead */ }
+                killProcessTreeIfAlive(child);
             }, 5_000);
         }
     }, watchdogConfig);
@@ -2326,6 +2377,11 @@ export function spawnAgent(prompt, opts = {}) {
         buffer += chunk.toString();
         const lines = buffer.split('\n');
         buffer = lines.pop() ?? '';
+        const clampedPending = clampPendingLine(buffer);
+        if (clampedPending.overflowed) {
+            console.warn(`[jaw:${agentLabel}] stdout line exceeded the pending-line cap without a newline — truncating`);
+            buffer = clampedPending.buffer;
+        }
         for (const line of lines) {
             if (!line.trim())
                 continue;
@@ -2351,6 +2407,7 @@ export function spawnAgent(prompt, opts = {}) {
         clearOpencodeIdleTimer();
         clearAgyQuietCompletionTimer();
         stallWatchdog.stop();
+        releaseExitDrain();
         if (stdSettled)
             return; // error handler already resolved
         // [I1] Flush residual NDJSON buffer — last event may lack trailing newline