@bman654/clodex 2.18.10 → 2.19.0

package/dist/cli.js

@@ -7,12 +7,14 @@ import {
   REGISTRY_SCHEMA_VERSION_WITH_MATERIALIZED_ACTIVE_ACCOUNT,
   assertRegistryWriteOwnership,
   backupDir,
+  cancelOnExit,
   clearActiveOAuthAccount,
   collectPristineFacts,
   contentAddressedBackupPath,
   customProviderId,
   emitParentNotice,
   ensureSecureAppHome,
+  exitAfterDrain,
   findClaudeBinary,
   getAppHome,
   getClaudeVersionForBinary,
@@ -74,7 +76,7 @@ import {
   withRegistryWriteLockSync,
   writeParentNoticeLines,
   writeParentNoticeLinesSync
-} from "./chunk-VFYRDLDD.js";
+} from "./chunk-Q2YFYQQT.js";
 
 // src/cli.ts
 import pc13 from "picocolors";
@@ -323,19 +325,25 @@ function launchClaude(env, model, extraArgs) {
       env,
       shell: isWindows
     });
-    const forward = (signal) => {
-      child.kill(signal);
+    const forwardSigint = () => {
+      child.kill("SIGINT");
     };
-    process.once("SIGINT", () => forward("SIGINT"));
-    process.once("SIGTERM", () => forward("SIGTERM"));
-    child.on("exit", (code) => {
-      restore();
-      resolve4(code ?? 0);
-    });
-    child.on("error", (err) => {
+    const forwardSigterm = () => {
+      child.kill("SIGTERM");
+    };
+    process.once("SIGINT", forwardSigint);
+    process.once("SIGTERM", forwardSigterm);
+    const stopForwarding = () => {
+      process.off("SIGINT", forwardSigint);
+      process.off("SIGTERM", forwardSigterm);
+    };
+    const finish = (code) => {
+      stopForwarding();
       restore();
-      resolve4(1);
-    });
+      resolve4(code);
+    };
+    child.on("exit", (code) => finish(code ?? 0));
+    child.on("error", () => finish(1));
   });
 }
 
