codex-multi-auth 2.3.0-beta.0 → 2.3.0-beta.2

package/dist/lib/codex-manager/formatters/text-style.js

@@ -0,0 +1,111 @@
+import { stdout as output } from "node:process";
+import { ANSI } from "../../ui/ansi.js";
+import { paintUiText } from "../../ui/format.js";
+import { getUiRuntimeOptions } from "../../ui/runtime.js";
+export function stylePromptText(text, tone) {
+    if (!output.isTTY)
+        return text;
+    const ui = getUiRuntimeOptions();
+    if (ui.v2Enabled) {
+        if (tone === "muted") {
+            return `${ui.theme.colors.dim}${paintUiText(ui, text, "muted")}${ui.theme.colors.reset}`;
+        }
+        const mapped = tone === "accent" ? "primary" : tone;
+        return paintUiText(ui, text, mapped);
+    }
+    const legacyCode = tone === "accent"
+        ? ANSI.green
+        : tone === "success"
+            ? ANSI.green
+            : tone === "warning"
+                ? ANSI.yellow
+                : tone === "danger"
+                    ? ANSI.red
+                    : ANSI.dim;
+    return `${legacyCode}${text}${ANSI.reset}`;
+}
+export function collapseWhitespace(value) {
+    return value.replace(/\s+/g, " ").trim();
+}
+export function formatReasonLabel(reason) {
+    if (!reason)
+        return undefined;
+    const normalized = collapseWhitespace(reason.replace(/_/g, " "));
+    return normalized.length > 0 ? normalized : undefined;
+}
+export function extractErrorMessageFromPayload(payload) {
+    if (!payload || typeof payload !== "object")
+        return undefined;
+    const record = payload;
+    const directMessage = typeof record.message === "string"
+        ? collapseWhitespace(record.message)
+        : "";
+    const directCode = typeof record.code === "string" ? collapseWhitespace(record.code) : "";
+    if (directMessage) {
+        if (directCode &&
+            !directMessage.toLowerCase().includes(directCode.toLowerCase())) {
+            return `${directMessage} [${directCode}]`;
+        }
+        return directMessage;
+    }
+    const nested = record.error;
+    if (nested && typeof nested === "object") {
+        return extractErrorMessageFromPayload(nested);
+    }
+    return undefined;
+}
+export function parseStructuredErrorMessage(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    const candidates = new Set([trimmed]);
+    const firstBrace = trimmed.indexOf("{");
+    const lastBrace = trimmed.lastIndexOf("}");
+    if (firstBrace >= 0 && lastBrace > firstBrace) {
+        candidates.add(trimmed.slice(firstBrace, lastBrace + 1));
+    }
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse(candidate);
+            const message = extractErrorMessageFromPayload(parsed);
+            if (message)
+                return message;
+        }
+        catch {
+            // ignore non-JSON candidates
+        }
+    }
+    return undefined;
+}
+export function normalizeFailureDetail(message, reason) {
+    const reasonLabel = formatReasonLabel(reason);
+    const raw = message?.trim() || reasonLabel || "refresh failed";
+    const structured = parseStructuredErrorMessage(raw);
+    const normalized = collapseWhitespace(structured ?? raw);
+    const bounded = normalized.length > 260 ? `${normalized.slice(0, 257)}...` : normalized;
+    return bounded.length > 0 ? bounded : "refresh failed";
+}
+export function joinStyledSegments(parts) {
+    if (parts.length === 0)
+        return "";
+    const separator = stylePromptText(" | ", "muted");
+    return parts.join(separator);
+}
+export function formatResultSummary(segments) {
+    const rendered = segments.map((segment) => stylePromptText(segment.text, segment.tone));
+    return `${stylePromptText("Result:", "accent")} ${joinStyledSegments(rendered)}`;
+}
+export function stringifyLogArgs(args) {
+    return args
+        .map((value) => {
+        if (typeof value === "string")
+            return value;
+        try {
+            return JSON.stringify(value);
+        }
+        catch {
+            return String(value);
+        }
+    })
+        .join(" ");
+}

