@rikcodes/teamclaude 1.1.20-rik.8 → 1.1.20-rik.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rikcodes/teamclaude",
-  "version": "1.1.20-rik.8",
+  "version": "1.1.20-rik.9",
   "description": "Multi-account proxy for Claude Code and Codex: pools Claude Max, ChatGPT/Codex, API-key and third-party backend accounts, and rotates on quota",
   "type": "module",
   "main": "src/index.js",

package/src/crash-log.js

@@ -1,5 +1,14 @@
 import { appendFileSync } from 'node:fs';
 
+/** Did a write fail because whatever was reading has gone?
+ *
+ *  Node reports this asynchronously when the stream is non-blocking, so it
+ *  arrives as an event rather than at the call site and no `try` around the
+ *  write can catch it. */
+function isBrokenPipe(err) {
+  return err?.code === 'EPIPE' || err?.code === 'ERR_STREAM_DESTROYED';
+}
+
 /**
  * Write a fatal error to `path` before the process dies.
  *
@@ -11,16 +20,39 @@ import { appendFileSync } from 'node:fs';
  * Handling these events replaces Node's own behaviour, so this must do what
  * Node would: report and exit non-zero. Continuing after an uncaught exception
  * would leave the proxy running on unknown state.
+ *
+ * A broken pipe is the one exception, and it is deliberate. The terminal going
+ * away says nothing about the proxy's state — every account, route and inflight
+ * request is exactly as it was — so ending the process punishes every routed
+ * session for a closed pane. It happened three times in two days here: the TUI
+ * writes to a non-blocking stdout, so the failure could not be caught where it
+ * was written, and each death also orphaned a sidecar on its port. Recorded
+ * once, because a stream dying is worth knowing, then survived. Once is enough:
+ * the stream stays dead, and a storm of them would say nothing new.
  * @param {string} path
  * @param {{ exit?: (code: number) => void, log?: { write: (s: string) => void } }} [opts]
  */
 export function installCrashHandlers(path, { exit = process.exit, log = process.stderr } = {}) {
+  let brokenPipeRecorded = false;
+  // 0600: a stack can carry request context. A write failure (read-only home,
+  // full disk) must not mask the crash itself — stderr still gets the entry.
+  const record = (/** @type {string} */ entry) => {
+    try { appendFileSync(path, entry, { mode: 0o600 }); } catch { /* report to stderr regardless */ }
+  };
   const report = (/** @type {string} */ kind) => (/** @type {any} */ err) => {
     const stack = err?.stack || String(err);
-    const entry = `\n=== ${new Date().toISOString()} ${kind} ===\n${stack}\n`;
-    // 0600: a stack can carry request context. A write failure (read-only home,
-    // full disk) must not mask the crash itself — stderr still gets the entry.
-    try { appendFileSync(path, entry, { mode: 0o600 }); } catch { /* report to stderr regardless */ }
+    // A bare "Error: write EPIPE" names neither the stream nor the call. The
+    // code and syscall are what turn the next one of these into a diagnosis
+    // rather than an afternoon of inference.
+    const detail = [err?.code, err?.syscall].filter(Boolean).join(' ');
+    const entry = `\n=== ${new Date().toISOString()} ${kind}${detail ? ` (${detail})` : ''} ===\n${stack}\n`;
+    if (isBrokenPipe(err)) {
+      if (!brokenPipeRecorded) { brokenPipeRecorded = true; record(entry); }
+      // Deliberately not written to `log`: that is very likely the stream that
+      // just failed, and would fail again.
+      return;
+    }
+    record(entry);
     log.write(entry);
     exit(1);
   };

package/src/tui.js

@@ -586,13 +586,16 @@ export class TUI {
     this._setStdoutBlocking(true);
     // Blocking again means a failed write throws here instead of arriving as
     // an event, and a terminal that has already gone will fail. Restoring the
-    // screen is best-effort: there is nobody left to restore it for. The error
-    // listener outlives this write, so a late async failure is absorbed too.
+    // screen is best-effort: there is nobody left to restore it for.
     try { process.stdout.write(`${ESC}?25h${ESC}?1049l`); } catch { /* terminal already gone */ }
-    if (this._stdoutErrorHandler) {
-      process.stdout.removeListener('error', this._stdoutErrorHandler);
-      this._stdoutErrorHandler = null;
-    }
+    // The error listener stays. Flipping back to blocking does not make writes
+    // ALREADY QUEUED synchronous, so a paint still in flight can fail after
+    // this point, and shutdown() runs well past it — stopping the prober, the
+    // warmer and the sidecar, then awaiting a state save. An earlier version
+    // removed the listener here while claiming it outlived the write; it did
+    // not, and the proxy died of an unhandled EPIPE in exactly that window. It
+    // only sets a flag, so leaving it attached for the rest of the process
+    // costs nothing.
     try { process.stdin.setRawMode(false); } catch {}
     process.stdin.pause();
   }