@@ -346,7 +354,7 @@ import { join } from "path";
 // package.json
 var package_default = {
   name: "@bman654/clodex",
-  version: "2.18.10",
+  version: "2.19.0",
   publishConfig: {
     access: "public"
   },
@@ -5682,9 +5690,12 @@ function getUserPricingCachePath() {
 function loadPricingCache() {
   return readPricingFile(getUserPricingCachePath()) ?? loadBundledPricingCache();
 }
-async function fetchPricingCache() {
+async function fetchPricingCache(signal) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  const onCallerAbort = () => controller.abort();
+  if (signal?.aborted) controller.abort();
+  else signal?.addEventListener("abort", onCallerAbort, { once: true });
   try {
     const response = await fetch(PRICING_API_URL, {
       signal: controller.signal,
@@ -5699,6 +5710,7 @@ async function fetchPricingCache() {
     return null;
   } finally {
     clearTimeout(timer);
+    signal?.removeEventListener("abort", onCallerAbort);
   }
 }
 function pickPricingRow(rows, platform) {
@@ -5802,17 +5814,24 @@ function applyPricingToRegistryProviders(registry, cache) {
   return changed;
 }
 function enrichPricingAsync(onComplete) {
+  const controller = new AbortController();
+  const { signal } = controller;
+  const unregister = cancelOnExit(() => controller.abort());
   void (async () => {
-    const fetched = await fetchPricingCache();
+    const fetched = await fetchPricingCache(signal);
+    if (signal.aborted) return;
     const cache = fetched ?? loadPricingCache();
     const changed = await withRegistryWriteLock(() => {
+      if (signal.aborted) return void 0;
       const registry = loadRegistryStrict();
       const updated = applyPricingToRegistryProviders(registry, cache);
       if (updated) saveRegistry(registry);
       return updated;
-    });
-    onComplete?.(changed);
-  })().catch(() => onComplete?.(false));
+    }, { signal });
+    if (changed !== void 0) onComplete?.(changed);
+  })().catch(() => {
+    if (!signal.aborted) onComplete?.(false);
+  }).finally(unregister);
 }
 function pricingPlatformForProvider(templateId, providerId) {
   return TEMPLATE_TO_PRICING_PLATFORM[templateId] ?? TEMPLATE_TO_PRICING_PLATFORM[providerId];
@@ -5821,6 +5840,7 @@ function pricingPlatformForProvider(templateId, providerId) {
 // src/registry/models-dev.ts
 var MODELS_DEV_API_URL = "https://models.dev/api.json";
 var FETCH_TIMEOUT_MS2 = 15e3;
+var MODELS_DEV_REFRESH_DELAY_MS = 500;
 var FILE_MODE2 = 384;
 var META_KEY = "_relay_meta";
 var memoryCache = null;
@@ -5921,9 +5941,12 @@ function loadModelsDevCache() {
   if (memoryCache && memoryCachePath === "bundled") return memoryCache;
   return rememberModelsDevCache("bundled", loadBundledModelsDevCache());
 }
-async function fetchModelsDevCache() {
+async function fetchModelsDevCache(signal) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS2);
+  const onCallerAbort = () => controller.abort();
+  if (signal?.aborted) controller.abort();
+  else signal?.addEventListener("abort", onCallerAbort, { once: true });
   try {
     const response = await fetch(MODELS_DEV_API_URL, {
       signal: controller.signal,
@@ -5939,16 +5962,28 @@ async function fetchModelsDevCache() {
     return null;
   } finally {
     clearTimeout(timer);
+    signal?.removeEventListener("abort", onCallerAbort);
   }
 }
 function resolveModelsDevSlug(providerId) {
   return REGISTRY_TO_MODELS_DEV[providerId] ?? providerId;
 }
 function refreshModelsDevCacheAsync(onComplete) {
-  void (async () => {
-    const updated = await fetchModelsDevCache() !== null;
-    onComplete?.(updated);
-  })();
+  const controller = new AbortController();
+  const start = setTimeout(() => {
+    void (async () => {
+      try {
+        const updated = await fetchModelsDevCache(controller.signal) !== null;
+        onComplete?.(updated);
+      } finally {
+        unregister();
+      }
+    })();
+  }, MODELS_DEV_REFRESH_DELAY_MS);
+  const unregister = cancelOnExit(() => {
+    clearTimeout(start);
+    controller.abort();
+  });
 }
 function findModelsDevModel(providerId, modelId, cache = loadModelsDevCache()) {
   const slug = resolveModelsDevSlug(providerId);
@@ -6512,7 +6547,10 @@ function writeInferenceResponseLifecycleLog(path, entry) {
     ...entry.failureSource ? { failureSource: entry.failureSource } : {},
     ...entry.terminationSource ? { terminationSource: entry.terminationSource } : {},
     ...attempt !== void 0 ? { attempt } : {},
-    ...entry.reusedSocket !== void 0 ? { reusedSocket: entry.reusedSocket } : {}
+    ...entry.reusedSocket !== void 0 ? { reusedSocket: entry.reusedSocket } : {},
+    ...entry.outageHold !== void 0 ? { outageHold: entry.outageHold } : {},
+    ...entry.holdElapsedMs !== void 0 ? { holdElapsedMs: entry.holdElapsedMs } : {},
+    ...entry.retryDelayMs !== void 0 ? { retryDelayMs: entry.retryDelayMs } : {}
   }));
 }
 function writeProxyLifecycleLog(path, entry) {
@@ -8104,7 +8142,10 @@ import { AsyncLocalStorage } from "async_hooks";
 
 // src/outbound-proxy.ts
 import { randomUUID as randomUUID3 } from "crypto";
+import diagnosticsChannel from "diagnostics_channel";
+import { Socket } from "net";
 import { networkInterfaces } from "os";
+import { TLSSocket } from "tls";
 import { HttpsProxyAgent } from "https-proxy-agent";
 var OUTBOUND_PROXY_HOP_HEADER = "x-clodex-proxy-hop";
 var outboundProxyHopNonce = randomUUID3();
@@ -8177,12 +8218,34 @@ function proxyUrlTargetsListener(proxyUrl, listenerHost, listenerPort, localAddr
   return isWildcard(boundHost) && (isWildcard(proxyHost) || localAddresses.has(proxyHost));
 }
 var dispatcherInstalled = false;
+function abandonPendingConnectionsOnExit() {
+  const pending = /* @__PURE__ */ new Set();
+  const track = (message) => {
+    const socket = message.socket;
+    if (!(socket instanceof Socket)) return;
+    pending.add(socket);
+    const settled = () => pending.delete(socket);
+    socket.once(socket instanceof TLSSocket ? "secureConnect" : "connect", settled);
+    socket.once("close", settled);
+  };
+  diagnosticsChannel.subscribe("net.client.socket", track);
+  cancelOnExit(() => {
+    diagnosticsChannel.unsubscribe("net.client.socket", track);
+    for (const socket of pending) {
+      socket.on("error", () => {
+      });
+      socket.destroy(Object.assign(new Error("clodex is exiting"), { code: "ECONNABORTED" }));
+    }
+    pending.clear();
+  });
+}
 async function installOutboundDispatcher() {
   if (dispatcherInstalled) return true;
   try {
     const { Agent: Agent3, EnvHttpProxyAgent, setGlobalDispatcher } = await import("undici");
     const dispatcher = hasOutboundProxyEnv() ? new EnvHttpProxyAgent({ allowH2: false }) : new Agent3({ allowH2: false });
     setGlobalDispatcher(dispatcher);
+    abandonPendingConnectionsOnExit();
     dispatcherInstalled = true;
     return true;
   } catch (err) {
@@ -8699,6 +8762,34 @@ function passthroughUpstreamRetries(env = process.env, warn = defaultWarn) {
   }
   return DEFAULT_PASSTHROUGH_RETRIES;
 }
+var PASSTHROUGH_OUTAGE_HOLD_ENV = "CLODEX_PASSTHROUGH_OUTAGE_HOLD_MS";
+var DEFAULT_PASSTHROUGH_OUTAGE_HOLD_MS = 12e4;
+var MAX_PASSTHROUGH_OUTAGE_HOLD_MS = 57e4;
+function passthroughOutageHoldMs(env = process.env, warn = defaultWarn) {
+  const raw = env[PASSTHROUGH_OUTAGE_HOLD_ENV]?.trim();
+  if (raw === void 0 || raw === "") return DEFAULT_PASSTHROUGH_OUTAGE_HOLD_MS;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 0) {
+    reportOnce(
+      `${PASSTHROUGH_OUTAGE_HOLD_ENV}=${raw}`,
+      `ignoring ${PASSTHROUGH_OUTAGE_HOLD_ENV}=${raw} (expected a non-negative integer number of milliseconds)`,
+      warn
+    );
+    return DEFAULT_PASSTHROUGH_OUTAGE_HOLD_MS;
+  }
+  if (value > MAX_PASSTHROUGH_OUTAGE_HOLD_MS) {
+    reportOnce(
+      `${PASSTHROUGH_OUTAGE_HOLD_ENV}=${raw}`,
+      `clamping ${PASSTHROUGH_OUTAGE_HOLD_ENV}=${raw} to ${MAX_PASSTHROUGH_OUTAGE_HOLD_MS}ms (the ceiling keeps the hold 29 s inside the 599 s Claude Code waits for response headers after a request has gone unanswered, at its default API_TIMEOUT_MS)`,
+      warn
+    );
+    return MAX_PASSTHROUGH_OUTAGE_HOLD_MS;
+  }
+  return value;
+}
+function outageRetryDelayMs(retry) {
+  return Math.min(15e3, 1e3 * 2 ** Math.max(0, retry - 1));
+}
 
 // src/oauth/ws-upgrade-pacer.ts
 var WS_NEW_CONNECTIONS_PER_MIN_ENV = "CLODEX_WS_MAX_NEW_CONNECTIONS_PER_MIN";
@@ -9782,12 +9873,17 @@ function deleteEntry(entry, closeSocket = true) {
   entry.inFlight = false;
   entry.current = void 0;
   unregisterEntry(entry);
-  if (closeSocket) {
-    try {
-      entry.socket.close();
-    } catch {
-    }
+  if (closeSocket) closeGracefully(entry.socket);
+}
+var WS_CLOSING = 2;
+function closeGracefully(socket) {
+  try {
+    socket.close();
+  } catch {
+    return;
   }
+  if (socket.readyState !== WS_CLOSING) return;
+  socket.once("close", cancelOnExit(() => socket.terminate()));
 }
 function failContext(entry, ctx, message, diagnosticDetails, statusCode, retryAfter) {
   if (ctx.closed || entry.current !== ctx) return;
@@ -20069,6 +20165,19 @@ var MAX_BODY_BYTES = 50 * 1024 * 1024;
 var MAX_ERROR_BODY_BYTES = 64 * 1024;
 var MAX_USAGE_SSE_BLOCK_BYTES = 64 * 1024;
 var RETRYABLE_PASSTHROUGH_CODE = "ECONNRESET";
+var OUTAGE_HOLD_CODES = /* @__PURE__ */ new Set([
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EAI_FAIL",
+  "ECONNREFUSED",
+  "ENETUNREACH",
+  "EHOSTUNREACH",
+  "ENETDOWN",
+  "EHOSTDOWN",
+  "EADDRNOTAVAIL",
+  "ECONNRESET",
+  "ETIMEDOUT"
+]);
 function upstreamUnreachableDetail(err) {
   return err.message || err.code || err.name || "connection failed";
 }
@@ -20223,10 +20332,17 @@ function requestHeadersWithoutProxyHeaders(req) {
   }
   return headers;
 }
-function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorized, agent, onErrorResponse, onResponseUsage, lifecycle, isLocalShutdown = () => false) {
+function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorized, agent, onErrorResponse, onResponseUsage, lifecycle, isLocalShutdown = () => false, passthrough = {}) {
   return new Promise((resolve4) => {
     const startedAt = Date.now();
     const retryBudget = passthroughUpstreamRetries();
+    const outageHoldMs = passthrough.holdOutages ? passthroughOutageHoldMs() : 0;
+    const holdDeadline = startedAt + outageHoldMs;
+    let lastHoldError;
+    let outageRetries = 0;
+    let reuseRetries = 0;
+    let holdTimer;
+    let attemptDeadlineTimer;
     let lastActivityAt = startedAt;
     let headersReceived = false;
     let firstByteAt;
@@ -20278,8 +20394,49 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
     const errorType = (err) => err.code ?? err.name;
     let upstream;
     let attempt = 0;
-    const isRetryableUpstreamFailure = (err, request3) => attempt <= retryBudget && !headersReceived && !failed && !clientDisconnected2 && !isLocalShutdown() && request3.reusedSocket === true && err.code === RETRYABLE_PASSTHROUGH_CODE;
-    const sendAttempt = () => {
+    const isRetryableUpstreamFailure = (err, request3) => reuseRetries < retryBudget && !headersReceived && !failed && !clientDisconnected2 && !isLocalShutdown() && request3.reusedSocket === true && err.code === RETRYABLE_PASSTHROUGH_CODE;
+    const isOutageHoldFailure = (err, request3, tlsEstablished) => outageHoldMs > 0 && !headersReceived && !failed && !clientDisconnected2 && !isLocalShutdown() && request3.reusedSocket !== true && !tlsEstablished && OUTAGE_HOLD_CODES.has(err.code ?? "");
+    const clearAttemptDeadline = () => {
+      if (attemptDeadlineTimer) clearTimeout(attemptDeadlineTimer);
+      attemptDeadlineTimer = void 0;
+    };
+    const answer502 = (detail, failure) => {
+      failed = true;
+      stopProgress();
+      clearAttemptDeadline();
+      const now = Date.now();
+      writeLifecycle("response_failed", {
+        statusCode: 502,
+        phase: responsePhase(),
+        durationMs: now - startedAt,
+        idleMs: now - lastActivityAt,
+        bytes,
+        chunks,
+        errorType: failure.errorType,
+        terminationSource: isLocalShutdown() ? "local_shutdown" : "upstream_failure",
+        attempt,
+        reusedSocket: failure.reusedSocket,
+        ...failure.outageHold ? { outageHold: true } : {}
+      });
+      onErrorResponse?.(502, `Anthropic upstream unreachable: ${detail}`);
+      if (!res.headersSent) res.writeHead(502, { "Content-Type": "text/plain" });
+      res.end(`Anthropic upstream unreachable: ${detail}`);
+      done();
+    };
+    const holdExpiredDetail = (pendingHandshake) => {
+      const parts = [`outage hold of ${outageHoldMs} ms expired`];
+      if (pendingHandshake) parts[0] += " before the TLS handshake completed";
+      if (lastHoldError) parts.push(`last upstream error: ${upstreamUnreachableDetail(lastHoldError)}`);
+      return parts.join("; ");
+    };
+    const lateReplayDetail = () => {
+      const parts = [
+        `reused connection was reset and the outage hold of ${outageHoldMs} ms had expired before the request could be resent, so it was not resent on a new connection`
+      ];
+      if (lastHoldError) parts.push(`last upstream error: ${upstreamUnreachableDetail(lastHoldError)}`);
+      return parts.join("; ");
+    };
+    const sendAttempt = (replayOfReset = false) => {
       attempt += 1;
       const request3 = https.request({
         protocol: "https:",
@@ -20290,8 +20447,10 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
         headers: requestHeadersWithoutProxyHeaders(req),
         servername: net.isIP(origin.hostname) ? void 0 : origin.hostname,
         rejectUnauthorized,
-        agent
+        agent,
+        ...passthrough.lookup ? { lookup: passthrough.lookup } : {}
       }, (upstreamRes) => {
+        clearAttemptDeadline();
         headersReceived = true;
         statusCode = upstreamRes.statusCode ?? 502;
         lastActivityAt = Date.now();
@@ -20340,12 +20499,95 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
         });
       });
       upstream = request3;
+      let tlsEstablished = false;
+      const cutPendingAttempt = (lateReplay) => {
+        if (tlsEstablished || headersReceived || failed || clientDisconnected2) return;
+        answer502(lateReplay ? lateReplayDetail() : holdExpiredDetail(true), {
+          errorType: "outage_hold_expired",
+          reusedSocket: false,
+          outageHold: true
+        });
+        request3.destroy();
+      };
+      const attemptRemaining = holdDeadline - Date.now();
+      const startedAfterDeadline = outageHoldMs > 0 && attemptRemaining <= 0;
+      if (outageHoldMs > 0 && attemptRemaining > 0) {
+        attemptDeadlineTimer = setTimeout(() => {
+          attemptDeadlineTimer = void 0;
+          cutPendingAttempt(false);
+        }, attemptRemaining);
+      }
+      request3.once("socket", (socket) => {
+        if (request3.reusedSocket) {
+          clearAttemptDeadline();
+          return;
+        }
+        if (startedAfterDeadline) {
+          cutPendingAttempt(replayOfReset);
+          return;
+        }
+        socket.once("secureConnect", () => {
+          tlsEstablished = true;
+          clearAttemptDeadline();
+        });
+      });
       request3.once("error", (err) => {
+        clearAttemptDeadline();
         if (clientDisconnected2) {
           done();
           return;
         }
+        if (isOutageHoldFailure(err, request3, tlsEstablished)) {
+          lastHoldError = err;
+          const now = Date.now();
+          const remaining = holdDeadline - now;
+          if (remaining <= 0) {
+            answer502(holdExpiredDetail(false), {
+              errorType: errorType(err),
+              reusedSocket: false,
+              outageHold: true
+            });
+            return;
+          }
+          outageRetries += 1;
+          const backoff = outageRetryDelayMs(outageRetries);
+          const holdDelay = Math.min(backoff, remaining);
+          const waitReachesDeadline = backoff >= remaining;
+          writeLifecycle("response_retried", {
+            phase: responsePhase(),
+            durationMs: now - startedAt,
+            idleMs: now - lastActivityAt,
+            errorType: errorType(err),
+            terminationSource: "upstream_failure",
+            attempt,
+            reusedSocket: false,
+            outageHold: true,
+            holdElapsedMs: now - startedAt,
+            retryDelayMs: holdDelay
+          });
+          lastActivityAt = now;
+          holdTimer = setTimeout(() => {
+            holdTimer = void 0;
+            if (clientDisconnected2 || failed || isLocalShutdown()) {
+              if (isLocalShutdown()) res.destroy();
+              done();
+              return;
+            }
+            if (waitReachesDeadline || Date.now() >= holdDeadline) {
+              answer502(holdExpiredDetail(false), {
+                errorType: errorType(err),
+                reusedSocket: false,
+                outageHold: true
+              });
+              return;
+            }
+            lastActivityAt = Date.now();
+            sendAttempt();
+          }, holdDelay);
+          return;
+        }
         if (isRetryableUpstreamFailure(err, request3)) {
+          reuseRetries += 1;
           const retriedAt = Date.now();
           writeLifecycle("response_retried", {
             phase: responsePhase(),
@@ -20357,33 +20599,17 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
             reusedSocket: true
           });
           lastActivityAt = retriedAt;
-          sendAttempt();
+          sendAttempt(true);
           return;
         }
         if (failed) {
           done();
           return;
         }
-        failed = true;
-        stopProgress();
-        const now = Date.now();
-        writeLifecycle("response_failed", {
-          statusCode: 502,
-          phase: responsePhase(),
-          durationMs: now - startedAt,
-          idleMs: now - lastActivityAt,
-          bytes,
-          chunks,
+        answer502(upstreamUnreachableDetail(err), {
           errorType: errorType(err),
-          terminationSource: isLocalShutdown() ? "local_shutdown" : "upstream_failure",
-          attempt,
           reusedSocket: request3.reusedSocket === true
         });
-        const detail = upstreamUnreachableDetail(err);
-        onErrorResponse?.(502, `Anthropic upstream unreachable: ${detail}`);
-        if (!res.headersSent) res.writeHead(502, { "Content-Type": "text/plain" });
-        res.end(`Anthropic upstream unreachable: ${detail}`);
-        done();
       });
       request3.end(rawBody);
     };
@@ -20404,6 +20630,11 @@ function forwardRawAnthropicRequest(req, res, rawBody, origin, rejectUnauthorize
       stopProgress();
       if (res.writableFinished || failed) return;
       clientDisconnected2 = true;
+      if (holdTimer) {
+        clearTimeout(holdTimer);
+        holdTimer = void 0;
+      }
+      clearAttemptDeadline();
       const now = Date.now();
       writeLifecycle("response_client_disconnected", {
         statusCode,
@@ -20926,7 +21157,14 @@ async function startHttpProxy(options) {
           provider: "anthropic",
           progressIntervalMs: options.responseProgressIntervalMs ?? INFERENCE_PROGRESS_INTERVAL_MS
         } : void 0,
-        () => shuttingDown
+        () => shuttingDown,
+        // Only messages generation is held. count_tokens, OAuth, bootstrap and
+        // telemetry calls carry no lifecycle log and short client timeouts of
+        // their own, so holding them would only slow startup without a trace.
+        {
+          holdOutages: messagesEndpoint === "messages",
+          lookup: options.anthropicLookup
+        }
       );
       return;
     }
@@ -23742,14 +23980,11 @@ function isCliEntryPoint() {
   }
 }
 if (isCliEntryPoint()) {
-  main().then((exitCode) => {
-    process.exit(exitCode);
-  }).catch((err) => {
-    if (err === /* @__PURE__ */ Symbol.for("clack:cancel")) {
-      process.exit(0);
-    }
-    console.error(pc13.red("\nUnexpected error:"), err);
-    process.exit(1);
+  const exitOptions = { trace: Boolean(parseArgs(process.argv.slice(2)).trace) };
+  main().then((exitCode) => exitAfterDrain(exitCode, exitOptions), (err) => {
+    const cancelled = err === /* @__PURE__ */ Symbol.for("clack:cancel");
+    if (!cancelled) console.error(pc13.red("\nUnexpected error:"), err);
+    exitAfterDrain(cancelled ? 0 : 1, exitOptions);
   });
 }
 export {