package/dist/lib/codex-manager/health-check.d.ts

@@ -0,0 +1,14 @@
+import { type DashboardDisplaySettings } from "../dashboard-settings.js";
+/**
+ * Body of the `check` command, also reused by the login dashboard's quick
+ * check / deep check actions. Moved verbatim out of lib/codex-manager.ts
+ * (audit roadmap §4.1.1 phase 3).
+ */
+export interface HealthCheckOptions {
+    forceRefresh?: boolean;
+    liveProbe?: boolean;
+    model?: string;
+    display?: DashboardDisplaySettings;
+}
+export declare function runHealthCheck(options?: HealthCheckOptions): Promise<void>;
+//# sourceMappingURL=health-check.d.ts.map

package/dist/lib/codex-manager/health-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health-check.d.ts","sourceRoot":"","sources":["../../../lib/codex-manager/health-check.ts"],"names":[],"mappings":"AAOA,OAAO,EACN,KAAK,wBAAwB,EAE7B,MAAM,0BAA0B,CAAC;AAiClC;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IAClC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,wBAAwB,CAAC;CACnC;AAED,wBAAsB,cAAc,CACnC,OAAO,GAAE,kBAAuB,GAC9B,OAAO,CAAC,IAAI,CAAC,CA6Tf"}

package/dist/lib/codex-manager/health-check.js

