codex-multi-auth 2.19.1 → 2.20.0

package/config/minimal-codex.json

@@ -1,15 +1,15 @@
-{
-  "$schema": "./schema/config.schema.json",
-  "plugin": ["codex-multi-auth"],
-
-  "provider": {
-    "openai": {
-      "options": {
-        "store": false
-      }
-    }
-  },
-  "model": "openai/gpt-5.6-sol"
-}
-
-
+{
+  "$schema": "./schema/config.schema.json",
+  "plugin": ["codex-multi-auth"],
+
+  "provider": {
+    "openai": {
+      "options": {
+        "store": false
+      }
+    }
+  },
+  "model": "openai/gpt-5.6-sol"
+}
+
+

package/dist/index.js

@@ -1043,7 +1043,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                             }
                                             let response;
                                             const fetchStart = performance.now();
-                                            // Merge user AbortSignal with timeout (Node 18 compatible - no AbortSignal.any)
+                                            // Merge user AbortSignal with timeout without AbortSignal.any (keeps listeners bounded)
                                             const fetchController = new AbortController();
                                             const requestTimeoutMs = fetchTimeoutMs;
                                             let requestTimedOut = false;

package/dist/lib/accounts/rate-limits.js

@@ -2,6 +2,7 @@
  * Rate limiting utilities for account management.
  * Extracted from accounts.ts to reduce module size and improve cohesion.
  */
