codex-multi-auth 2.3.0-beta.1 → 2.3.0-beta.3

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"}

package/dist/lib/codex-manager/login-flow.js

@@ -0,0 +1,387 @@
+import { isBrowserLaunchSuppressed } from "../auth/browser.js";
+import { promptAddAnotherAccount, promptLoginMode } from "../cli.js";
+import { ACCOUNT_LIMITS } from "../constants.js";
+import { loadDashboardDisplaySettings } from "../dashboard-settings.js";
+import { createLogger } from "../logger.js";
+import { loadQuotaCache } from "../quota-cache.js";
+import { resolveActiveIndex } from "../runtime/account-status.js";
+import { clearAccounts, formatStorageErrorHint, getNamedBackups, loadAccounts, loadFlaggedAccounts, restoreAccountsFromBackup, setStoragePath, StorageError, } from "../storage.js";
+import { UI_COPY } from "../ui/ui-copy.js";
+import { confirm } from "../ui/confirm.js";
+import { stylePromptText } from "./formatters/index.js";
+import { runHealthCheck } from "./health-check.js";
+import { parseAuthLoginArgs, printUsage, } from "./help.js";
+import { runActionPanel } from "./login-action-panel.js";
+import { handleManageAction, promptBackupRestoreMode, promptManualBackupSelection, promptOAuthSignInMode, } from "./login-menu-actions.js";
+import { countMenuQuotaRefreshTargets, DEFAULT_MENU_QUOTA_REFRESH_TTL_MS, loadRuntimeCurrentSelectionForStorage, refreshQuotaCacheForMenu, syncCodexCliActiveSelectionIfDrifted, toExistingAccountInfo, } from "./login-menu-data.js";
+import { isOAuthCancellation, persistAccountPool, resolveAccountSelection, runSignInFlow, syncSelectionToCodex, } from "./login-oauth.js";
+import { persistAndSyncSelectedAccount } from "./persist-selected-account.js";
+import { runFix as runRepairFix, runVerifyFlagged as runRepairVerifyFlagged, } from "./repair-commands.js";
+import { applyUiThemeFromDashboardSettings, configureUnifiedSettings, } from "./settings-hub.js";
+function clearMenuQuotaAutoRefreshSkip(state) {
+    state.skipNextMenuQuotaAutoRefresh = false;
+    state.menuQuotaRefreshGeneration += 1;
+}
+// The menu quota refresh runs fire-and-forget behind the dashboard. On the
+// paths that leave the loop (add-account's storage write, process exit) an
+// in-flight refresh must finish first so its cache save cannot race the
+// account-pool write (Windows EBUSY/EPERM on sibling files) or be orphaned
+// mid-write. The chain never rejects (it ends in .catch/.finally), and the
+// wait is bounded by the per-probe HTTP timeouts.
+async function drainPendingMenuQuotaRefresh(state) {
+    if (state.pendingMenuQuotaRefresh) {
+        await state.pendingMenuQuotaRefresh;
+    }
+}
+const log = createLogger("codex-manager");
+async function clearAccountsAndReset() {
+    await clearAccounts();
+}
+/** @internal */
+export async function runAuthLogin(args, deps) {
+    const parsedArgs = parseAuthLoginArgs(args);
+    if (!parsedArgs.ok) {
+        if (parsedArgs.reason === "error") {
+            console.error(parsedArgs.message);
+            printUsage();
+            return 1;
+        }
+        return 0;
+    }
+    const loginOptions = parsedArgs.options;
+    // `--org <id>` binds this login to a specific workspace/org so the same
+    // email's personal vs business/team workspace can be registered on demand
+    // (issue #491). The org is threaded explicitly into resolveAccountSelection
+    // (no process.env mutation), so concurrent re-entry (menu re-entry, a reused
+    // test worker) can never bind a login to a stale org via a shared global.
+    if (loginOptions.org) {
+        console.log(`Binding this login to workspace org id: ${loginOptions.org}`);
+    }
+    return runAuthLoginFlow(loginOptions, deps);
+}
+async function runLoginDashboardLoop(menuState, deps) {
+    while (true) {
+        const existingStorage = await loadAccounts();
+        if (!existingStorage || existingStorage.accounts.length === 0) {
+            await drainPendingMenuQuotaRefresh(menuState);
+            return "add-account";
+        }
+        const currentStorage = existingStorage;
+        const displaySettings = await loadDashboardDisplaySettings();
+        applyUiThemeFromDashboardSettings(displaySettings);
+        const quotaCache = await loadQuotaCache();
+        const shouldAutoFetchLimits = displaySettings.menuAutoFetchLimits ?? true;
+        const showFetchStatus = displaySettings.menuShowFetchStatus ?? true;
+        const quotaTtlMs = displaySettings.menuQuotaTtlMs ?? DEFAULT_MENU_QUOTA_REFRESH_TTL_MS;
+        const shouldSkipAutoFetchThisPass = !menuState.pendingMenuQuotaRefresh &&
+            menuState.skipNextMenuQuotaAutoRefresh;
+        if (shouldSkipAutoFetchThisPass) {
+            menuState.skipNextMenuQuotaAutoRefresh = false;
+        }
+        if (shouldAutoFetchLimits &&
+            !menuState.pendingMenuQuotaRefresh &&
+            !shouldSkipAutoFetchThisPass) {
+            const staleCount = countMenuQuotaRefreshTargets(currentStorage, quotaCache, quotaTtlMs);
+            if (staleCount > 0) {
+                if (showFetchStatus) {
+                    menuState.menuQuotaRefreshStatus = `${UI_COPY.mainMenu.loadingLimits} [0/${staleCount}]`;
+                }
+                const refreshGeneration = menuState.menuQuotaRefreshGeneration;
+                menuState.pendingMenuQuotaRefresh = refreshQuotaCacheForMenu(currentStorage, quotaCache, quotaTtlMs, (current, total) => {
+                    if (!showFetchStatus)
+                        return;
+                    menuState.menuQuotaRefreshStatus = `${UI_COPY.mainMenu.loadingLimits} [${current}/${total}]`;
+                })
+                    .then(() => {
+                    if (refreshGeneration === menuState.menuQuotaRefreshGeneration) {
+                        menuState.skipNextMenuQuotaAutoRefresh = true;
+                    }
+                    return undefined;
+                })
+                    .catch(() => undefined)
+                    .finally(() => {
+                    menuState.menuQuotaRefreshStatus = undefined;
+                    menuState.pendingMenuQuotaRefresh = null;
+                });
+            }
+        }
+        const flaggedStorage = await loadFlaggedAccounts();
+        await syncCodexCliActiveSelectionIfDrifted(currentStorage);
+        const runtimeCurrent = await loadRuntimeCurrentSelectionForStorage(currentStorage);
+        const menuResult = await promptLoginMode(toExistingAccountInfo(currentStorage, quotaCache, displaySettings, runtimeCurrent), {
+            flaggedCount: flaggedStorage.accounts.length,
+            statusMessage: showFetchStatus
+                ? () => menuState.menuQuotaRefreshStatus
+                : undefined,
+        });
+        if (menuResult.mode === "cancel") {
+            console.log("Cancelled.");
+            await drainPendingMenuQuotaRefresh(menuState);
+            return "exit";
+        }
+        if (menuResult.mode === "check") {
+            clearMenuQuotaAutoRefreshSkip(menuState);
+            await runActionPanel("Quick Check", "Checking local session + live status", async () => {
+                await runHealthCheck({ forceRefresh: false, liveProbe: true });
+            }, displaySettings);
+            continue;
+        }
+        if (menuResult.mode === "deep-check") {
+            clearMenuQuotaAutoRefreshSkip(menuState);
+            await runActionPanel("Deep Check", "Refreshing and testing all accounts", async () => {
+                await runHealthCheck({ forceRefresh: true, liveProbe: true });
+            }, displaySettings);
+            continue;
+        }
+        if (menuResult.mode === "forecast") {
+            clearMenuQuotaAutoRefreshSkip(menuState);
+            await runActionPanel("Best Account", "Comparing accounts", async () => {
+                await deps.runForecast(["--live"]);
+            }, displaySettings);
+            continue;
+        }
+        if (menuResult.mode === "fix") {
+            clearMenuQuotaAutoRefreshSkip(menuState);
+            await runActionPanel("Auto-Fix", "Checking and fixing common issues", async () => {
+                await runRepairFix(["--live"], deps.createRepairCommandDeps());
+            }, displaySettings);
+            continue;
+        }
+        if (menuResult.mode === "settings") {
+            clearMenuQuotaAutoRefreshSkip(menuState);
+            await configureUnifiedSettings(displaySettings);
+            continue;
+        }
+        if (menuResult.mode === "verify-flagged") {
+            clearMenuQuotaAutoRefreshSkip(menuState);
+            await runActionPanel("Problem Account Check", "Checking problem accounts", async () => {
+                await runRepairVerifyFlagged([], deps.createRepairCommandDeps());
+            }, displaySettings);
+            continue;
+        }
+        if (menuResult.mode === "fresh" && menuResult.deleteAll) {
+            clearMenuQuotaAutoRefreshSkip(menuState);
+            await runActionPanel("Reset Accounts", "Deleting all saved accounts", async () => {
+                await clearAccountsAndReset();
+                console.log("Cleared saved accounts from active storage. Recovery snapshots remain available.");
+            }, displaySettings);
+            continue;
+        }
+        if (menuResult.mode === "manage") {
+            clearMenuQuotaAutoRefreshSkip(menuState);
+            const requiresInteractiveOAuth = typeof menuResult.refreshAccountIndex === "number";
+            if (requiresInteractiveOAuth) {
+                await handleManageAction(currentStorage, menuResult);
+                continue;
+            }
+            await runActionPanel("Applying Change", "Updating selected account", async () => {
+                await handleManageAction(currentStorage, menuResult);
+            }, displaySettings);
+            continue;
+        }
+        if (menuResult.mode === "add") {
+            await drainPendingMenuQuotaRefresh(menuState);
+            return "add-account";
+        }
+    }
+}
+async function runAuthLoginFlow(loginOptions, deps) {
+    setStoragePath(null);
+    const menuState = {
+        pendingMenuQuotaRefresh: null,
+        menuQuotaRefreshStatus: undefined,
+        skipNextMenuQuotaAutoRefresh: false,
+        menuQuotaRefreshGeneration: 0,
+    };
+    // When the user explicitly picks a sign-in transport on the command line
+    // (--device-auth, --manual, --no-browser), they want to add a new account
+    // directly. Skipping the dashboard menu keeps `login --device-auth`
+    // usable from scripts and matches the documented behavior of the help text.
+    const explicitSignInMode = loginOptions.deviceAuth || loginOptions.manual;
+    loginFlow: while (true) {
+        const existingStorage = await loadAccounts();
+        if (!explicitSignInMode &&
+            existingStorage &&
+            existingStorage.accounts.length > 0) {
+            const dashboardOutcome = await runLoginDashboardLoop(menuState, deps);
+            if (dashboardOutcome === "exit") {
+                return 0;
+            }
+        }
+        const refreshedStorage = await loadAccounts();
+        let existingCount = refreshedStorage?.accounts.length ?? 0;
+        let forceNewLogin = existingCount > 0;
+        let onboardingBackupDiscoveryWarning = null;
+        const loadNamedBackupsForOnboarding = async () => {
+            if (existingCount > 0) {
+                onboardingBackupDiscoveryWarning = null;
+                return [];
+            }
+            try {
+                onboardingBackupDiscoveryWarning = null;
+                return await getNamedBackups();
+            }
+            catch (error) {
+                const code = error.code;
+                log.debug("getNamedBackups failed, skipping restore option", {
+                    code,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                if (code && code !== "ENOENT") {
+                    onboardingBackupDiscoveryWarning =
+                        "Named backup discovery failed. Continuing with browser or manual sign-in only.";
+                    console.warn(onboardingBackupDiscoveryWarning);
+                }
+                else {
+                    onboardingBackupDiscoveryWarning = null;
+                }
+                return [];
+            }
+        };
+        let namedBackups = await loadNamedBackupsForOnboarding();
+        while (true) {
+            const latestNamedBackup = namedBackups[0] ?? null;
+            const preferManualMode = loginOptions.manual || isBrowserLaunchSuppressed();
+            const signInMode = loginOptions.deviceAuth
+                ? "device"
+                : preferManualMode
+                    ? "manual"
+                    : await promptOAuthSignInMode(latestNamedBackup, onboardingBackupDiscoveryWarning);
+            if (signInMode === "cancel") {
+                if (existingCount > 0) {
+                    console.log(stylePromptText(UI_COPY.oauth.cancelledBackToMenu, "muted"));
+                    continue loginFlow;
+                }
+                console.log("Cancelled.");
+                return 0;
+            }
+            if (signInMode === "restore-backup") {
+                const latestAvailableBackup = namedBackups[0] ?? null;
+                if (!latestAvailableBackup) {
+                    namedBackups = await loadNamedBackupsForOnboarding();
+                    continue;
+                }
+                const restoreMode = await promptBackupRestoreMode(latestAvailableBackup);
+                if (restoreMode === "back") {
+                    namedBackups = await loadNamedBackupsForOnboarding();
+                    continue;
+                }
+                const selectedBackup = restoreMode === "manual"
+                    ? await promptManualBackupSelection(namedBackups)
+                    : latestAvailableBackup;
+                if (!selectedBackup) {
+                    namedBackups = await loadNamedBackupsForOnboarding();
+                    continue;
+                }
+                const confirmed = await confirm(UI_COPY.oauth.restoreBackupConfirm(selectedBackup.fileName, selectedBackup.accountCount));
+                if (!confirmed) {
+                    namedBackups = await loadNamedBackupsForOnboarding();
+                    continue;
+                }
+                const displaySettings = await loadDashboardDisplaySettings();
+                applyUiThemeFromDashboardSettings(displaySettings);
+                try {
+                    await runActionPanel("Load Backup", `Loading ${selectedBackup.fileName}`, async () => {
+                        const restoredStorage = await restoreAccountsFromBackup(selectedBackup.path, { persist: false });
+                        const targetIndex = resolveActiveIndex(restoredStorage);
+                        const { synced } = await persistAndSyncSelectedAccount({
+                            storage: restoredStorage,
+                            targetIndex,
+                            parsed: targetIndex + 1,
+                            switchReason: "restore",
+                            preserveActiveIndexByFamily: true,
+                        });
+                        console.log(UI_COPY.oauth.restoreBackupLoaded(selectedBackup.fileName, restoredStorage.accounts.length));
+                        if (!synced) {
+                            console.warn(UI_COPY.oauth.restoreBackupSyncWarning);
+                        }
+                    }, displaySettings);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    if (error instanceof StorageError) {
+                        console.error(formatStorageErrorHint(error, selectedBackup.path));
+                    }
+                    else {
+                        console.error(`Backup restore failed: ${message}`);
+                    }
+                    const storageAfterRestoreAttempt = await loadAccounts().catch(() => null);
+                    if ((storageAfterRestoreAttempt?.accounts.length ?? 0) > 0) {
+                        continue loginFlow;
+                    }
+                    namedBackups = await loadNamedBackupsForOnboarding();
+                    continue;
+                }
+                continue loginFlow;
+            }
+            if (signInMode !== "browser" &&
+                signInMode !== "manual" &&
+                signInMode !== "device") {
+                continue;
+            }
+            const tokenResult = await runSignInFlow(forceNewLogin, signInMode);
+            if (tokenResult.type !== "success") {
+                if (isOAuthCancellation(tokenResult)) {
+                    // In explicit-mode invocations the dashboard was bypassed,
+                    // so falling back to it on cancel would re-enter the same
+                    // transport flow and trap the user. Exit cleanly instead.
+                    if (explicitSignInMode) {
+                        console.log("Cancelled.");
+                        return 0;
+                    }
+                    if (existingCount > 0) {
+                        console.log(stylePromptText(UI_COPY.oauth.cancelledBackToMenu, "muted"));
+                        continue loginFlow;
+                    }
+                    console.log("Cancelled.");
+                    return 0;
+                }
+                console.error(`Login failed: ${tokenResult.message ?? tokenResult.reason ?? "unknown error"}`);
+                return 1;
+            }
+            const resolved = resolveAccountSelection(tokenResult, loginOptions.org);
+            const persistOutcome = await persistAccountPool([resolved], false);
+            await syncSelectionToCodex(resolved);
+            const latestStorage = await loadAccounts();
+            const count = latestStorage?.accounts.length ?? 1;
+            existingCount = count;
+            namedBackups = [];
+            onboardingBackupDiscoveryWarning = null;
+            // Only claim a new saved slot when one was actually appended. A
+            // same-email login that maps onto an existing entry updates or
+            // rebinds it instead of growing the pool (issue #512).
+            const outcomeMessage = persistOutcome === "rebound"
+                ? `Rebound workspace for existing account. Total: ${count}`
+                : persistOutcome === "updated"
+                    ? `Updated existing account. Total: ${count}`
+                    : `Added account. Total: ${count}`;
+            console.log(outcomeMessage);
+            console.log("Next steps:");
+            console.log("  codex-multi-auth status  Check that the wrapper is active.");
+            console.log("  codex-multi-auth check   Confirm your saved accounts look healthy.");
+            console.log("  codex-multi-auth list    Review saved accounts before switching.");
+            if (count >= ACCOUNT_LIMITS.MAX_ACCOUNTS) {
+                console.log(`Reached maximum account limit (${ACCOUNT_LIMITS.MAX_ACCOUNTS}).`);
+                // Same reasoning as the addAnother=false branch below: in
+                // explicit mode the dashboard is bypassed, so falling out of
+                // the inner loop would re-enter loginFlow and silently start
+                // another sign-in session despite the cap.
+                if (explicitSignInMode) {
+                    return 0;
+                }
+                break;
+            }
+            const addAnother = await promptAddAnotherAccount(count);
+            if (!addAnother) {
+                // With an explicit transport flag the dashboard was bypassed,
+                // so falling back to it after declining would loop into a fresh
+                // sign-in instead of exiting. Return directly in that case.
+                if (explicitSignInMode) {
+                    return 0;
+                }
+                break;
+            }
+            forceNewLogin = true;
+        }
+    }
+}

package/dist/lib/codex-manager/login-menu-actions.d.ts

@@ -0,0 +1,20 @@
+import type { promptLoginMode } from "../cli.js";
+import { type AccountStorageV3, type NamedBackupSummary } from "../storage.js";
+import { type OAuthSignInMode } from "./login-oauth.js";
+/**
+ * Per-menu-item action handlers for the login dashboard: sign-in mode and
+ * backup-restore prompts plus the manage actions (switch/delete/toggle/refresh
+ * an account row). Moved verbatim out of lib/codex-manager.ts (audit roadmap
+ * §4.1.1 phase 4).
+ */
+/** @internal */
+export type BackupRestoreMode = "latest" | "manual" | "back";
+/** @internal */
+export declare function promptOAuthSignInMode(backupOption: NamedBackupSummary | null, backupDiscoveryWarning?: string | null): Promise<OAuthSignInMode>;
+/** @internal */
+export declare function promptBackupRestoreMode(latestBackup: NamedBackupSummary): Promise<BackupRestoreMode>;
+/** @internal */
+export declare function promptManualBackupSelection(backups: NamedBackupSummary[]): Promise<NamedBackupSummary | null>;
+/** @internal */
+export declare function handleManageAction(storage: AccountStorageV3, menuResult: Awaited<ReturnType<typeof promptLoginMode>>): Promise<void>;
+//# sourceMappingURL=login-menu-actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"login-menu-actions.d.ts","sourceRoot":"","sources":["../../../lib/codex-manager/login-menu-actions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,EAEN,KAAK,gBAAgB,EAGrB,KAAK,kBAAkB,EAGvB,MAAM,eAAe,CAAC;AASvB,OAAO,EACN,KAAK,eAAe,EAKpB,MAAM,kBAAkB,CAAC;AAG1B;;;;;GAKG;AAEH,gBAAgB;AAChB,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAC;AAE7D,gBAAgB;AAChB,wBAAsB,qBAAqB,CAC1C,YAAY,EAAE,kBAAkB,GAAG,IAAI,EACvC,sBAAsB,GAAE,MAAM,GAAG,IAAW,GAC1C,OAAO,CAAC,eAAe,CAAC,CA6D1B;AAED,gBAAgB;AAChB,wBAAsB,uBAAuB,CAC5C,YAAY,EAAE,kBAAkB,GAC9B,OAAO,CAAC,iBAAiB,CAAC,CA0C5B;AAED,gBAAgB;AAChB,wBAAsB,2BAA2B,CAChD,OAAO,EAAE,kBAAkB,EAAE,GAC3B,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAkCpC;AA2GD,gBAAgB;AAChB,wBAAsB,kBAAkB,CACvC,OAAO,EAAE,gBAAgB,EACzB,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,GACrD,OAAO,CAAC,IAAI,CAAC,CA8Gf"}