@hellcoder/companion 0.104.2 → 0.104.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hellcoder/companion",
-  "version": "0.104.2",
+  "version": "0.104.3",
   "type": "module",
   "description": "Web UI for launching and interacting with Claude Code agents — Moritz Edition (fork of the-companion)",
   "license": "MIT",

package/server/claude-adapter.test.ts

@@ -1530,21 +1530,52 @@ function createMockProc() {
 }
 
 describe("stdio transport disconnect propagation", () => {
-  it("fires disconnect and kills a lingering process when stdout closes while alive", async () => {
+  it("kills a wedged process that does not exit within the grace period", async () => {
     // The wedge case: the worker stops emitting (e.g. after a 429) and closes
-    // stdout but the process keeps running. The adapter must kill it (so the
-    // relaunch path's PID-liveness guard is cleared) and report disconnect.
-    const { proc, endStdout } = createMockProc();
-    adapter.attachStdio(proc);
-    expect(adapter.isConnected()).toBe(true);
+    // stdout but the process keeps running and never exits. After the grace
+    // window the adapter must kill it (so the relaunch path's PID-liveness guard
+    // is cleared) and report disconnect.
+    vi.useFakeTimers();
+    try {
+      const { proc, endStdout } = createMockProc();
+      adapter.attachStdio(proc);
+      expect(adapter.isConnected()).toBe(true);
+
+      endStdout();
+      // Within the grace window the process is still alive → not killed yet.
+      await vi.advanceTimersByTimeAsync(0);
+      expect(proc.kill).not.toHaveBeenCalled();
+
+      // Past the grace window with no self-exit → treated as wedged and killed.
+      await vi.advanceTimersByTimeAsync(2100);
+      expect(proc.kill).toHaveBeenCalledTimes(1);
+      expect(adapter.isConnected()).toBe(false);
+      expect(disconnectCb).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 
-    endStdout();
-    // Let the async stdout reader observe the close and run its finally block.
-    await new Promise((r) => setTimeout(r, 0));
+  it("does NOT kill a process that exits on its own within the grace period", async () => {
+    // The common, healthy case: the CLI closes stdout a beat before it exits
+    // cleanly (e.g. right after a `result`). Killing here would convert a code-0
+    // exit into a SIGTERM (143) and force a needless relaunch, so the adapter
+    // must wait out the grace and let the process exit on its own.
+    vi.useFakeTimers();
+    try {
+      const { proc, endStdout, resolveExit } = createMockProc();
+      adapter.attachStdio(proc);
 
-    expect(proc.kill).toHaveBeenCalledTimes(1);
-    expect(adapter.isConnected()).toBe(false);
-    expect(disconnectCb).toHaveBeenCalledTimes(1);
+      endStdout();      // stdout closes while the process is still alive
+      resolveExit();    // ...but the process exits on its own during the grace
+      await vi.advanceTimersByTimeAsync(2100);
+
+      expect(proc.kill).not.toHaveBeenCalled();
+      expect(adapter.isConnected()).toBe(false);
+      expect(disconnectCb).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
   });
 
   it("fires disconnect on process exit", async () => {

package/server/claude-adapter.ts

@@ -55,6 +55,16 @@ import { reportProtocolDrift } from "./protocol-monitor.js";
 /** Number of recent CLI message hashes to track for deduplication on WS reconnect. */
 const CLI_DEDUP_WINDOW = 2000;
 
+/**
+ * Grace period after stdout closes before we kill a still-alive CLI process.
+ * The CLI's stdout often EOFs a beat *before* the process exits cleanly (e.g.
+ * right after emitting a `result`). Killing immediately turns that code-0 exit
+ * into a SIGTERM (143) and forces a needless relaunch. We wait this long for the
+ * process to exit on its own; only a process that is still alive afterwards is
+ * treated as genuinely wedged and killed. Overridable for tests/tuning.
+ */
+const STDOUT_CLOSE_GRACE_MS = Number(process.env.COMPANION_STDOUT_CLOSE_GRACE_MS) || 2000;
+
 // --- Claude Code Adapter ------------------------------------------------------
 
 export class ClaudeAdapter implements IBackendAdapter {
@@ -277,22 +287,33 @@ export class ClaudeAdapter implements IBackendAdapter {
       });
     } finally {
       // The stdout stream ended: the stream-json transport is dead and cannot
-      // be revived on this process. If the child somehow lingers (e.g. it
-      // stopped emitting after a fatal API error such as a 429 but never
-      // exited), kill it so `proc.exited` resolves and the launcher's
-      // `session:exited` → proactive `--resume` relaunch can recover it. Left
-      // alive, the process would keep `handleAutoRelaunch`'s PID-liveness guard
-      // satisfied, blocking every relaunch path indefinitely.
+      // be revived on this process. The process is now in one of two states:
+      //   (a) Exiting cleanly — its stdout EOFs a beat before it exits (e.g.
+      //       right after a `result`). Killing here converts a code-0 exit into
+      //       a SIGTERM (143) and forces a needless relaunch.
+      //   (b) Wedged — it stopped emitting (e.g. after a fatal API error such
+      //       as a 429) but will never exit, leaving `handleAutoRelaunch`'s
+      //       PID-liveness guard satisfied and blocking recovery indefinitely.
+      // Give it a short grace to exit on its own; only kill if it is STILL alive
+      // afterwards. That distinguishes (a) from (b) instead of clobbering every
+      // session that simply closed stdout on the way out.
       const proc = this.stdioProc;
       if (proc && proc.exitCode === null && !proc.killed) {
-        log.warn("claude-adapter", "stdout closed while process still alive; killing stale process", {
-          sessionId: this.sessionId,
-          pid: proc.pid,
-        });
-        try {
-          proc.kill();
-        } catch {
-          // Process may have exited between the check and the kill.
+        const exitedOnOwn = await Promise.race([
+          proc.exited.then(() => true),
+          new Promise<boolean>((resolve) => setTimeout(() => resolve(false), STDOUT_CLOSE_GRACE_MS)),
+        ]);
+        if (!exitedOnOwn && proc.exitCode === null && !proc.killed) {
+          log.warn("claude-adapter", "stdout closed and process did not exit within grace; killing stale process", {
+            sessionId: this.sessionId,
+            pid: proc.pid,
+            graceMs: STDOUT_CLOSE_GRACE_MS,
+          });
+          try {
+            proc.kill();
+          } catch {
+            // Process may have exited between the check and the kill.
+          }
         }
       }
       this.notifyStdioDisconnect();