+import { LUNA_RESERVE_MODEL } from "../constants.js";
 import { nowMs } from "../utils.js";
 export function parseRateLimitReason(code) {
     if (!code)
@@ -61,6 +62,10 @@ export function isRateLimitedForFamily(entity, family, model) {
         if (isRateLimitedForQuotaKey(entity, modelKey)) {
             return true;
         }
+        // Luna Reserve is independently metered. Ordinary Luna/Codex family
+        // exhaustion must not suppress a separately available reserve allowance.
+        if (model === LUNA_RESERVE_MODEL)
+            return false;
     }
     const baseKey = getQuotaKey(family);
     return isRateLimitedForQuotaKey(entity, baseKey);

package/dist/lib/accounts.js

@@ -9,7 +9,7 @@ import { MODEL_FAMILIES } from "./request/helpers/model-map.js";
 import { getHealthTracker, getTokenTracker, resetTrackers, selectHybridAccount, } from "./rotation.js";
 import { withRoutingMutex, } from "./routing-mutex.js";
 import { nowMs } from "./utils.js";
-import { ERROR_MESSAGES, HTTP_STATUS, MAX_RATE_LIMIT_DELAY_MS } from "./constants.js";
+import { ERROR_MESSAGES, HTTP_STATUS, LUNA_RESERVE_MODEL, MAX_RATE_LIMIT_DELAY_MS } from "./constants.js";
 import { CodexAuthError } from "./errors.js";
 import { loadCodexCliState, } from "./codex-cli/state.js";
 import { syncAccountStorageFromCodexCli } from "./codex-cli/sync.js";
@@ -1062,13 +1062,14 @@ export class AccountManager {
             : undefined;
         const newLimits = { ...carried?.limits };
         const baseKey = getQuotaKey(family);
-        if (!model || reason === "quota" || reason === "unknown") {
+        const independentReserve = model === LUNA_RESERVE_MODEL;
+        if (!independentReserve && (!model || reason === "quota" || reason === "unknown")) {
             const currentResetAt = account.rateLimitResetTimes[baseKey] ?? 0;
             account.rateLimitResetTimes[baseKey] = Math.max(currentResetAt, resetAt);
             newLimits[baseKey] = Math.max(newLimits[baseKey] ?? 0, resetAt);
         }
         if (model &&
-            (reason === "tokens" || reason === "concurrent" || reason === "unknown")) {
+            (independentReserve || reason === "tokens" || reason === "concurrent" || reason === "unknown")) {
             const modelKey = getQuotaKey(family, model);
             const currentResetAt = account.rateLimitResetTimes[modelKey] ?? 0;
             account.rateLimitResetTimes[modelKey] = Math.max(currentResetAt, resetAt);
@@ -1550,7 +1551,7 @@ export class AccountManager {
         for (const account of enabledAccounts) {
             const perAccountWaitTimes = [];
             const baseResetAt = account.rateLimitResetTimes[baseKey];
-            if (typeof baseResetAt === "number") {
+            if (model !== LUNA_RESERVE_MODEL && typeof baseResetAt === "number") {
                 perAccountWaitTimes.push(Math.max(0, baseResetAt - now));
             }
             if (modelKey) {

package/dist/lib/auth/account-access.js

@@ -51,8 +51,8 @@ export async function fetchAuthorizedAccounts(accessToken, options = {}) {
         return null;
     const doFetch = options.fetch ?? globalThis.fetch;
     const timeout = AbortSignal.timeout(ACCOUNTS_CHECK_TIMEOUT_MS);
-    // combineSignals wraps AbortSignal.any (available since Node 18.17, the
-    // engines floor) with null-tolerance; the native composite also detaches
+    // combineSignals wraps AbortSignal.any (available on every Node the
+    // engines floor, `>=22.19`, permits) with null-tolerance; the native composite also detaches
     // from a long-lived caller signal once this request completes.
     const signal = options.signal
         ? combineSignals(options.signal, timeout)

package/dist/lib/codex-cli/version.d.ts

@@ -0,0 +1,22 @@
+interface ResolvedCodexBin {
+    path: string;
+    launchWithNode: boolean;
+}
+export interface CodexCliVersionDeps {
+    resolveBin?: () => Promise<ResolvedCodexBin | null>;
+    execFile?: (file: string, args: readonly string[], options: {
+        timeout: number;
+    }) => Promise<{
+        stdout: string;
+    }>;
+}
+export declare const CLIENT_VERSION_PATTERN: RegExp;
+/** Extracts `0.160.1` from `codex --version` output such as `codex-cli 0.160.1`. */
+export declare function parseCodexCliVersion(output: string): string | null;
+/**
+ * Returns the installed Codex CLI version, or null when no binary resolves or
+ * the probe fails. Detection failure must never break a check: the caller just
+ * sends no `client_version`, exactly as before.
+ */
+export declare function detectInstalledCodexCliVersion(deps?: CodexCliVersionDeps): Promise<string | null>;
+export {};

package/dist/lib/codex-cli/version.js

@@ -0,0 +1,78 @@
+/**
+ * Detects the installed Codex CLI version for the `client_version` parameter
+ * the upstream models catalog requires (issue #733). The catalog filters by
+ * `minimal_client_version`, so the honest value is whatever `codex --version`
+ * reports on this host — never a hardcoded string.
+ */
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+// scripts/codex-bin-resolver.js is plain shipped JS, so it loads by URL:
+// dist/lib/codex-cli/ resolves ../../../scripts, the source tree ../../scripts.
+const RESOLVER_CANDIDATES = [
+    fileURLToPath(new URL("../../../scripts/codex-bin-resolver.js", import.meta.url)),
+    fileURLToPath(new URL("../../scripts/codex-bin-resolver.js", import.meta.url)),
+];
+async function loadBinResolver() {
+    for (const candidate of RESOLVER_CANDIDATES) {
+        if (!existsSync(candidate))
+            continue;
+        const resolverModule = (await import(pathToFileURL(candidate).href).catch(() => null));
+        if (typeof resolverModule?.resolveRealCodexBin === "function") {
+            return resolverModule;
+        }
+    }
+    return null;
+}
+async function defaultResolveBin() {
+    const resolverModule = await loadBinResolver();
+    const resolve = resolverModule?.resolveRealCodexBin;
+    if (!resolve)
+        return null;
+    const bin = resolve();
+    // PATH discovery can hand back npm's extensionless `codex` shim on Windows,
+    // which no spawn API can exec. The resolver knows the sibling package entry
+    // the shim points at; launch that through node instead.
+    if (bin &&
+        process.platform === "win32" &&
+        !bin.launchWithNode &&
+        resolverModule.isWindowsShimPath?.(bin.path)) {
+        const entry = resolverModule.resolveWindowsShimPackageEntry?.(bin.path);
+        if (entry)
+            return { path: entry, launchWithNode: true };
+    }
+    return bin;
+}
+const defaultExecFile = (file, args, options) => new Promise((resolve, reject) => {
+    execFile(file, [...args], { ...options, encoding: "utf8", windowsHide: true, maxBuffer: 1024 * 1024 }, (error, stdout) => {
+        if (error)
+            reject(error);
+        else
+            resolve({ stdout: String(stdout) });
+    });
+});
+export const CLIENT_VERSION_PATTERN = /^[0-9A-Za-z.+_-]{1,80}$/;
+/** Extracts `0.160.1` from `codex --version` output such as `codex-cli 0.160.1`. */
+export function parseCodexCliVersion(output) {
+    const match = /(?:^|\s)v?(\d+\.\d+\.\d+[-0-9A-Za-z.+_]*)/.exec(output);
+    const version = match?.[1];
+    return version && CLIENT_VERSION_PATTERN.test(version) ? version : null;
+}
+/**
+ * Returns the installed Codex CLI version, or null when no binary resolves or
+ * the probe fails. Detection failure must never break a check: the caller just
+ * sends no `client_version`, exactly as before.
+ */
+export async function detectInstalledCodexCliVersion(deps = {}) {
+    try {
+        const bin = await (deps.resolveBin ?? defaultResolveBin)();
+        if (!bin || typeof bin.path !== "string" || bin.path.length === 0)
+            return null;
+        const exec = deps.execFile ?? defaultExecFile;
+        const { stdout } = await exec(bin.launchWithNode ? process.execPath : bin.path, bin.launchWithNode ? [bin.path, "--version"] : ["--version"], { timeout: 10_000 });
+        return parseCodexCliVersion(stdout);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/codex-manager/commands/limits.d.ts

@@ -1,11 +1,13 @@
 import { type ModelFamily } from "../../prompts/codex.js";
 import type { QuotaCacheData } from "../../quota-cache.js";
 import type { AccountStorageV3 } from "../../storage.js";
+import type { LunaReserveSnapshot } from "../../luna-reserve.js";
 export interface LimitsCommandDeps {
     setStoragePath: (path: string | null) => void;
     loadAccounts: () => Promise<AccountStorageV3 | null>;
     loadQuotaCache: () => Promise<QuotaCacheData>;
     refreshQuotaCache: (storage: AccountStorageV3, cache: QuotaCacheData, maxAgeMs: number) => Promise<QuotaCacheData>;
+    refreshLunaReserveUsage?: (storage: AccountStorageV3) => Promise<Record<number, LunaReserveSnapshot>>;
     resolveActiveIndex: (storage: AccountStorageV3, family?: ModelFamily) => number;
     getNow?: () => number;
     logInfo?: (message: string) => void;

package/dist/lib/codex-manager/commands/limits.js

@@ -46,6 +46,32 @@ function publicQuotaEntry(entry) {
         secondary: publicWindow(entry.secondary),
     };
 }
+/** Convert one Reserve window to the stable public JSON shape. */
+function publicReserveWindow(window) {
+    return window
+        ? {
+            usedPercent: window.usedPercent,
+            remainingPercent: window.remainingPercent,
+            windowMinutes: window.windowMinutes,
+            resetAtMs: window.resetAtMs,
+        }
+        : null;
+}
+/** Convert a Reserve snapshot to public JSON while preserving explicit unknowns. */
+function publicLunaReserve(snapshot) {
+    if (!snapshot)
+        return null;
+    return {
+        observedAt: snapshot.observedAt,
+        offered: snapshot.offered,
+        available: snapshot.available,
+        limitId: snapshot.limitId,
+        limitName: snapshot.limitName,
+        normalModelSlug: snapshot.normalModelSlug,
+        primary: publicReserveWindow(snapshot.primary),
+        secondary: publicReserveWindow(snapshot.secondary),
+    };
+}
 /**
  * Emit configured accounts joined to safe cached quota records.
  *
@@ -86,8 +112,12 @@ export async function runLimitsCommand(args, deps) {
         return 0;
     }
     let cache = await deps.loadQuotaCache();
+    let lunaReserveByAccount = {};
     if (parsed.options.refresh) {
         cache = await deps.refreshQuotaCache(storage, cache, LIMITS_REFRESH_MAX_AGE_MS);
+        if (deps.refreshLunaReserveUsage) {
+            lunaReserveByAccount = await deps.refreshLunaReserveUsage(storage);
+        }
     }
     const generatedAt = deps.getNow?.() ?? Date.now();
     const selection = resolveSelection(storage, deps.resolveActiveIndex);
@@ -102,6 +132,7 @@ export async function runLimitsCommand(args, deps) {
             enabled: account.enabled !== false,
             current: index === selection.routedIndex,
             quota: quota ? publicQuotaEntry(quota) : null,
+            lunaReserve: publicLunaReserve(lunaReserveByAccount[index]),
         };
     });
     logInfo(JSON.stringify({

package/dist/lib/codex-manager/commands/status.js

@@ -279,7 +279,7 @@ export async function runStatusCommand(deps) {
             runtimeSnapshot.serverBurstCooldownUntil > now
             ? formatWaitTime(runtimeSnapshot.serverBurstCooldownUntil - now)
             : null;
-        logInfo(`Runtime: responses=${runtimeSnapshot.responsesRequests}, refresh=${runtimeSnapshot.authRefreshRequests}, probes=${runtimeSnapshot.diagnosticProbeRequests}, budgetExhaustions=${runtimeMetrics.requestAttemptBudgetExhaustions}`);
+        logInfo(`Runtime: responses=${runtimeSnapshot.responsesRequests}, refresh=${runtimeSnapshot.authRefreshRequests}, probes=${runtimeSnapshot.diagnosticProbeRequests}, reserveFallbacks=${runtimeSnapshot.lunaReserveFallbacks ?? 0}, budgetExhaustions=${runtimeMetrics.requestAttemptBudgetExhaustions}`);
         const lastRuntimeAccount = formatRuntimeLastAccount(runtimeSnapshot);
         if (lastRuntimeAccount) {
             logInfo(paint(`Last runtime account: ${lastRuntimeAccount}`, "accent"));

package/dist/lib/codex-manager.js

@@ -46,6 +46,7 @@ import { runUnpinCommand } from "./codex-manager/commands/unpin.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";
+import { refreshLunaReserveUsage } from "./runtime/luna-reserve-usage.js";
 import { printUsage } from "./codex-manager/help.js";
 import { availabilityTone, formatBackupSavedAt, formatCompactQuotaSnapshot, formatRateLimitEntry, formatResultSummary, normalizeFailureDetail, riskTone, styleAccountDetailText, stylePromptText, styleQuotaSummary, } from "./codex-manager/formatters/index.js";
 import { applyUiThemeFromDashboardSettings } from "./codex-manager/settings-hub.js";
@@ -307,6 +308,7 @@ const CLI_COMMAND_HANDLERS = new Map([
             loadAccounts,
             loadQuotaCache,
             refreshQuotaCache: refreshQuotaCacheForMenu,
+            refreshLunaReserveUsage,
             resolveActiveIndex,
         }),
     ],

package/dist/lib/constants.d.ts

@@ -6,6 +6,8 @@
 export declare const PLUGIN_NAME = "codex-multi-auth";
 /** Base URL for ChatGPT backend API */
 export declare const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+/** Backend model used for the separately metered Luna Reserve allowance. */
+export declare const LUNA_RESERVE_MODEL: "gpt-reserve";
 /** Dummy API key used for OpenAI SDK (actual auth via OAuth) */
 export declare const DUMMY_API_KEY = "chatgpt-oauth";
 /** Provider ID for UI display - shows under "OpenAI" in auth dropdown */

package/dist/lib/constants.js

@@ -6,6 +6,8 @@
 export const PLUGIN_NAME = "codex-multi-auth";
 /** Base URL for ChatGPT backend API */
 export const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+/** Backend model used for the separately metered Luna Reserve allowance. */
+export const LUNA_RESERVE_MODEL = "gpt-reserve";
 /** Dummy API key used for OpenAI SDK (actual auth via OAuth) */
 export const DUMMY_API_KEY = "chatgpt-oauth";
 /** Provider ID for UI display - shows under "OpenAI" in auth dropdown */

package/dist/lib/context-budget/model-context-windows.d.ts

@@ -6,7 +6,7 @@
  * behavior (see the v2.5.0 release notes) closely enough to launch that no
  * estimate here has been reviewed for it yet.
  */
-export declare const UNESTIMATED_ROUTABLE_MODELS: readonly ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-6-astra", "gpt-6-sol", "gpt-6-luna", "gpt-6.1-sol", "gpt-daybreak-blue-latest", "gpt-daybreak-red-latest"];
+export declare const UNESTIMATED_ROUTABLE_MODELS: readonly ["gpt-5.6-sol", "gpt-5.6-terra", "gpt-5.6-luna", "gpt-6-astra", "gpt-6-sol", "gpt-6-luna", "gpt-reserve", "gpt-6.1-sol", "gpt-daybreak-blue-latest", "gpt-daybreak-red-latest"];
 export interface EffectiveContextWindow {
     tokens: number;
     source: "override" | "estimate";

package/dist/lib/context-budget/model-context-windows.js

@@ -53,6 +53,10 @@ export const UNESTIMATED_ROUTABLE_MODELS = [
     // upstream catalog as Astra, so the same reasoning keeps them unestimated.
     "gpt-6-sol",
     "gpt-6-luna",
+    // Luna Reserve is a quota alias of Luna, but the backend does not publish
+    // a distinct transport context ceiling for the alias. Keep it fail-closed
+    // alongside Luna rather than copying an unverified API/catalog number.
+    "gpt-reserve",
     "gpt-6.1-sol",
     "gpt-daybreak-blue-latest",
     "gpt-daybreak-red-latest",

package/dist/lib/context-budget-response.js

@@ -17,14 +17,14 @@ function buildPauseMessage(advisory) {
     const windowNote = advisory.windowSource === "override"
         ? "your configured window size"
         : "an estimated window size (unverified — set `contextBudgetGuardModelWindowOverrides` if you know the real limit)";
-    return `[Plugin Notice] Context budget guard paused this session at ${formatPercent(advisory.percent)}% of ${windowNote} for \`${advisory.model}\`, before hitting the model's actual limit.
-
-Please use one of these commands to reduce context size:
-
-• **/compact** - Compress conversation history (recommended)
-• **/clear** - Start fresh with empty context
-• **/undo** - Remove recent messages
-
+    return `[Plugin Notice] Context budget guard paused this session at ${formatPercent(advisory.percent)}% of ${windowNote} for \`${advisory.model}\`, before hitting the model's actual limit.
+
+Please use one of these commands to reduce context size:
+
+• **/compact** - Compress conversation history (recommended)
+• **/clear** - Start fresh with empty context
+• **/undo** - Remove recent messages
+
 Then retry your request. This pause clears itself automatically once your context usage drops back below the threshold.`;
 }
 /**

package/dist/lib/context-overflow.js

@@ -33,16 +33,16 @@ export function isContextOverflowError(status, bodyText) {
 /**
  * The message shown to users when context overflow occurs
  */
-const CONTEXT_OVERFLOW_MESSAGE = `[Plugin Notice] Context is too long for this model.
-
-Please use one of these commands to reduce context size:
-
-• **/compact** - Compress conversation history (recommended)
-• **/clear** - Start fresh with empty context
-• **/undo** - Remove recent messages
-
-Then retry your request.
-
+const CONTEXT_OVERFLOW_MESSAGE = `[Plugin Notice] Context is too long for this model.
+
+Please use one of these commands to reduce context size:
+
+• **/compact** - Compress conversation history (recommended)
+• **/clear** - Start fresh with empty context
+• **/undo** - Remove recent messages
+
+Then retry your request.
+
 Alternatively, you can switch to a model with a larger context window.`;
 /**
  * Creates a synthetic SSE response for context overflow errors.

package/dist/lib/luna-reserve.d.ts

@@ -0,0 +1,26 @@
+import { LUNA_RESERVE_MODEL } from "./constants.js";
+export interface LunaReserveWindow {
+    usedPercent: number | null;
+    remainingPercent: number | null;
+    windowMinutes: number | null;
+    resetAtMs: number | null;
+}
+export interface LunaReserveSnapshot {
+    observedAt: number;
+    offered: boolean;
+    available: boolean | null;
+    limitId: string | null;
+    limitName: typeof LUNA_RESERVE_MODEL | null;
+    normalModelSlug: string | null;
+    primary: LunaReserveWindow | null;
+    secondary: LunaReserveWindow | null;
+}
+/**
+ * Parse the official Codex app-server `account/rateLimits/read` response for
+ * the separately metered Luna Reserve bucket.
+ *
+ * Absence is intentionally represented as `offered:false`, never as 0% left:
+ * the backend may omit Reserve when an account is not currently eligible or
+ * when the experiment is not active for that account.
+ */
+export declare function parseLunaReserveRateLimits(value: unknown, observedAt?: number): LunaReserveSnapshot;

package/dist/lib/luna-reserve.js

@@ -0,0 +1,68 @@
+import { LUNA_RESERVE_MODEL } from "./constants.js";
+import { isRecord } from "./utils.js";
+/** Return a finite numeric value or null for malformed backend data. */
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+/** Normalize backend percentages into the inclusive 0-100 range. */
+function clampPercent(value) {
+    const number = finiteNumber(value);
+    return number === null ? null : Math.max(0, Math.min(100, number));
+}
+/** Parse one Reserve usage window without inventing missing values. */
+function parseWindow(value) {
+    if (!isRecord(value))
+        return null;
+    const usedPercent = clampPercent(value.usedPercent);
+    const duration = finiteNumber(value.windowDurationMins);
+    const resetSeconds = finiteNumber(value.resetsAt);
+    return {
+        usedPercent,
+        remainingPercent: usedPercent === null ? null : Math.max(0, 100 - usedPercent),
+        windowMinutes: duration === null || duration < 0 ? null : duration,
+        resetAtMs: resetSeconds === null || resetSeconds <= 0 ? null : resetSeconds * 1000,
+    };
+}
+/**
+ * Parse the official Codex app-server `account/rateLimits/read` response for
+ * the separately metered Luna Reserve bucket.
+ *
+ * Absence is intentionally represented as `offered:false`, never as 0% left:
+ * the backend may omit Reserve when an account is not currently eligible or
+ * when the experiment is not active for that account.
+ */
+export function parseLunaReserveRateLimits(value, observedAt = Date.now()) {
+    const absent = {
+        observedAt,
+        offered: false,
+        available: null,
+        limitId: null,
+        limitName: null,
+        normalModelSlug: null,
+        primary: null,
+        secondary: null,
+    };
+    if (!isRecord(value) || !isRecord(value.rateLimitsByLimitId))
+        return absent;
+    for (const [limitId, candidate] of Object.entries(value.rateLimitsByLimitId)) {
+        if (!isRecord(candidate) || candidate.limitName !== LUNA_RESERVE_MODEL)
+            continue;
+        const primary = parseWindow(candidate.primary);
+        const secondary = parseWindow(candidate.secondary);
+        const knownWindows = [primary, secondary].filter((window) => window !== null && window.usedPercent !== null);
+        const exhausted = knownWindows.some((window) => (window.usedPercent ?? 0) >= 100);
+        return {
+            observedAt,
+            offered: true,
+            available: knownWindows.length === 0 ? null : !exhausted,
+            limitId: limitId || (typeof candidate.limitId === "string" ? candidate.limitId : null),
+            limitName: LUNA_RESERVE_MODEL,
+            normalModelSlug: typeof candidate.normalModelSlug === "string" && candidate.normalModelSlug.trim()
+                ? candidate.normalModelSlug.trim()
+                : null,
+            primary,
+            secondary,
+        };
+    }
+    return absent;
+}