codex-multi-auth 1.3.2 → 2.0.1

package/dist/lib/codex-manager.js

@@ -19,12 +19,14 @@ import { runDoctor as runRepairDoctor, runFix as runRepairFix, runVerifyFlagged
 import { runForecastCommand } from "./codex-manager/commands/forecast.js";
 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 { loadPersistedRuntimeObservabilitySnapshot } from "./runtime/runtime-observability.js";
 import { runSwitchCommand } from "./codex-manager/commands/switch.js";
 import { parseAuthLoginArgs, printUsage } from "./codex-manager/help.js";
 import { applyUiThemeFromDashboardSettings, configureUnifiedSettings, resolveMenuLayoutMode, } from "./codex-manager/settings-hub.js";
-import { getPluginConfigExplainReport } from "./config.js";
+import { getCodexRuntimeRotationProxy, getPluginConfigExplainReport, loadPluginConfig, savePluginConfig, } from "./config.js";
+import { bindCodexAppRuntimeRotation, getAppBindStatus, unbindCodexAppRuntimeRotation, } from "./runtime/app-bind.js";
 import { ACCOUNT_LIMITS } from "./constants.js";
 import { DEFAULT_DASHBOARD_DISPLAY_SETTINGS, loadDashboardDisplaySettings, } from "./dashboard-settings.js";
 import { evaluateForecastAccounts, recommendForecastAccount, summarizeForecast, } from "./forecast.js";
@@ -32,7 +34,9 @@ import { createLogger } from "./logger.js";
 import { MODEL_FAMILIES } from "./prompts/codex.js";
 import { getModelCapabilities, getModelProfile, resolveNormalizedModel, } from "./request/helpers/model-map.js";
 import { formatRateLimitEntry as formatAccountRateLimitEntry, getRateLimitResetTimeForFamily, resolveActiveIndex, } from "./runtime/account-status.js";
+import { buildQuotaEmailFallbackState, hasSafeQuotaEmailFallback, hasUniqueQuotaAccountId, isQuotaCacheEntryExhausted, normalizeQuotaAccountId, normalizeQuotaEmail, quotaLeftPercentFromUsed, } from "./quota-readiness.js";
 import { loadQuotaCache, saveQuotaCache, } from "./quota-cache.js";
+import { isDisplayCurrentAccount, readAppRuntimeHelperAccountSignal, resolveAccountCurrentMarkers, resolveRuntimeCurrentAccount, } from "./runtime/runtime-current-account.js";
 import { fetchCodexQuotaSnapshot, formatQuotaSnapshotLine, } from "./quota-probe.js";
 import { queuedRefresh } from "./refresh-queue.js";
 import { clearAccounts, findMatchingAccountIndex, formatStorageErrorHint, inspectStorageHealth, getLastAccountsSaveTimestamp, getNamedBackups, getStoragePath, loadAccounts, loadFlaggedAccounts, restoreAccountsFromBackup, StorageError, saveAccounts, setStoragePath, withAccountStorageTransaction, } from "./storage.js";
@@ -316,70 +320,6 @@ const IMPLEMENTED_FEATURES = [
 function formatRateLimitEntry(account, now, family = "codex") {
     return formatAccountRateLimitEntry(account, now, formatWaitTime, family);
 }
-function normalizeQuotaEmail(email) {
-    const normalized = sanitizeEmail(email);
-    return normalized && normalized.length > 0 ? normalized : null;
-}
-function normalizeQuotaAccountId(accountId) {
-    if (typeof accountId !== "string")
-        return null;
-    const trimmed = accountId.trim();
-    return trimmed.length > 0 ? trimmed : null;
-}
-function hasUniqueQuotaAccountId(accounts, account) {
-    const accountId = normalizeQuotaAccountId(account.accountId);
-    if (!accountId)
-        return false;
-    let matchCount = 0;
-    for (const candidate of accounts) {
-        if (normalizeQuotaAccountId(candidate.accountId) !== accountId)
-            continue;
-        matchCount += 1;
-        if (matchCount > 1)
-            return false;
-    }
-    return matchCount === 1;
-}
-function buildQuotaEmailFallbackState(accounts) {
-    const stateByEmail = new Map();
-    for (const account of accounts) {
-        const email = normalizeQuotaEmail(account.email);
-        if (!email)
-            continue;
-        const existing = stateByEmail.get(email);
-        if (existing) {
-            existing.matchingCount += 1;
-            const accountId = normalizeQuotaAccountId(account.accountId);
-            if (accountId) {
-                existing.distinctAccountIds.add(accountId);
-            }
-            continue;
-        }
-        const distinctAccountIds = new Set();
-        const accountId = normalizeQuotaAccountId(account.accountId);
-        if (accountId) {
-            distinctAccountIds.add(accountId);
-        }
-        stateByEmail.set(email, {
-            matchingCount: 1,
-            distinctAccountIds,
-        });
-    }
-    return stateByEmail;
-}
-function hasSafeQuotaEmailFallback(emailFallbackState, account) {
-    const email = normalizeQuotaEmail(account.email);
-    if (!email)
-        return false;
-    const state = emailFallbackState.get(email);
-    if (!state)
-        return false;
-    // size > 1 only matters when multiple accounts share the same email but
-    // disagree on accountId; a single matching account already implies size <= 1.
-    if (state.distinctAccountIds.size > 1)
-        return false;
-    return state.matchingCount === 1;
-}
 function quotaCacheEntryToSnapshot(entry) {
     return {
         status: entry.status,
@@ -415,13 +355,7 @@ function formatCompactQuotaPart(windowMinutes, usedPercent) {
     const left = quotaLeftPercentFromUsed(usedPercent);
     return `${label} ${left}%`;
 }
-function quotaLeftPercentFromUsed(usedPercent) {
-    if (typeof usedPercent !== "number" || !Number.isFinite(usedPercent)) {
-        return undefined;
-    }
-    return Math.max(0, Math.min(100, Math.round(100 - usedPercent)));
-}
-function formatCompactQuotaSnapshot(snapshot) {
+function formatCompactQuotaSnapshot(snapshot, now = Date.now()) {
     const parts = [
         formatCompactQuotaPart(snapshot.primary.windowMinutes, snapshot.primary.usedPercent),
         formatCompactQuotaPart(snapshot.secondary.windowMinutes, snapshot.secondary.usedPercent),
@@ -429,12 +363,15 @@ function formatCompactQuotaSnapshot(snapshot) {
     if (snapshot.status === 429) {
         parts.push("rate-limited");
     }
+    if (isQuotaCacheEntryExhausted(snapshot, now)) {
+        parts.push("quota-exhausted");
+    }
     if (parts.length > 0) {
         return parts.join(" | ");
     }
     return formatQuotaSnapshotLine(snapshot);
 }
-function formatAccountQuotaSummary(entry) {
+function formatAccountQuotaSummary(entry, now = Date.now()) {
     const parts = [
         formatCompactQuotaPart(entry.primary.windowMinutes, entry.primary.usedPercent),
         formatCompactQuotaPart(entry.secondary.windowMinutes, entry.secondary.usedPercent),
@@ -442,6 +379,9 @@ function formatAccountQuotaSummary(entry) {
     if (entry.status === 429) {
         parts.push("rate-limited");
     }
+    if (isQuotaCacheEntryExhausted(entry, now)) {
+        parts.push("quota-exhausted");
+    }
     if (parts.length > 0) {
         return parts.join(" | ");
     }
@@ -479,7 +419,7 @@ function getPersistedQuotaViewForAccount(cache, account, accounts, now, emailFal
     return {
         updatedAt: cachedEntry?.updatedAt ?? now,
         status: 429,
-        model: cachedEntry?.model ?? "gpt-5-codex",
+        model: cachedEntry?.model ?? "gpt-5.3-codex",
         planType: cachedEntry?.planType,
         primary: {
             ...cachedEntry?.primary,
@@ -547,7 +487,7 @@ function pruneUnsafeQuotaEmailCacheEntry(cache, email, accounts, emailFallbackSt
     return true;
 }
 const DEFAULT_MENU_QUOTA_REFRESH_TTL_MS = 5 * 60_000;
-const MENU_QUOTA_REFRESH_MODEL = "gpt-5-codex";
+const MENU_QUOTA_REFRESH_MODEL = "gpt-5.3-codex";
 function resolveMenuQuotaProbeInput(account, cache, maxAgeMs, now, accounts, emailFallbackState = buildQuotaEmailFallbackState(accounts)) {
     if (account.enabled === false)
         return null;
@@ -649,19 +589,22 @@ function hasLikelyInvalidRefreshToken(refreshToken) {
         return true;
     return trimmed.startsWith("token-");
 }
-function mapAccountStatus(account, index, activeIndex, now, persistedQuotaStatus) {
+function mapAccountStatus(account, isCurrentAccount, now, persistedQuotaEntry) {
     if (account.enabled === false)
         return "disabled";
     if (typeof account.coolingDownUntil === "number" &&
         account.coolingDownUntil > now) {
         return "cooldown";
     }
-    if (persistedQuotaStatus === 429)
+    if (persistedQuotaEntry && isQuotaCacheEntryExhausted(persistedQuotaEntry, now)) {
+        return "quota-exhausted";
+    }
+    if (persistedQuotaEntry?.status === 429)
         return "rate-limited";
     const rateLimit = formatRateLimitEntry(account, now, "codex");
     if (rateLimit)
         return "rate-limited";
-    if (index === activeIndex)
+    if (isCurrentAccount)
         return "active";
     return "ok";
 }
@@ -693,6 +636,7 @@ function accountStatusSortBucket(status) {
             return 0;
         case "unknown":
             return 1;
+        case "quota-exhausted":
         case "cooldown":
         case "rate-limited":
             return 2;
@@ -708,7 +652,7 @@ function accountReadinessSortBucket(account) {
     const statusBucket = accountStatusSortBucket(account.status);
     if (statusBucket >= 2)
         return statusBucket;
-    return account.quotaRateLimited ? 2 : statusBucket;
+    return account.quotaRateLimited || account.quotaExhausted ? 2 : statusBucket;
 }
 function compareReadyFirstAccounts(left, right) {
     const bucketDelta = accountReadinessSortBucket(left) - accountReadinessSortBucket(right);
@@ -763,13 +707,16 @@ function applyAccountMenuOrdering(accounts, displaySettings) {
     }
     return sorted;
 }
-function toExistingAccountInfo(storage, quotaCache, displaySettings) {
+function toExistingAccountInfo(storage, quotaCache, displaySettings, runtimeCurrent = null) {
     const now = Date.now();
     const activeIndex = resolveActiveIndex(storage, "codex");
     const layoutMode = resolveMenuLayoutMode(displaySettings);
     const emailFallbackState = buildQuotaEmailFallbackState(storage.accounts);
     const baseAccounts = storage.accounts.map((account, index) => {
         const entry = getPersistedQuotaViewForAccount(quotaCache, account, storage.accounts, now, emailFallbackState);
+        const currentMarkers = resolveAccountCurrentMarkers(index, activeIndex, runtimeCurrent);
+        const isCurrentAccount = isDisplayCurrentAccount(index, activeIndex, runtimeCurrent);
+        const quotaExhausted = entry ? isQuotaCacheEntryExhausted(entry, now) : false;
         return {
             index,
             sourceIndex: index,
@@ -778,16 +725,20 @@ function toExistingAccountInfo(storage, quotaCache, displaySettings) {
             email: account.email,
             addedAt: account.addedAt,
             lastUsed: account.lastUsed,
-            status: mapAccountStatus(account, index, activeIndex, now, entry?.status),
+            status: mapAccountStatus(account, isCurrentAccount, now, entry),
             quotaSummary: (displaySettings.menuShowQuotaSummary ?? true) && entry
-                ? formatAccountQuotaSummary(entry)
+                ? formatAccountQuotaSummary(entry, now)
                 : undefined,
             quota5hLeftPercent: quotaLeftPercentFromUsed(entry?.primary.usedPercent),
             quota5hResetAtMs: entry?.primary.resetAtMs,
             quota7dLeftPercent: quotaLeftPercentFromUsed(entry?.secondary.usedPercent),
             quota7dResetAtMs: entry?.secondary.resetAtMs,
             quotaRateLimited: entry?.status === 429,
-            isCurrentAccount: index === activeIndex,
+            quotaExhausted,
+            isCurrentAccount,
+            isDefaultAccount: index === activeIndex,
+            isRuntimeCurrentAccount: runtimeCurrent?.index === index,
+            currentMarkers,
             enabled: account.enabled !== false,
             showStatusBadge: displaySettings.menuShowStatusBadge ?? true,
             showCurrentBadge: displaySettings.menuShowCurrentBadge ?? true,
@@ -813,6 +764,60 @@ function toExistingAccountInfo(storage, quotaCache, displaySettings) {
             : (account.sourceIndex ?? displayIndex) + 1,
     }));
 }
+async function loadRuntimeCurrentSelectionForStorage(storage, now = Date.now()) {
+    const [runtimeSnapshot, appBindStatus] = await Promise.all([
+        loadPersistedRuntimeObservabilitySnapshot().catch(() => null),
+        getAppBindStatus()
+            .then((status) => (status.running ? status.router : null))
+            .catch(() => null),
+    ]);
+    return resolveRuntimeCurrentAccount(storage, {
+        runtimeSnapshot,
+        appBindStatus,
+        appHelperStatus: readAppRuntimeHelperAccountSignal(),
+    }, { now });
+}
+function activeAccountMatchesCodexCliState(account, state) {
+    if (!state)
+        return true;
+    const accountId = account.accountId?.trim();
+    const activeAccountId = state.activeAccountId?.trim();
+    if (accountId && activeAccountId) {
+        return accountId === activeAccountId;
+    }
+    const email = sanitizeEmail(account.email);
+    const activeEmail = sanitizeEmail(state.activeEmail);
+    if (email && activeEmail) {
+        return email === activeEmail;
+    }
+    return false;
+}
+async function syncCodexCliActiveSelectionIfDrifted(storage) {
+    const activeIndex = resolveActiveIndex(storage, "codex");
+    if (activeIndex < 0 || activeIndex >= storage.accounts.length) {
+        return false;
+    }
+    const account = storage.accounts[activeIndex];
+    if (!account) {
+        return false;
+    }
+    try {
+        const cliState = await loadCodexCliState({ forceRefresh: true });
+        if (!cliState || activeAccountMatchesCodexCliState(account, cliState)) {
+            return false;
+        }
+        return setCodexCliActiveSelection({
+            accountId: account.accountId,
+            email: account.email,
+            accessToken: account.accessToken,
+            refreshToken: account.refreshToken,
+            expiresAt: account.expiresAt,
+        });
+    }
+    catch {
+        return false;
+    }
+}
 function resolveAccountSelection(tokens) {
     const override = (process.env.CODEX_AUTH_ACCOUNT_ID ?? "").trim();
     if (override) {
@@ -1529,7 +1534,7 @@ async function syncSelectionToCodex(tokens) {
 async function runHealthCheck(options = {}) {
     const forceRefresh = options.forceRefresh === true;
     const liveProbe = options.liveProbe === true;
-    const probeModel = options.model?.trim() || "gpt-5-codex";
+    const probeModel = options.model?.trim() || "gpt-5.3-codex";
     const modelInspection = inspectRequestedModel(probeModel);
     const display = options.display ?? DEFAULT_DASHBOARD_DISPLAY_SETTINGS;
     const quotaCache = liveProbe ? await loadQuotaCache() : null;
@@ -1745,7 +1750,7 @@ function printBestUsage() {
         "Options:",
         "  --live, -l         Probe live quota headers via Codex backend before switching",
         "  --json, -j         Print machine-readable JSON output",
-        "  --model, -m        Probe model for live mode (default: gpt-5-codex)",
+        "  --model, -m        Probe model for live mode (default: gpt-5.3-codex)",
         "",
         "Behavior:",
         "  - Chooses the healthiest account using forecast scoring",
@@ -1756,7 +1761,7 @@ function parseBestArgs(args) {
     const options = {
         live: false,
         json: false,
-        model: "gpt-5-codex",
+        model: "gpt-5.3-codex",
         modelProvided: false,
     };
     for (let i = 0; i < args.length; i += 1) {
@@ -2057,7 +2062,9 @@ async function runAuthLogin(args) {
                     }
                 }
                 const flaggedStorage = await loadFlaggedAccounts();
-                const menuResult = await promptLoginMode(toExistingAccountInfo(currentStorage, quotaCache, displaySettings), {
+                await syncCodexCliActiveSelectionIfDrifted(currentStorage);
+                const runtimeCurrent = await loadRuntimeCurrentSelectionForStorage(currentStorage);
+                const menuResult = await promptLoginMode(toExistingAccountInfo(currentStorage, quotaCache, displaySettings, runtimeCurrent), {
                     flaggedCount: flaggedStorage.accounts.length,
                     statusMessage: showFetchStatus
                         ? () => menuQuotaRefreshStatus
@@ -2532,6 +2539,11 @@ export async function runCodexMultiAuthCli(rawArgs) {
             resolveActiveIndex,
             formatRateLimitEntry,
             loadRuntimeObservabilitySnapshot: loadPersistedRuntimeObservabilitySnapshot,
+            loadAppBindStatus: async () => getAppBindStatus()
+                .then((status) => (status.running ? status.router : null))
+                .catch(() => null),
+            loadAppHelperStatus: readAppRuntimeHelperAccountSignal,
+            loadQuotaCache,
         });
     }
     if (command === "switch") {
@@ -2572,6 +2584,22 @@ export async function runCodexMultiAuthCli(rawArgs) {
             loadRuntimeObservabilitySnapshot: loadPersistedRuntimeObservabilitySnapshot,
         });
     }
+    if (command === "rotation") {
+        return runRotationCommand(rest, {
+            loadPluginConfig,
+            savePluginConfig,
+            getCodexRuntimeRotationProxy,
+            setStoragePath,
+            getStoragePath,
+            loadAccounts,
+            resolveActiveIndex,
+            bindCodexApp: bindCodexAppRuntimeRotation,
+            unbindCodexApp: unbindCodexAppRuntimeRotation,
+            getCodexAppBindStatus: getAppBindStatus,
+            loadRuntimeObservabilitySnapshot: loadPersistedRuntimeObservabilitySnapshot,
+            loadQuotaCache,
+        });
+    }
     if (command === "why-selected") {
         return runWhySelectedCommand(rest, {
             parseWhySelectedArgs,