@@ -0,0 +1,278 @@
+import { extractAccountEmail, extractAccountId, formatAccountLabel, sanitizeEmail, } from "../accounts.js";
+import { setCodexCliActiveSelection } from "../codex-cli/writer.js";
+import { DEFAULT_DASHBOARD_DISPLAY_SETTINGS, } from "../dashboard-settings.js";
+import { isCodexUnavailableError } from "../errors.js";
+import { loadQuotaCache, saveQuotaCache } from "../quota-cache.js";
+import { CODEX_UNAVAILABLE_PROBE_NOTE, fetchCodexQuotaSnapshot, } from "../quota-probe.js";
+import { buildQuotaEmailFallbackState } from "../quota-readiness.js";
+import { queuedRefresh } from "../refresh-queue.js";
+import { resolveActiveIndex } from "../runtime/account-status.js";
+import { loadAccounts, saveAccounts, setStoragePath } from "../storage.js";
+import { applyTokenAccountIdentity, hasLikelyInvalidRefreshToken, hasUsableAccessToken, } from "./account-credentials.js";
+import { saveAccountsWithRetry } from "./forecast-report-shared.js";
+import { formatModelInspection, formatQuotaSnapshotForDashboard, formatResultSummary, inspectRequestedModel, normalizeFailureDetail, styleAccountDetailText, stylePromptText, } from "./formatters/index.js";
+import { cloneQuotaCacheData, DEFAULT_LIVE_PROBE_MODEL, pruneUnsafeQuotaEmailCacheEntry, updateQuotaCacheForAccount, } from "./quota-cache-helpers.js";
+export async function runHealthCheck(options = {}) {
+    const forceRefresh = options.forceRefresh === true;
+    const liveProbe = options.liveProbe === true;
+    const probeModel = options.model?.trim() || DEFAULT_LIVE_PROBE_MODEL;
+    const modelInspection = inspectRequestedModel(probeModel);
+    const display = options.display ?? DEFAULT_DASHBOARD_DISPLAY_SETTINGS;
+    const quotaCache = liveProbe ? await loadQuotaCache() : null;
+    const workingQuotaCache = quotaCache ? cloneQuotaCacheData(quotaCache) : null;
+    let quotaCacheChanged = false;
+    setStoragePath(null);
+    const storage = await loadAccounts();
+    if (!storage || storage.accounts.length === 0) {
+        console.log("No accounts configured.");
+        return;
+    }
+    let quotaEmailFallbackState = liveProbe && quotaCache
+        ? buildQuotaEmailFallbackState(storage.accounts)
+        : null;
+    let changed = false;
+    let ok = 0;
+    let failed = 0;
+    let warnings = 0;
+    let codexAvailable = 0;
+    let signedInOnly = 0;
+    const activeIndex = resolveActiveIndex(storage, "codex");
+    let activeAccountRefreshed = false;
+    const now = Date.now();
+    console.log(stylePromptText(forceRefresh
+        ? `Checking ${storage.accounts.length} account(s) with full refresh test...`
+        : `Checking ${storage.accounts.length} account(s) with quick check${liveProbe ? " + live check" : ""}...`, "accent"));
+    if (liveProbe) {
+        console.log(stylePromptText(`Model probe: ${formatModelInspection(modelInspection)}`, "muted"));
+    }
+    for (let i = 0; i < storage.accounts.length; i += 1) {
+        const account = storage.accounts[i];
+        if (!account)
+            continue;
+        const label = formatAccountLabel(account, i);
+        const labelText = stylePromptText(label, "accent");
+        const sessionLikelyValid = hasUsableAccessToken(account, now);
+        if (!forceRefresh && sessionLikelyValid) {
+            if (account.enabled === false) {
+                account.enabled = true;
+                changed = true;
+            }
+            if (i === activeIndex) {
+                activeAccountRefreshed = true;
+            }
+            let healthDetail = "signed in and working";
+            let healthTone = "success";
+            if (liveProbe) {
+                const currentAccessToken = account.accessToken;
+                const probeAccountId = currentAccessToken
+                    ? (account.accountId ?? extractAccountId(currentAccessToken))
+                    : undefined;
+                if (!probeAccountId || !currentAccessToken) {
+                    warnings += 1;
+                    signedInOnly += 1;
+                    healthTone = "warning";
+                    healthDetail =
+                        "signed in (live check skipped: missing account ID)";
+                }
+                else {
+                    try {
+                        const snapshot = await fetchCodexQuotaSnapshot({
+                            accountId: probeAccountId,
+                            accessToken: currentAccessToken,
+                            model: modelInspection.normalized,
+                        });
+                        if (workingQuotaCache) {
+                            quotaCacheChanged =
+                                updateQuotaCacheForAccount(workingQuotaCache, account, snapshot, storage.accounts, quotaEmailFallbackState ?? undefined) || quotaCacheChanged;
+                        }
+                        healthDetail = formatQuotaSnapshotForDashboard(snapshot, display);
+                        codexAvailable += 1;
+                    }
+                    catch (error) {
+                        warnings += 1;
+                        signedInOnly += 1;
+                        healthTone = "warning";
+                        if (isCodexUnavailableError(error)) {
+                            healthDetail =
+                                `signed in; ${CODEX_UNAVAILABLE_PROBE_NOTE}`;
+                        }
+                        else {
+                            const message = normalizeFailureDetail(error instanceof Error ? error.message : String(error), undefined);
+                            healthDetail = `signed in (live check failed: ${message})`;
+                        }
+                    }
+                }
+            }
+            if (hasLikelyInvalidRefreshToken(account.refreshToken)) {
+                healthDetail += " (re-login suggested soon)";
+            }
+            ok += 1;
+            if (display.showPerAccountRows) {
+                const healthMarker = healthTone === "success" ? "✓" : "!";
+                console.log(`  ${stylePromptText(healthMarker, healthTone)} ${labelText} ${stylePromptText("|", "muted")} ${styleAccountDetailText(healthDetail, healthTone)}`);
+            }
+            continue;
+        }
+        const result = await queuedRefresh(account.refreshToken);
+        if (result.type === "success") {
+            const tokenAccountId = extractAccountId(result.access);
+            const nextEmail = sanitizeEmail(extractAccountEmail(result.access, result.idToken));
+            const previousEmail = account.email;
+            let accountIdentityChanged = false;
+            if (account.refreshToken !== result.refresh) {
+                account.refreshToken = result.refresh;
+                changed = true;
+            }
+            if (account.accessToken !== result.access) {
+                account.accessToken = result.access;
+                changed = true;
+            }
+            if (account.expiresAt !== result.expires) {
+                account.expiresAt = result.expires;
+                changed = true;
+            }
+            if (nextEmail && nextEmail !== account.email) {
+                account.email = nextEmail;
+                changed = true;
+                accountIdentityChanged = true;
+            }
+            if (applyTokenAccountIdentity(account, tokenAccountId)) {
+                changed = true;
+                accountIdentityChanged = true;
+            }
+            if (account.enabled === false) {
+                account.enabled = true;
+                changed = true;
+            }
+            if (accountIdentityChanged && liveProbe && workingQuotaCache) {
+                quotaEmailFallbackState = buildQuotaEmailFallbackState(storage.accounts);
+                quotaCacheChanged =
+                    pruneUnsafeQuotaEmailCacheEntry(workingQuotaCache, previousEmail, storage.accounts, quotaEmailFallbackState) || quotaCacheChanged;
+            }
+            account.lastUsed = Date.now();
+            if (i === activeIndex) {
+                activeAccountRefreshed = true;
+            }
+            ok += 1;
+            let healthyMessage = "working now";
+            let healthyTone = "success";
+            if (liveProbe) {
+                const probeAccountId = account.accountId ?? tokenAccountId;
+                if (!probeAccountId) {
+                    warnings += 1;
+                    signedInOnly += 1;
+                    healthyTone = "warning";
+                    healthyMessage =
+                        "signed in (live check skipped: missing account ID)";
+                }
+                else {
+                    try {
+                        const snapshot = await fetchCodexQuotaSnapshot({
+                            accountId: probeAccountId,
+                            accessToken: result.access,
+                            model: modelInspection.normalized,
+                        });
+                        if (workingQuotaCache) {
+                            quotaCacheChanged =
+                                updateQuotaCacheForAccount(workingQuotaCache, account, snapshot, storage.accounts, quotaEmailFallbackState ?? undefined) || quotaCacheChanged;
+                        }
+                        healthyMessage = formatQuotaSnapshotForDashboard(snapshot, display);
+                        codexAvailable += 1;
+                    }
+                    catch (error) {
+                        warnings += 1;
+                        signedInOnly += 1;
+                        healthyTone = "warning";
+                        if (isCodexUnavailableError(error)) {
+                            healthyMessage =
+                                `signed in; ${CODEX_UNAVAILABLE_PROBE_NOTE}`;
+                        }
+                        else {
+                            const message = normalizeFailureDetail(error instanceof Error ? error.message : String(error), undefined);
+                            healthyMessage = `signed in (live check failed: ${message})`;
+                        }
+                    }
+                }
+            }
+            if (display.showPerAccountRows) {
+                const healthyMarker = healthyTone === "success" ? "✓" : "!";
+                console.log(`  ${stylePromptText(healthyMarker, healthyTone)} ${labelText} ${stylePromptText("|", "muted")} ${styleAccountDetailText(healthyMessage, healthyTone)}`);
+            }
+        }
+        else {
+            const detail = normalizeFailureDetail(result.message, result.reason);
+            if (sessionLikelyValid) {
+                warnings += 1;
+                if (liveProbe) {
+                    signedInOnly += 1;
+                }
+                if (display.showPerAccountRows) {
+                    console.log(`  ${stylePromptText("!", "warning")} ${labelText} ${stylePromptText("|", "muted")} ${stylePromptText(`refresh failed (${detail}) but this account still works right now`, "warning")}`);
+                }
+            }
+            else {
+                failed += 1;
+                if (display.showPerAccountRows) {
+                    console.log(`  ${stylePromptText("✗", "danger")} ${labelText} ${stylePromptText("|", "muted")} ${stylePromptText(detail, "danger")}`);
+                }
+            }
+        }
+    }
+    if (!display.showPerAccountRows) {
+        console.log(stylePromptText("Per-account lines are hidden in dashboard settings.", "muted"));
+    }
+    if (workingQuotaCache && quotaCacheChanged) {
+        try {
+            await saveQuotaCache(workingQuotaCache);
+        }
+        catch (error) {
+            // Quota cache is a derived artifact; a transient Windows EBUSY/EPERM
+            // here must not abort the health check before account fixes commit.
+            console.warn(`Quota cache save failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    if (changed) {
+        await saveAccountsWithRetry(storage, saveAccounts);
+    }
+    if (activeAccountRefreshed &&
+        activeIndex >= 0 &&
+        activeIndex < storage.accounts.length) {
+        const activeAccount = storage.accounts[activeIndex];
+        if (activeAccount) {
+            await setCodexCliActiveSelection({
+                accountId: activeAccount.accountId,
+                email: activeAccount.email,
+                accessToken: activeAccount.accessToken,
+                refreshToken: activeAccount.refreshToken,
+                expiresAt: activeAccount.expiresAt,
+            });
+        }
+    }
+    console.log("");
+    console.log(formatResultSummary(liveProbe
+        ? [
+            {
+                text: `${codexAvailable} Codex available`,
+                tone: codexAvailable > 0 ? "success" : "muted",
+            },
+            {
+                text: `${signedInOnly} signed in only`,
+                tone: signedInOnly > 0 ? "warning" : "muted",
+            },
+            {
+                text: `${failed} need re-login`,
+                tone: failed > 0 ? "danger" : "muted",
+            },
+        ]
+        : [
+            { text: `${ok} working`, tone: "success" },
+            {
+                text: `${failed} need re-login`,
+                tone: failed > 0 ? "danger" : "muted",
+            },
+            {
+                text: `${warnings} warning${warnings === 1 ? "" : "s"}`,
+                tone: warnings > 0 ? "warning" : "muted",
+            },
+        ]));
+}

package/dist/lib/codex-manager/help.js

@@ -181,4 +181,3 @@ export function parseBestArgs(args) {
     }
     return { ok: true, options };
 }
-//# sourceMappingURL=help.js.map

package/dist/lib/codex-manager/login-action-panel.d.ts

@@ -0,0 +1,4 @@
+import type { DashboardDisplaySettings } from "../dashboard-settings.js";
+/** @internal */
+export declare function runActionPanel(title: string, stage: string, action: () => Promise<void> | void, settings?: DashboardDisplaySettings): Promise<void>;
+//# sourceMappingURL=login-action-panel.d.ts.map

package/dist/lib/codex-manager/login-action-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login-action-panel.d.ts","sourceRoot":"","sources":["../../../lib/codex-manager/login-action-panel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAuJzE,gBAAgB;AAChB,wBAAsB,cAAc,CACnC,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,EAClC,QAAQ,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,IAAI,CAAC,CAgHf"}

package/dist/lib/codex-manager/login-action-panel.js

@@ -0,0 +1,238 @@
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
+import { ANSI } from "../ui/ansi.js";
+import { UI_COPY } from "../ui/ui-copy.js";
+import { stringifyLogArgs, stylePromptText, } from "./formatters/index.js";
+import { isAbortError } from "./login-oauth.js";
+async function waitForMenuReturn(options = {}) {
+    if (!input.isTTY || !output.isTTY) {
+        return;
+    }
+    const promptText = options.promptText ?? UI_COPY.returnFlow.continuePrompt;
+    const autoReturnMs = options.autoReturnMs ?? 0;
+    const pauseOnAnyKey = options.pauseOnAnyKey ?? true;
+    try {
+        let chunk;
+        do {
+            chunk = input.read();
+        } while (chunk !== null);
+    }
+    catch {
+        // best effort buffer drain
+    }
+    const writeInlineStatus = (message) => {
+        output.write(`\r${ANSI.clearLine}${stylePromptText(message, "muted")}`);
+    };
+    const clearInlineStatus = () => {
+        output.write(`\r${ANSI.clearLine}`);
+    };
+    if (autoReturnMs > 0) {
+        if (!pauseOnAnyKey) {
+            await new Promise((resolve) => setTimeout(resolve, autoReturnMs));
+            return;
+        }
+        const wasRaw = input.isRaw ?? false;
+        const endAt = Date.now() + autoReturnMs;
+        let lastShownSeconds = null;
+        const renderCountdown = () => {
+            const remainingMs = Math.max(0, endAt - Date.now());
+            const remainingSeconds = Math.max(1, Math.ceil(remainingMs / 1000));
+            if (lastShownSeconds === remainingSeconds)
+                return;
+            lastShownSeconds = remainingSeconds;
+            writeInlineStatus(UI_COPY.returnFlow.autoReturn(remainingSeconds));
+        };
+        renderCountdown();
+        const pinned = await new Promise((resolve) => {
+            let done = false;
+            const interval = setInterval(renderCountdown, 80);
+            let timeout = setTimeout(() => {
+                timeout = null;
+                if (!done) {
+                    done = true;
+                    cleanup();
+                    resolve(false);
+                }
+            }, autoReturnMs);
+            const onData = () => {
+                if (done)
+                    return;
+                done = true;
+                cleanup();
+                resolve(true);
+            };
+            const cleanup = () => {
+                clearInterval(interval);
+                if (timeout) {
+                    clearTimeout(timeout);
+                    timeout = null;
+                }
+                input.removeListener("data", onData);
+                try {
+                    input.setRawMode(wasRaw);
+                }
+                catch {
+                    // best effort restore
+                }
+            };
+            try {
+                input.setRawMode(true);
+            }
+            catch {
+                // if raw mode fails, keep countdown behavior
+            }
+            input.on("data", onData);
+            input.resume();
+        });
+        clearInlineStatus();
+        if (!pinned) {
+            return;
+        }
+        const paused = stylePromptText(UI_COPY.returnFlow.paused, "muted");
+        writeInlineStatus(paused);
+        await new Promise((resolve) => {
+            const wasRaw = input.isRaw ?? false;
+            const onData = () => {
+                cleanup();
+                resolve();
+            };
+            const cleanup = () => {
+                input.removeListener("data", onData);
+                try {
+                    input.setRawMode(wasRaw);
+                }
+                catch {
+                    // best effort restore
+                }
+            };
+            try {
+                input.setRawMode(true);
+            }
+            catch {
+                // best effort fallback
+            }
+            input.on("data", onData);
+            input.resume();
+        });
+        clearInlineStatus();
+        return;
+    }
+    const rl = createInterface({ input, output });
+    try {
+        const question = promptText.length > 0 ? `${stylePromptText(promptText, "muted")} ` : "";
+        output.write(`\r${ANSI.clearLine}`);
+        await rl.question(question);
+    }
+    catch (error) {
+        if (!isAbortError(error)) {
+            throw error;
+        }
+    }
+    finally {
+        rl.close();
+        clearInlineStatus();
+    }
+}
+/** @internal */
+export async function runActionPanel(title, stage, action, settings) {
+    if (!input.isTTY || !output.isTTY) {
+        await action();
+        return;
+    }
+    const spinnerFrames = ["-", "\\", "|", "/"];
+    let frame = 0;
+    let running = true;
+    let failed = null;
+    const captured = [];
+    const maxVisibleLines = Math.max(8, (output.rows ?? 24) - 8);
+    const previousLog = console.log;
+    const previousWarn = console.warn;
+    const previousError = console.error;
+    const capture = (prefix, args) => {
+        const line = stringifyLogArgs(args).trim();
+        if (!line)
+            return;
+        captured.push(prefix ? `${prefix}${line}` : line);
+        if (captured.length > 400) {
+            captured.splice(0, captured.length - 400);
+        }
+    };
+    const render = () => {
+        output.write(ANSI.clearScreen + ANSI.moveTo(1, 1));
+        const spinner = running
+            ? `${spinnerFrames[frame % spinnerFrames.length] ?? "-"} `
+            : failed
+                ? "x "
+                : "+ ";
+        const stageText = running
+            ? `${spinner}${stage}`
+            : failed
+                ? UI_COPY.returnFlow.failed
+                : UI_COPY.returnFlow.done;
+        previousLog(stylePromptText(title, "accent"));
+        previousLog(stylePromptText(stageText, failed ? "danger" : running ? "accent" : "success"));
+        previousLog("");
+        const lines = captured.slice(-maxVisibleLines);
+        for (const line of lines) {
+            previousLog(line);
+        }
+        const remainingLines = Math.max(0, maxVisibleLines - lines.length);
+        for (let i = 0; i < remainingLines; i += 1) {
+            previousLog("");
+        }
+        previousLog("");
+        if (running)
+            previousLog(stylePromptText(UI_COPY.returnFlow.working, "muted"));
+        frame += 1;
+    };
+    console.log = (...args) => {
+        capture("", args);
+    };
+    console.warn = (...args) => {
+        capture("! ", args);
+    };
+    console.error = (...args) => {
+        capture("x ", args);
+    };
+    output.write(ANSI.altScreenOn + ANSI.hide);
+    let timer = null;
+    try {
+        render();
+        timer = setInterval(() => {
+            if (!running)
+                return;
+            render();
+        }, 120);
+        await action();
+    }
+    catch (error) {
+        failed = error;
+        capture("x ", [error instanceof Error ? error.message : String(error)]);
+    }
+    finally {
+        running = false;
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+        render();
+        console.log = previousLog;
+        console.warn = previousWarn;
+        console.error = previousError;
+    }
+    if (failed) {
+        await waitForMenuReturn({
+            promptText: UI_COPY.returnFlow.actionFailedPrompt,
+        });
+    }
+    else {
+        await waitForMenuReturn({
+            autoReturnMs: settings?.actionAutoReturnMs ?? 2_000,
+            pauseOnAnyKey: settings?.actionPauseOnKey ?? true,
+        });
+    }
+    output.write(ANSI.altScreenOff + ANSI.show + ANSI.clearScreen + ANSI.moveTo(1, 1));
+    if (failed) {
+        throw failed;
+    }
+}

package/dist/lib/codex-manager/login-flow.d.ts

@@ -0,0 +1,17 @@
+import { type RepairCommandDeps } from "./repair-commands.js";
+/**
+ * Interactive control loop for the `login` command: the account dashboard menu
+ * and the add-account/onboarding flow. Moved verbatim out of
+ * lib/codex-manager.ts (audit roadmap §4.1.1 phase 4); the menu quota-refresh
+ * bookkeeping that previously lived in closure-mutable variables is now an
+ * explicit {@link MenuQuotaRefreshState} created in runAuthLoginFlow and passed
+ * through.
+ */
+/** @internal */
+export interface LoginFlowDeps {
+    runForecast(args: string[]): Promise<number>;
+    createRepairCommandDeps(): RepairCommandDeps;
+}
+/** @internal */
+export declare function runAuthLogin(args: string[], deps: LoginFlowDeps): Promise<number>;
+//# sourceMappingURL=login-flow.d.ts.map

package/dist/lib/codex-manager/login-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login-flow.d.ts","sourceRoot":"","sources":["../../../lib/codex-manager/login-flow.ts"],"names":[],"mappings":"AAmDA,OAAO,EACN,KAAK,iBAAiB,EAGtB,MAAM,sBAAsB,CAAC;AAM9B;;;;;;;GAOG;AAEH,gBAAgB;AAChB,MAAM,WAAW,aAAa;IAC7B,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C,uBAAuB,IAAI,iBAAiB,CAAC;CAC7C;AAkCD,gBAAgB;AAChB,wBAAsB,YAAY,CACjC,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,EAAE,aAAa,GACjB,OAAO,CAAC,MAAM,CAAC,CAqBjB"}