@bman654/clodex 2.12.2 → 2.13.1

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.1",
   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
@@ -8181,17 +8183,17 @@ function proxyUrlTargetsListener(proxyUrl, listenerHost, listenerPort, localAddr
   return isWildcard(boundHost) && (isWildcard(proxyHost) || localAddresses.has(proxyHost));
 }
 var dispatcherInstalled = false;
-async function installOutboundProxyDispatcher() {
+async function installOutboundDispatcher() {
   if (dispatcherInstalled) return true;
-  if (!hasOutboundProxyEnv()) return false;
   try {
-    const { EnvHttpProxyAgent, setGlobalDispatcher } = await import("undici");
-    setGlobalDispatcher(new EnvHttpProxyAgent());
+    const { Agent: Agent3, EnvHttpProxyAgent, setGlobalDispatcher } = await import("undici");
+    const dispatcher = hasOutboundProxyEnv() ? new EnvHttpProxyAgent({ allowH2: false }) : new Agent3({ allowH2: false });
+    setGlobalDispatcher(dispatcher);
     dispatcherInstalled = true;
     return true;
   } catch (err) {
     console.error(
-      `clodex: HTTP(S)_PROXY is set but installing the outbound proxy dispatcher failed; using direct connections (${err instanceof Error ? err.message : String(err)})`
+      `clodex: installing the outbound fetch dispatcher failed; continuing with Node's existing dispatcher (${err instanceof Error ? err.message : String(err)})`
     );
     return false;
   }
@@ -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";
@@ -11831,7 +11904,13 @@ function anthropicUpstreamHeaders(apiKey, stream = false, inboundBeta, authType,
 }
 var UpstreamUnreachableError = class extends Error {
   constructor(cause) {
-    super(`Upstream unreachable: ${cause instanceof Error ? cause.message : String(cause)}`);
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    const directCode = cause !== null && typeof cause === "object" ? cause.code : void 0;
+    const nestedCause = cause instanceof Error ? cause.cause : void 0;
+    const nestedCode = nestedCause !== null && typeof nestedCause === "object" ? nestedCause.code : void 0;
+    const code = typeof directCode === "string" ? directCode : typeof nestedCode === "string" ? nestedCode : void 0;
+    const detailWithCode = code && !detail.includes(code) ? detail ? `${detail} (${code})` : code : detail;
+    super(`Upstream unreachable: ${detailWithCode}`, { cause });
     this.name = "UpstreamUnreachableError";
   }
 };
@@ -13346,12 +13425,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 +14301,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 +15236,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 +15334,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 +15355,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 +15377,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) {
@@ -20298,6 +20377,7 @@ async function startHttpProxy(options) {
       mitmServer.emit("connection", clientSocket);
       return;
     }
+    clientSocket.once("error", () => clientSocket.destroy());
     const target = authorityParts(req.url ?? "");
     if (!target) {
       clientSocket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
@@ -22533,7 +22613,7 @@ Error: ${launchPlan.error}
   return exitCode;
 }
 async function main(args = process.argv.slice(2)) {
-  await installOutboundProxyDispatcher();
+  await installOutboundDispatcher();
   const parsed = parseArgs(args);
   if (parsed.error) {
     console.error(pc13.red(`