@bman654/clodex 2.12.2 → 2.13.0

package/dist/cli.js

@@ -382,7 +382,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.12.2",
+  version: "2.13.0",
   publishConfig: {
     access: "public"
   },
@@ -3895,8 +3895,8 @@ import {
   statSync as statSync8,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync6,
-  openSync as openSync7,
-  closeSync as closeSync7,
+  openSync as openSync8,
+  closeSync as closeSync8,
   realpathSync as realpathSync2
 } from "fs";
 import { homedir as homedir3 } from "os";
@@ -8120,6 +8120,8 @@ import { wrapLanguageModel, extractReasoningMiddleware } from "ai";
 
 // src/oauth/responses-websocket.ts
 import { createHash as createHash6 } from "crypto";
+import { closeSync as closeSync6, openSync as openSync6 } from "fs";
+import { devNull } from "os";
 import { AsyncLocalStorage } from "async_hooks";
 
 // src/outbound-proxy.ts
@@ -8886,8 +8888,8 @@ var FAILURE_EVENT_TYPES = /* @__PURE__ */ new Set(["error", "response.failed", "
 var RESPONSES_WS_HARD_TTL_MS = 55 * 6e4;
 var RESPONSES_WS_IDLE_TTL_MS = 30 * 6e4;
 var RESPONSES_WS_NURSERY_IDLE_TTL_MS = 5 * 6e4;
-var RESPONSES_WS_MAX_CONNECTIONS = 64;
-var RESPONSES_WS_MAX_NURSERY_CONNECTIONS = 48;
+var RESPONSES_WS_MAX_CONNECTIONS = Number.POSITIVE_INFINITY;
+var RESPONSES_WS_MAX_NURSERY_CONNECTIONS = Number.POSITIVE_INFINITY;
 var diagnosticContext = new AsyncLocalStorage();
 function withResponsesWebSocketDiagnosticContext(context, fn) {
   return diagnosticContext.run(context, fn);
@@ -9845,6 +9847,64 @@ function evictOldestIdleGeneration(generation, maxConnections, reason) {
   }
   return evictions;
 }
+var DESCRIPTOR_EXHAUSTION_CODES = /* @__PURE__ */ new Set(["EMFILE", "ENFILE"]);
+function isDescriptorExhaustion(code) {
+  return typeof code === "string" && DESCRIPTOR_EXHAUSTION_CODES.has(code);
+}
+function descriptorExhaustionCode(error) {
+  const code = error.code;
+  if (isDescriptorExhaustion(code)) return code;
+  try {
+    closeSync6(openSync6(devNull, "r"));
+    return void 0;
+  } catch (probe) {
+    const probeCode = probe.code;
+    return isDescriptorExhaustion(probeCode) ? probeCode : void 0;
+  }
+}
+var descriptorExhaustionNoticed = false;
+function shedIdleConnectionsForDescriptors(failing, ctx, code, socketErrorCode) {
+  const registered = connectionEntries().filter((entry) => entry !== failing);
+  const idle = registered.filter((entry) => !entry.inFlight && entry.generation !== "isolated").sort((left, right) => left.lastUsedAt - right.lastUsedAt);
+  for (const victim of idle) {
+    const idleMs = Math.max(0, victim.options.now() - victim.lastUsedAt);
+    victim.debug(
+      `shedding idle ${victim.generation} connection after ${code}: connection=${victim.debugId} idle_ms=${idleMs} reason=descriptor_exhaustion`
+    );
+    victim.inFlight = false;
+    victim.current = void 0;
+    unregisterEntry(victim);
+    try {
+      victim.socket.terminate();
+    } catch {
+    }
+  }
+  failing.debug(
+    `${code} opening connection=${failing.debugId}: registered=${registered.length} shed=${idle.length}` + (socketErrorCode && socketErrorCode !== code ? ` reported_as=${socketErrorCode}` : "")
+  );
+  emitContextDiagnostic(failing, ctx, {
+    event: "ws_descriptor_exhaustion",
+    code,
+    detectedBy: socketErrorCode === code ? "error_code" : "descriptor_probe",
+    socketErrorCode: boundedDiagnosticIdentifier(socketErrorCode),
+    heldConnections: registered.length,
+    shedConnections: idle.length
+  });
+  if (descriptorExhaustionNoticed) return;
+  descriptorExhaustionNoticed = true;
+  emitParentNotice(
+    `clodex: warning: ${descriptorLimitName(code)} was reached (${code}) while opening a ChatGPT connection. clodex had ${registered.length} pooled connection(s) registered and closed ${idle.length} idle one(s) to recover; each parallel conversation keeps one open. ${descriptorLimitRemedy(code)} Further open-file warnings suppressed.`
+  );
+}
+function descriptorLimitName(code) {
+  return code === "ENFILE" ? "the system-wide open-file limit" : "this process's open-file limit";
+}
+function descriptorLimitRemedy(code) {
+  return code === "ENFILE" ? "Close other programs holding many files, or raise the system-wide file limit, if this recurs." : "Raise it with `ulimit -n` in the shell that starts clodex (or the service limit for a launchd/systemd-managed server) if this recurs.";
+}
+function descriptorExhaustionMessage(code, registered) {
+  return `${descriptorLimitName(code)} was reached (${code}) while opening a ChatGPT connection with ${registered} pooled connection(s) registered; ${descriptorLimitRemedy(code)}`;
+}
 function isModelDataEvent(type) {
   return Boolean(type && (type.includes(".delta") || type === "response.output_item.added" || type === "response.output_item.done"));
 }
@@ -10177,13 +10237,21 @@ function createConnection(WebSocket, wsUrl, headers, persistent, key, options, d
   socket.on("error", (error) => {
     const ctx = entry.current;
     if (ctx) {
+      const socketErrorCode = error.code;
       const details = {
         source: "socket_error",
         socketErrorName: boundedDiagnosticIdentifier(error.name),
-        socketErrorCode: boundedDiagnosticIdentifier(error.code),
+        socketErrorCode: boundedDiagnosticIdentifier(socketErrorCode),
         ...diagnosticTextFingerprint("errorMessage", error.message)
       };
-      handleTransportFailure(entry, ctx, error.message, details);
+      let message = error.message;
+      const exhaustion = entry.open ? void 0 : descriptorExhaustionCode(error);
+      if (exhaustion) {
+        const registered = connectionEntries().filter((other) => other !== entry).length;
+        message = descriptorExhaustionMessage(exhaustion, registered);
+        shedIdleConnectionsForDescriptors(entry, ctx, exhaustion, socketErrorCode);
+      }
+      handleTransportFailure(entry, ctx, message, details);
     } else deleteEntry(entry);
   });
   socket.on("close", (code, reason) => {
@@ -10204,13 +10272,16 @@ function createConnection(WebSocket, wsUrl, headers, persistent, key, options, d
   });
   return entry;
 }
+function diagnosticCap(cap) {
+  return Number.isFinite(cap) ? cap : null;
+}
 function envConnectionCap(name, log12) {
   const raw = process.env[name];
   if (raw === void 0 || raw.trim() === "") return void 0;
   const value = Number(raw.trim());
-  if (!Number.isInteger(value) || value < 1 || value > 1024) {
+  if (!Number.isInteger(value) || value < 1) {
     try {
-      log12?.(`ws: ignoring ${name}=${raw} (expected an integer between 1 and 1024)`);
+      log12?.(`ws: ignoring ${name}=${raw} (expected a positive integer)`);
     } catch {
     }
     return void 0;
@@ -10510,8 +10581,10 @@ function createResponsesWebSocketFetch(wsUrl, log12, options = {}) {
       activeConnectionCount: connectionCount(),
       nurseryConnectionCount: connectionCountByGeneration("nursery"),
       establishedConnectionCount: connectionCountByGeneration("established"),
-      maxConnections: resolvedOptions.maxConnections,
-      maxNurseryConnections: resolvedOptions.maxNurseryConnections,
+      // `null` is unbounded, the shipped default. A number is a finite cap on
+      // the idle pool from an env or programmatic override.
+      maxConnections: diagnosticCap(resolvedOptions.maxConnections),
+      maxNurseryConnections: diagnosticCap(resolvedOptions.maxNurseryConnections),
       selectedConnectionId: selected?.debugId,
       selectedGeneration: selected?.generation,
       continuationMatchMode: selectedMatch?.mode,
@@ -11548,7 +11621,7 @@ function thinkingProviderOptions(npm) {
 
 // src/proxy.ts
 import { createServer } from "http";
-import { appendFileSync as appendFileSync2, openSync as openSync6, writeSync as writeSync5, closeSync as closeSync6 } from "fs";
+import { appendFileSync as appendFileSync2, openSync as openSync7, writeSync as writeSync5, closeSync as closeSync7 } from "fs";
 
 // src/http-utils.ts
 import * as zlib from "zlib";
@@ -13346,12 +13419,12 @@ function createTranslationLifecycle(logPath, requestId, claudeSessionId, modelId
 function appendSecureLog(logPath, line) {
   const redacted = redactTraceLine(line);
   try {
-    const fd = openSync6(logPath, "a", 384);
+    const fd = openSync7(logPath, "a", 384);
     try {
       writeSync5(fd, `${(/* @__PURE__ */ new Date()).toISOString()} ${redacted}
 `);
     } finally {
-      closeSync6(fd);
+      closeSync7(fd);
     }
   } catch {
     try {
@@ -14222,10 +14295,10 @@ function tryAcquirePatchLock(lockPath = getPatchLockPath(), opts = {}) {
   mkdirSync5(join8(lockPath, ".."), { recursive: true, mode: 448 });
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fd = openSync7(lockPath, "wx");
+      const fd = openSync8(lockPath, "wx");
       const content = { pid: process.pid, startedAt: now };
       writeFileSync6(fd, JSON.stringify(content));
-      closeSync7(fd);
+      closeSync8(fd);
       return () => {
         try {
           unlinkSync3(lockPath);
@@ -15157,13 +15230,13 @@ function localProvidersToServerModels(localProviders) {
 // src/registry/credential-cleanup-journal.ts
 import { randomUUID as randomUUID5 } from "crypto";
 import {
-  closeSync as closeSync8,
+  closeSync as closeSync9,
   existsSync as existsSync6,
   fstatSync as fstatSync3,
   fsyncSync as fsyncSync2,
   lstatSync,
   mkdirSync as mkdirSync6,
-  openSync as openSync8,
+  openSync as openSync9,
   readFileSync as readFileSync11,
   renameSync as renameSync4,
   unlinkSync as unlinkSync4,
@@ -15255,7 +15328,7 @@ function readJournalUnlocked(path) {
     if (before.isSymbolicLink() || !before.isFile()) {
       throw new Error("Credential cleanup journal must be a regular file.");
     }
-    fd = openSync8(path, "r");
+    fd = openSync9(path, "r");
     const opened = fstatSync3(fd);
     if (before.dev !== opened.dev || before.ino !== opened.ino) {
       throw new Error("Credential cleanup journal changed while opening.");
@@ -15276,19 +15349,19 @@ function readJournalUnlocked(path) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Could not read credential cleanup journal: ${message}`);
   } finally {
-    if (fd !== void 0) closeSync8(fd);
+    if (fd !== void 0) closeSync9(fd);
   }
 }
 function syncParentDirectory(path) {
   let fd;
   try {
-    fd = openSync8(dirname6(path), "r");
+    fd = openSync9(dirname6(path), "r");
     fsyncSync2(fd);
   } catch (error) {
     const code = error.code;
     if (code !== "EINVAL" && code !== "ENOTSUP" && code !== "EPERM") throw error;
   } finally {
-    if (fd !== void 0) closeSync8(fd);
+    if (fd !== void 0) closeSync9(fd);
   }
 }
 function writeJournalUnlocked(journal, path) {
@@ -15298,17 +15371,17 @@ function writeJournalUnlocked(journal, path) {
   const tmp = `${path}.${process.pid}.${randomUUID5()}.tmp`;
   let fd;
   try {
-    fd = openSync8(tmp, "wx", FILE_MODE4);
+    fd = openSync9(tmp, "wx", FILE_MODE4);
     writeFileSync7(fd, `${JSON.stringify(journal, null, 2)}
 `);
     fsyncSync2(fd);
-    closeSync8(fd);
+    closeSync9(fd);
     fd = void 0;
     assertRegistryWriteOwnership(path);
     renameSync4(tmp, path);
     syncParentDirectory(path);
   } finally {
-    if (fd !== void 0) closeSync8(fd);
+    if (fd !== void 0) closeSync9(fd);
     try {
       unlinkSync4(tmp);
     } catch (error) {