codex-multi-auth 2.22.0 → 2.23.0

package/dist/lib/codex-manager.js

@@ -39,10 +39,13 @@ import { runInitConfigCommand } from "./codex-manager/commands/init-config.js";
 import { runReportCommand } from "./codex-manager/commands/report.js";
 import { runRotationCommand } from "./codex-manager/commands/rotation.js";
 import { runFeaturesCommand, runStatusCommand, } from "./codex-manager/commands/status.js";
+import { runWebCommand } from "./web-dashboard.js";
 import { loadPersistedRuntimeObservabilitySnapshot } from "./runtime/runtime-observability.js";
 import { runSwitchCommand } from "./codex-manager/commands/switch.js";
 import { runHistoryCommand } from "./codex-manager/commands/history.js";
+import { runLocaleCommand } from "./codex-manager/commands/locale.js";
 import { runUnpinCommand } from "./codex-manager/commands/unpin.js";
+import { resolveOutputLocale } from "./locale.js";
 import { runWorkspaceCommand } from "./codex-manager/commands/workspace.js";
 import { runUsageCommand } from "./codex-manager/commands/usage.js";
 import { refreshQuotaCacheForMenu } from "./codex-manager/login-menu-data.js";
@@ -140,6 +143,7 @@ const IMPLEMENTED_FEATURES = [
     { id: 52, name: "Why-selected and monitor diagnostics" },
     { id: 53, name: "Config explain, init-config templates, and debug bundle" },
     { id: 54, name: "mcodex convenience launcher (monitor/tmux/forward)" },
+    { id: 55, name: "Local real-time web pool dashboard" },
 ];
 async function runForecast(args) {
     return runForecastCommand(args, {
@@ -267,31 +271,50 @@ export function buildSelectAccountTraced() {
 /**
  * Shared handler for `list` and `status` (aliases of the same view).
  */
-const runListOrStatusCommand = (rest) => runStatusCommand({
-    loadApiRoutes,
-    loadResetCreditState,
-    loadInferenceRequestTimes,
-    loadModelInventory,
-    setStoragePath,
-    getStoragePath,
-    loadAccounts,
-    inspectStorageHealth,
-    resolveActiveIndex,
-    formatRateLimitEntry,
-    loadRuntimeObservabilitySnapshot: loadPersistedRuntimeObservabilitySnapshot,
-    loadAppBindStatus: async () => getAppBindStatus()
-        .then((status) => status.router ? {
-        ...status.router,
-        // Keep historical diagnostics, but never revive a crashed router's
-        // persisted "running" marker or its account-selection signal.
-        state: status.running ? status.router.state : "stopped",
-        nativeOpenai: status.running && status.state?.nativeOpenai === true,
-    } : null)
-        .catch(() => null),
-    loadAppHelperStatus: readAppRuntimeHelperAccountSignal,
-    loadQuotaCache,
-    json: rest.includes("--json") || rest.includes("-j"),
-});
+function buildStatusCommandDeps(rest, logInfo) {
+    return {
+        loadApiRoutes,
+        loadResetCreditState,
+        loadInferenceRequestTimes,
+        loadModelInventory,
+        setStoragePath,
+        getStoragePath,
+        loadAccounts,
+        inspectStorageHealth,
+        resolveActiveIndex,
+        formatRateLimitEntry,
+        loadRuntimeObservabilitySnapshot: loadPersistedRuntimeObservabilitySnapshot,
+        loadAppBindStatus: async () => getAppBindStatus()
+            .then((status) => status.router ? {
+            ...status.router,
+            // Keep historical diagnostics, but never revive a crashed router's
+            // persisted "running" marker or its account-selection signal.
+            state: status.running ? status.router.state : "stopped",
+            nativeOpenai: status.running && status.state?.nativeOpenai === true,
+        } : null)
+            .catch(() => null),
+        loadAppHelperStatus: readAppRuntimeHelperAccountSignal,
+        loadQuotaCache,
+        json: rest.includes("--json") || rest.includes("-j"),
+        compact: !rest.includes("--details") && !rest.includes("--verbose") && !rest.includes("--json") && !rest.includes("-j"),
+        locale: resolveOutputLocale(loadPluginConfig().locale),
+        ...(logInfo ? { logInfo } : {}),
+    };
+}
+const runListOrStatusCommand = (rest) => runStatusCommand(buildStatusCommandDeps(rest));
+async function loadStatusJsonSnapshot() {
+    let serialized = "";
+    const exitCode = await runStatusCommand(buildStatusCommandDeps(["--json"], (message) => {
+        serialized = message;
+    }));
+    if (exitCode !== 0)
+        throw new Error("Unable to load status snapshot.");
+    const parsed = JSON.parse(serialized);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("Status snapshot is not an object.");
+    }
+    return parsed;
+}
 /**
  * Command registry for the `auth` dispatcher (audit roadmap §4.1.1 phase 2).
  *
@@ -307,6 +330,10 @@ const CLI_COMMAND_HANDLERS = new Map([
     ["login", (rest) => runAuthLogin(rest, { runForecast, createRepairCommandDeps })],
     ["list", runListOrStatusCommand],
     ["status", runListOrStatusCommand],
+    ["web", (rest) => runWebCommand(rest, {
+            getStatus: loadStatusJsonSnapshot,
+            locale: resolveOutputLocale(loadPluginConfig().locale),
+        })],
     [
         "limits",
         (rest) => runLimitsCommand(rest, {
@@ -481,6 +508,12 @@ const CLI_COMMAND_HANDLERS = new Map([
             if (subcommand === "template") {
                 return runInitConfigCommand(configArgs);
             }
+            if (subcommand === "locale") {
+                return runLocaleCommand(configArgs, {
+                    loadConfig: () => loadPluginConfig(),
+                    saveConfig: savePluginConfig,
+                });
+            }
             console.error(`Unknown config command: ${subcommand ?? "(missing)"}`);
             return 1;
         },
@@ -506,6 +539,32 @@ const CLI_COMMAND_HANDLERS = new Map([
     ],
 ]);
 export async function runCodexMultiAuthCli(rawArgs) {
+    const localeArgs = [...rawArgs];
+    const previousLocaleOverride = process.env.CODEX_MULTI_AUTH_LOCALE;
+    let localeOverrideChanged = false;
+    const restoreLocaleOverride = () => {
+        if (!localeOverrideChanged)
+            return;
+        if (previousLocaleOverride === undefined)
+            delete process.env.CODEX_MULTI_AUTH_LOCALE;
+        else
+            process.env.CODEX_MULTI_AUTH_LOCALE = previousLocaleOverride;
+    };
+    for (let i = 0; i < localeArgs.length; i += 1) {
+        const arg = localeArgs[i];
+        if (arg === "--locale" && localeArgs[i + 1]) {
+            process.env.CODEX_MULTI_AUTH_LOCALE = localeArgs[i + 1];
+            localeOverrideChanged = true;
+            localeArgs.splice(i, 2);
+            i -= 1;
+        }
+        else if (typeof arg === "string" && arg.startsWith("--locale=")) {
+            process.env.CODEX_MULTI_AUTH_LOCALE = arg.slice("--locale=".length);
+            localeOverrideChanged = true;
+            localeArgs.splice(i, 1);
+            i -= 1;
+        }
+    }
     // Lazy install setup (audit roadmap §4.5.4): app detection, Codex app bind,
     // and launcher routing moved out of npm postinstall to the first CLI run.
     // ensureFirstRunSetup never throws; the catch is belt-and-braces so no
@@ -515,31 +574,41 @@ export async function runCodexMultiAuthCli(rawArgs) {
     }).catch(() => undefined);
     const startupDisplaySettings = await loadDashboardDisplaySettings();
     applyUiThemeFromDashboardSettings(startupDisplaySettings);
-    const args = rawArgs[0] && rawArgs[0] !== "auth" && ACCOUNT_MANAGER_COMMANDS.has(rawArgs[0])
-        ? ["auth", ...rawArgs]
-        : [...rawArgs];
+    const args = localeArgs[0] && localeArgs[0] !== "auth" && ACCOUNT_MANAGER_COMMANDS.has(localeArgs[0])
+        ? ["auth", ...localeArgs]
+        : [...localeArgs];
     if (args.length === 0) {
+        restoreLocaleOverride();
         printUsage();
         return 0;
     }
     if (args[0] === "--help" || args[0] === "-h") {
+        restoreLocaleOverride();
         printUsage();
         return 0;
     }
     const [root, sub, ...rest] = args;
     if (root !== "auth") {
+        restoreLocaleOverride();
         printUsage();
         return 1;
     }
     const command = sub ?? "login";
     if (command === "--help" || command === "-h") {
+        restoreLocaleOverride();
         printUsage();
         return 0;
     }
     const handler = CLI_COMMAND_HANDLERS.get(command);
     if (handler) {
-        return handler(rest);
+        try {
+            return await handler(rest);
+        }
+        finally {
+            restoreLocaleOverride();
+        }
     }
+    restoreLocaleOverride();
     console.error(`Unknown command: ${command}`);
     printUsage();
     return 1;

package/dist/lib/config.js

@@ -1,6 +1,7 @@
 import { existsSync, promises as fs, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseBooleanEnv } from "./env-parsing.js";
+import { normalizeOutputLocaleSetting } from "./locale.js";
 import { stripModelEffortSuffix } from "./constants.js";
 import { withRetry, withRetrySync } from "./fs-retry.js";
 import { logWarn } from "./logger.js";
@@ -113,6 +114,7 @@ function resolvePluginConfigPath() {
  * CODEX_MODE is enabled by default for better Codex CLI parity
  */
 export const DEFAULT_PLUGIN_CONFIG = {
+    locale: "auto",
     codexMode: true,
     codexRuntimeRotationProxy: true,
     codexTuiV2: true,
@@ -1275,6 +1277,7 @@ function normalizeConfigExplainValue(value) {
     return value;
 }
 const CONFIG_EXPLAIN_ENTRIES = [
+    { key: "locale", envNames: ["CODEX_MULTI_AUTH_LOCALE"], getValue: config => normalizeOutputLocaleSetting(process.env.CODEX_MULTI_AUTH_LOCALE?.trim() || config.locale || "auto") ?? "auto" },
     { key: "codexMode", envNames: ["CODEX_MODE"], getValue: getCodexMode },
     {
         key: "codexRuntimeRotationProxy",

package/dist/lib/locale.d.ts

@@ -0,0 +1,7 @@
+export type OutputLocale = "en" | "zh";
+export type OutputLocaleSetting = OutputLocale | "auto";
+/** Resolve an explicit locale, environment override, or system language. */
+export declare function resolveOutputLocale(requested?: string | null, env?: NodeJS.ProcessEnv): OutputLocale;
+export declare function normalizeOutputLocaleSetting(value: string): OutputLocaleSetting | null;
+export declare function localized(locale: OutputLocale, en: string, zh: string): string;
+export declare function localeName(locale: OutputLocale): string;

package/dist/lib/locale.js

@@ -0,0 +1,35 @@
+const SUPPORTED_LOCALES = new Set(["auto", "en", "zh"]);
+/** Resolve an explicit locale, environment override, or system language. */
+export function resolveOutputLocale(requested, env = process.env) {
+    const configured = requested?.trim().toLowerCase();
+    const value = (env.CODEX_MULTI_AUTH_LOCALE?.trim() || configured || "auto")
+        .trim()
+        .toLowerCase();
+    if (value === "en" || value.startsWith("en-"))
+        return "en";
+    if (value === "zh" || value.startsWith("zh-"))
+        return "zh";
+    if (value !== "" && value !== "auto" && SUPPORTED_LOCALES.has(value)) {
+        return value === "zh" ? "zh" : "en";
+    }
+    const system = [env.LC_ALL, env.LC_MESSAGES, env.LANG]
+        .find((candidate) => typeof candidate === "string" && candidate.trim())
+        ?.toLowerCase() ?? "";
+    return system.startsWith("zh") ? "zh" : "en";
+}
+export function normalizeOutputLocaleSetting(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "auto")
+        return "auto";
+    if (normalized === "en" || normalized.startsWith("en-"))
+        return "en";
+    if (normalized === "zh" || normalized.startsWith("zh-"))
+        return "zh";
+    return null;
+}
+export function localized(locale, en, zh) {
+    return locale === "zh" ? zh : en;
+}
+export function localeName(locale) {
+    return locale === "zh" ? "中文" : "English";
+}

package/dist/lib/quota-probe.js

@@ -1,4 +1,5 @@
 import { CODEX_BASE_URL, MAX_RATE_LIMIT_DELAY_MS } from "./constants.js";
+import { fetchWithProxy } from "./request/proxy-fetch.js";
 import { createCodexHeaders, getUnsupportedCodexModelInfo } from "./request/fetch-helpers.js";
 import { QUOTA_PROBE_MODEL_CHAIN, resolveProbeReasoningEffort, } from "./request/helpers/model-map.js";
 import { CodexUnavailableError, isCodexUnavailableError } from "./errors.js";
@@ -367,7 +368,7 @@ export async function fetchCodexQuotaSnapshot(options) {
                     snapshot.diagnosticProbeRequests += 1;
                     snapshot.runtimeMetrics.diagnosticProbeRequests += 1;
                 });
-                response = await fetch(`${CODEX_BASE_URL}/codex/responses`, {
+                response = await fetchWithProxy(`${CODEX_BASE_URL}/codex/responses`, {
                     method: "POST",
                     headers,
                     body: JSON.stringify(probeBody),

package/dist/lib/request/proxy-fetch.d.ts

@@ -0,0 +1,5 @@
+type FetchInput = Parameters<typeof globalThis.fetch>[0];
+type FetchInit = Parameters<typeof globalThis.fetch>[1];
+export declare function setProxyFetchImpl(impl: typeof globalThis.fetch | null): void;
+export declare function fetchWithProxy(input: FetchInput, init?: FetchInit): ReturnType<typeof globalThis.fetch>;
+export {};

package/dist/lib/request/proxy-fetch.js

@@ -0,0 +1,37 @@
+import { fetch as undiciFetch } from "undici";
+import { applyProxyCompatibleInit, extractRequestUrl, } from "./url-rewriting.js";
+// Transport selection contract, in precedence order:
+//   1. An implementation registered via setProxyFetchImpl (embedding contract;
+//    works regardless of when the host installs it).
+//   2. A global fetch replaced after this module loaded, or a test double.
+//   3. A global fetch installed before module load — honored when it is
+//    distinguishable from the platform fetch (Node's built-in is named
+//    "fetch"); hosts needing guaranteed interception use setProxyFetchImpl.
+//   4. The package's Undici fetch, but only when the request carries a proxy
+//    dispatcher: Node 22's built-in fetch rejects the Undici 8 handler
+//    contract, so a proxied call needs the matching implementation.
+//   5. The ambient global fetch for ordinary direct requests.
+const initialGlobalFetch = globalThis.fetch;
+let overrideFetch = null;
+export function setProxyFetchImpl(impl) {
+    overrideFetch = impl;
+}
+function isTestDouble(fetchImpl) {
+    const candidate = fetchImpl;
+    return candidate._isMockFunction === true || candidate.mock !== undefined;
+}
+function isPlatformFetch(fetchImpl) {
+    return fetchImpl.name === "fetch" && !isTestDouble(fetchImpl);
+}
+export function fetchWithProxy(input, init) {
+    const url = extractRequestUrl(input);
+    const proxiedInit = applyProxyCompatibleInit(url, init);
+    const currentGlobalFetch = globalThis.fetch;
+    const baseFetch = overrideFetch ??
+        (currentGlobalFetch !== initialGlobalFetch || !isPlatformFetch(currentGlobalFetch)
+            ? currentGlobalFetch
+            : proxiedInit.dispatcher
+                ? undiciFetch
+                : currentGlobalFetch);
+    return baseFetch(input, proxiedInit);
+}

package/dist/lib/request/url-rewriting.js

@@ -98,11 +98,28 @@ function shouldBypassProxyForUrl(url, noProxyValue) {
     }
     return false;
 }
+/**
+ * Loopback destinations never traverse a configured proxy: routing them through
+ * HTTP_PROXY would leak managed bearer tokens to the proxy and break the
+ * loopback-only runtime proxy contract. This bypass applies even when NO_PROXY
+ * is unset, matching curl/git proxy conventions.
+ */
+function isLoopbackRequestHost(url) {
+    const hostname = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+    return (hostname === "localhost" ||
+        hostname.endsWith(".localhost") ||
+        hostname === "::1" ||
+        hostname.startsWith("127.") ||
+        hostname.startsWith("::ffff:127."));
+}
 export function resolveProxyUrlForRequest(url, env = process.env) {
     const parsed = new URL(url);
     if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
         return undefined;
     }
+    if (isLoopbackRequestHost(parsed)) {
+        return undefined;
+    }
     const httpProxy = resolveProxyEnvValue(env, "http_proxy", "HTTP_PROXY");
     const httpsProxy = resolveProxyEnvValue(env, "https_proxy", "HTTPS_PROXY");
     if (!httpProxy && !httpsProxy) {

package/dist/lib/runtime/account-model-catalog.d.ts

@@ -23,6 +23,8 @@ export declare class AccountModelCatalog {
     private readonly pending;
     constructor(fetchCatalog: (accountKey: string) => Promise<unknown>, now?: () => number, ttlMs?: number);
     private read;
+    /** Includes successful empty catalogs; stale or failed discovery remains unknown. */
+    hasUsablePickerSnapshot(key: string): boolean;
     /** Picker-only stale-while-refresh view; routing still awaits fresh discovery. */
     cachedList(accountKeys: string[]): CatalogModel[];
     invalidate(): void;

package/dist/lib/runtime/account-model-catalog.js

@@ -83,12 +83,17 @@ export class AccountModelCatalog {
             this.pending.delete(key);
         }
     }
+    /** Includes successful empty catalogs; stale or failed discovery remains unknown. */
+    hasUsablePickerSnapshot(key) {
+        const entry = this.cache.get(key);
+        return Boolean(entry && !entry.error && entry.checkedAt <= this.now() && this.now() - entry.checkedAt < 15 * 60_000);
+    }
     /** Picker-only stale-while-refresh view; routing still awaits fresh discovery. */
     cachedList(accountKeys) {
         return buildVisibleModelUnion(accountKeys.map((key, index) => {
             const entry = this.cache.get(key);
-            const usable = entry && !entry.error && entry.checkedAt <= this.now() && this.now() - entry.checkedAt < 15 * 60_000;
-            return { id: key, kind: "oauth", priority: index, enabled: true, models: usable ? entry.models ?? [] : [], visibleModels: null };
+            const usable = this.hasUsablePickerSnapshot(key);
+            return { id: key, kind: "oauth", priority: index, enabled: true, models: usable ? entry?.models ?? [] : [], visibleModels: null };
         }));
     }
     invalidate() { this.cache.clear(); }

package/dist/lib/runtime/app-bind.d.ts

@@ -1,4 +1,4 @@
-import type { WebSocketDisconnectDiagnostic } from "./responses-websocket.js";
+import type { WebSocketDisconnectDiagnostic, WebSocketUpgradeRejectionDiagnostic } from "./responses-websocket.js";
 export interface AppBindPaths {
     codexHome: string;
     configPath: string;
@@ -39,6 +39,9 @@ export interface AppBindState {
 }
 export interface AppBindRouterStatus {
     lastWebsocketDisconnect?: WebSocketDisconnectDiagnostic | null;
+    websocketActiveConnections?: number | null;
+    websocketCapacityReclaims?: number | null;
+    lastWebsocketUpgradeRejection?: WebSocketUpgradeRejectionDiagnostic | null;
     schedulingStrategy?: "hybrid" | "sequential";
     state: string | null;
     pid: number | null;

package/dist/lib/runtime/app-bind.js

@@ -232,6 +232,29 @@ function readWebsocketDisconnect(value) {
     if (!isRecord(value) || typeof value.at !== "number" || !Number.isFinite(value.at) || value.at < 0)
         return null;
     const { cause, stage, closeCode, routeKind, connectionAgeMs, eventCount } = value;
+    const transport = {};
+    for (const key of ["requestBytes", "inputItemCount"]) {
+        const field = value[key];
+        if (field !== undefined) {
+            if (typeof field !== "number" || !Number.isSafeInteger(field) || field < 0)
+                return null;
+            transport[key] = field;
+        }
+    }
+    for (const key of ["isPrewarm", "hasPreviousResponse", "reusedConnection", "sendCompleted", "compressionNegotiated", "tcpEndReceived", "tcpCloseHadError"]) {
+        const field = value[key];
+        if (field !== undefined) {
+            if (typeof field !== "boolean")
+                return null;
+            transport[key] = field;
+        }
+    }
+    const errorCode = value.transportErrorCode;
+    if (errorCode !== undefined) {
+        if (errorCode !== "ECONNRESET" && errorCode !== "EPIPE" && errorCode !== "ETIMEDOUT" && errorCode !== "OTHER")
+            return null;
+        transport.transportErrorCode = errorCode;
+    }
     if (routeKind !== undefined && routeKind !== "oauth" && routeKind !== "api" && routeKind !== "zdr")
         return null;
     for (const count of [connectionAgeMs, eventCount])
@@ -246,7 +269,24 @@ function readWebsocketDisconnect(value) {
     return { at: value.at, cause, stage, ...(typeof closeCode === "number" ? { closeCode } : {}),
         ...(routeKind === "oauth" || routeKind === "api" || routeKind === "zdr" ? { routeKind } : {}),
         ...(typeof connectionAgeMs === "number" ? { connectionAgeMs } : {}),
-        ...(typeof eventCount === "number" ? { eventCount } : {}) };
+        ...(typeof eventCount === "number" ? { eventCount } : {}), ...transport };
+}
+function readWebsocketCounter(value, maximum = Number.MAX_SAFE_INTEGER) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= maximum
+        ? value : null;
+}
+function readWebsocketUpgradeRejection(value) {
+    if (!isRecord(value))
+        return null;
+    const at = readWebsocketCounter(value.at, 8.64e15);
+    const activeConnections = readWebsocketCounter(value.activeConnections, 64);
+    const { reason, status } = value;
+    if (at === null || activeConnections === null)
+        return null;
+    if (!((reason === "origin" && status === 403) ||
+        ((reason === "capacity" || reason === "repeated_disconnect") && status === 426)))
+        return null;
+    return { at, reason, status, activeConnections };
 }
 async function readRouterStatus(path) {
     const record = await readJsonFile(path);
@@ -254,6 +294,9 @@ async function readRouterStatus(path) {
         return null;
     return {
         lastWebsocketDisconnect: readWebsocketDisconnect(record.lastWebsocketDisconnect),
+        websocketActiveConnections: readWebsocketCounter(record.websocketActiveConnections, 64),
+        websocketCapacityReclaims: readWebsocketCounter(record.websocketCapacityReclaims),
+        lastWebsocketUpgradeRejection: readWebsocketUpgradeRejection(record.lastWebsocketUpgradeRejection),
         schedulingStrategy: record.schedulingStrategy === "hybrid" || record.schedulingStrategy === "sequential"
             ? record.schedulingStrategy : undefined,
         state: readString(record, "state"),
@@ -1407,7 +1450,22 @@ export function formatWebsocketDisconnect(value) {
     const diagnostic = readWebsocketDisconnect(value);
     if (!diagnostic || diagnostic.at > 8.64e15)
         return null;
-    return `Last WebSocket disconnect: ${new Date(diagnostic.at).toISOString()}; cause=${diagnostic.cause}; stage=${diagnostic.stage}${diagnostic.closeCode !== undefined ? `; closeCode=${diagnostic.closeCode}` : ""}${diagnostic.routeKind !== undefined ? `; route=${diagnostic.routeKind}` : ""}${diagnostic.connectionAgeMs !== undefined ? `; connectionAgeMs=${diagnostic.connectionAgeMs}` : ""}${diagnostic.eventCount !== undefined ? `; events=${diagnostic.eventCount}` : ""}`;
+    const transport = ["requestBytes", "inputItemCount", "isPrewarm", "hasPreviousResponse", "reusedConnection", "sendCompleted", "compressionNegotiated", "transportErrorCode", "tcpEndReceived", "tcpCloseHadError"]
+        .filter(key => diagnostic[key] !== undefined).map(key => `; ${key}=${diagnostic[key]}`).join("");
+    return `Last WebSocket disconnect: ${new Date(diagnostic.at).toISOString()}; cause=${diagnostic.cause}; stage=${diagnostic.stage}${diagnostic.closeCode !== undefined ? `; closeCode=${diagnostic.closeCode}` : ""}${diagnostic.routeKind !== undefined ? `; route=${diagnostic.routeKind}` : ""}${diagnostic.connectionAgeMs !== undefined ? `; connectionAgeMs=${diagnostic.connectionAgeMs}` : ""}${diagnostic.eventCount !== undefined ? `; events=${diagnostic.eventCount}` : ""}${transport}`;
+}
+function formatWebsocketAdmission(status) {
+    const active = readWebsocketCounter(status?.websocketActiveConnections, 64);
+    const reclaimed = readWebsocketCounter(status?.websocketCapacityReclaims);
+    const counters = [
+        ...(active !== null ? [`active=${active}`] : []),
+        ...(reclaimed !== null ? [`idleReclaimed=${reclaimed}`] : []),
+    ];
+    const rejection = readWebsocketUpgradeRejection(status?.lastWebsocketUpgradeRejection);
+    return [
+        ...(counters.length ? [`WebSocket connections: ${counters.join("; ")}`] : []),
+        ...(rejection ? [`Last WebSocket upgrade rejection: ${new Date(rejection.at).toISOString()}; reason=${rejection.reason}; status=${rejection.status}; active=${rejection.activeConnections}`] : []),
+    ];
 }
 export function formatAppBindStatus(status) {
     if (status.unmanagedBind && !status.state) {
@@ -1434,11 +1492,13 @@ export function formatAppBindStatus(status) {
         parts.push(`lastAccount=Account ${status.router.lastAccountIndex + 1}`);
     }
     const diagnostic = formatWebsocketDisconnect(status.router?.lastWebsocketDisconnect);
+    const admission = formatWebsocketAdmission(status.router);
     if (status.state.nativeOpenai)
-        return [`Codex app bind: ${parts.join(", ")}, native OpenAI, live account catalogs`, ...(diagnostic ? [diagnostic] : [])].join("\n");
+        return [`Codex app bind: ${parts.join(", ")}, native OpenAI, live account catalogs`, ...(diagnostic ? [diagnostic] : []), ...admission].join("\n");
     return [
         `Codex app bind: ${parts.join(", ")}`,
         ...(diagnostic ? [diagnostic] : []),
+        ...admission,
         [
             "Note: Codex Desktop may hide history while the app bind selects the",
             "codex-multi-auth-runtime-proxy provider; use `codex-multi-auth rotation",

package/dist/lib/runtime/responses-websocket.d.ts

@@ -9,12 +9,33 @@ export interface WebSocketDisconnectDiagnostic {
     routeKind?: "oauth" | "api" | "zdr";
     connectionAgeMs?: number;
     eventCount?: number;
+    requestBytes?: number;
+    inputItemCount?: number;
+    isPrewarm?: boolean;
+    hasPreviousResponse?: boolean;
+    reusedConnection?: boolean;
+    /** Local send callback success, not evidence of upstream receipt. */
+    sendCompleted?: boolean;
+    compressionNegotiated?: boolean;
+    transportErrorCode?: "ECONNRESET" | "EPIPE" | "ETIMEDOUT" | "OTHER";
+    tcpEndReceived?: boolean;
+    tcpCloseHadError?: boolean;
+}
+/** Local admission evidence only; no headers, credentials, or conversation IDs. */
+export interface WebSocketUpgradeRejectionDiagnostic {
+    at: number;
+    reason: "origin" | "capacity" | "repeated_disconnect";
+    status: number;
+    activeConnections: number;
 }
 interface WebSocketStats {
     connections: number;
+    activeConnections: number;
+    capacityReclaims: number;
     upstreamConnections: number;
     upstreamRequests: number;
     lastDisconnect?: WebSocketDisconnectDiagnostic;
+    lastUpgradeRejection?: WebSocketUpgradeRejectionDiagnostic;
 }
 /** Adapts only the transport; authenticated HTTP routing remains the policy authority. */
 export declare class ResponsesWebSocketGateway {
@@ -24,6 +45,9 @@ export declare class ResponsesWebSocketGateway {
     private readonly contexts;
     private readonly scope;
     private readonly sessions;
+    /** Credential-hashed, bounded API handshake backoff survives local reconnects. */
+    private readonly apiHandshakeBackoff;
+    private readonly websocketFailures;
     private readonly wss;
     private readonly maxBytes;
     /** Loopback hops must never go through an environment HTTP proxy (NODE_USE_ENV_PROXY). */
@@ -35,6 +59,12 @@ export declare class ResponsesWebSocketGateway {
         routeModel?: (model: string, headers: Headers) => string;
     });
     readonly fetch: typeof fetch;
+    private rememberDisconnect;
+    private needsHttpFallback;
+    /** One writer for the upgrade-rejection diagnostic so the two reject paths cannot drift. */
+    private recordUpgradeRejection;
+    /** Release idle setup sockets only; active work and generated history stay pinned. */
+    private reclaimIdleSession;
     handle(req: IncomingMessage, handler: () => Promise<void>): void;
     attach(server: Server, baseUrl: string): void;
     private serve;