opencode-copilot-account-switcher 0.13.2 → 0.13.4

package/dist/codex-invalid-account.d.ts

@@ -0,0 +1,32 @@
+import type { CodexAccountEntry, CodexStoreFile } from "./codex-store.js";
+export type CodexRecoveryCandidate = {
+    name: string;
+    entry: CodexAccountEntry;
+};
+export type CodexSetAuthInput = {
+    path: {
+        id: string;
+    };
+    body: {
+        type: "oauth";
+        refresh?: string;
+        access?: string;
+        expires?: number;
+        accountId?: string;
+    };
+};
+export type RecoverInvalidCodexAccountResult = {
+    removed: string;
+    replacement?: string;
+    switched: boolean;
+    weekRecoveryOnly: boolean;
+    noCandidates: boolean;
+    store: CodexStoreFile;
+};
+export declare function getCodexDisplayName(entry: CodexAccountEntry | undefined, fallbackName: string): string;
+export declare function sortCodexRecoveryCandidates(candidates: CodexRecoveryCandidate[]): CodexRecoveryCandidate[];
+export declare function recoverInvalidCodexAccount(input: {
+    store: CodexStoreFile;
+    invalidAccountName: string;
+    setAuth?: (next: CodexSetAuthInput) => Promise<unknown>;
+}): Promise<RecoverInvalidCodexAccountResult>;

package/dist/codex-invalid-account.js

@@ -0,0 +1,106 @@
+function pickPositiveNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return 0;
+    return value > 0 ? value : 0;
+}
+function pickFiniteNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return undefined;
+    return value;
+}
+function getWeekRemaining(entry) {
+    return pickPositiveNumber(entry.snapshot?.usageWeek?.remaining);
+}
+function get5hRemaining(entry) {
+    return pickPositiveNumber(entry.snapshot?.usage5h?.remaining);
+}
+function compareResetAt(a, b) {
+    const aMissing = a === undefined;
+    const bMissing = b === undefined;
+    if (aMissing && bMissing)
+        return 0;
+    if (aMissing)
+        return 1;
+    if (bMissing)
+        return -1;
+    if (a === b)
+        return 0;
+    return a < b ? -1 : 1;
+}
+export function getCodexDisplayName(entry, fallbackName) {
+    return entry?.workspaceName
+        ?? entry?.name
+        ?? entry?.email
+        ?? entry?.accountId
+        ?? fallbackName;
+}
+export function sortCodexRecoveryCandidates(candidates) {
+    const withIndex = candidates.map((candidate, index) => ({ candidate, index }));
+    const weekPositive = withIndex.filter(({ candidate }) => getWeekRemaining(candidate.entry) > 0);
+    const pool = weekPositive.length > 0 ? weekPositive : withIndex;
+    const has5hPositiveInPool = pool.some(({ candidate }) => get5hRemaining(candidate.entry) > 0);
+    return pool
+        .slice()
+        .sort((a, b) => {
+        if (weekPositive.length > 0 && has5hPositiveInPool) {
+            const a5h = get5hRemaining(a.candidate.entry);
+            const b5h = get5hRemaining(b.candidate.entry);
+            if (a5h > 0 && b5h <= 0)
+                return -1;
+            if (a5h <= 0 && b5h > 0)
+                return 1;
+            const by5hResetAt = compareResetAt(pickFiniteNumber(a.candidate.entry.snapshot?.usage5h?.resetAt), pickFiniteNumber(b.candidate.entry.snapshot?.usage5h?.resetAt));
+            if (by5hResetAt !== 0)
+                return by5hResetAt;
+        }
+        const byWeekResetAt = compareResetAt(pickFiniteNumber(a.candidate.entry.snapshot?.usageWeek?.resetAt), pickFiniteNumber(b.candidate.entry.snapshot?.usageWeek?.resetAt));
+        if (byWeekResetAt !== 0)
+            return byWeekResetAt;
+        return a.index - b.index;
+    })
+        .map(({ candidate }) => candidate);
+}
+export async function recoverInvalidCodexAccount(input) {
+    const store = {
+        ...input.store,
+        accounts: { ...input.store.accounts },
+    };
+    delete store.accounts[input.invalidAccountName];
+    const candidates = Object.entries(store.accounts).map(([name, entry]) => ({
+        name,
+        entry,
+    }));
+    const sorted = sortCodexRecoveryCandidates(candidates);
+    const replacement = sorted[0];
+    const noCandidates = !replacement;
+    const switched = Boolean(replacement);
+    const weekRecoveryOnly = Boolean(replacement
+        && getWeekRemaining(replacement.entry) > 0
+        && get5hRemaining(replacement.entry) <= 0);
+    if (replacement) {
+        store.active = replacement.name;
+    }
+    else if (store.active === input.invalidAccountName) {
+        delete store.active;
+    }
+    if (replacement && input.setAuth) {
+        await input.setAuth({
+            path: { id: "openai" },
+            body: {
+                type: "oauth",
+                refresh: replacement.entry.refresh,
+                access: replacement.entry.access,
+                expires: replacement.entry.expires,
+                accountId: replacement.entry.accountId,
+            },
+        });
+    }
+    return {
+        removed: input.invalidAccountName,
+        replacement: replacement?.name,
+        switched,
+        weekRecoveryOnly,
+        noCandidates,
+        store,
+    };
+}

package/dist/codex-oauth.d.ts

@@ -7,11 +7,33 @@ export type TokenResponse = {
 export type IdTokenClaims = {
     chatgpt_account_id?: string;
     organizations?: Array<{
-        id: string;
+        id?: string;
+        name?: string;
+        display_name?: string;
+        workspace_name?: string;
+        slug?: string;
     }>;
+    organization?: {
+        id?: string;
+        name?: string;
+        display_name?: string;
+        workspace_name?: string;
+        slug?: string;
+    };
+    workspace?: {
+        id?: string;
+        name?: string;
+        display_name?: string;
+        workspace_name?: string;
+        slug?: string;
+    };
+    workspace_name?: string;
     email?: string;
     "https://api.openai.com/auth"?: {
         chatgpt_account_id?: string;
+        workspace_name?: string;
+        workspace_id?: string;
+        organization_id?: string;
     };
 };
 export type CodexOAuthAccount = {
@@ -20,6 +42,7 @@ export type CodexOAuthAccount = {
     expires?: number;
     accountId?: string;
     email?: string;
+    workspaceName?: string;
 };
 type OAuthMode = "browser" | "headless";
 type RunCodexOAuthInput = {
@@ -35,5 +58,7 @@ type RunCodexOAuthInput = {
 export declare function parseJwtClaims(token: string): IdTokenClaims | undefined;
 export declare function extractAccountIdFromClaims(claims: IdTokenClaims): string | undefined;
 export declare function extractAccountId(tokens: TokenResponse): string | undefined;
+export declare function extractWorkspaceNameFromClaims(claims: IdTokenClaims): string | undefined;
+export declare function extractWorkspaceName(tokens: TokenResponse): string | undefined;
 export declare function runCodexOAuth(input?: RunCodexOAuthInput): Promise<CodexOAuthAccount | undefined>;
 export {};

package/dist/codex-oauth.js

@@ -82,6 +82,32 @@ export function extractAccountId(tokens) {
     const claims = parseJwtClaims(tokens.access_token);
     return claims ? extractAccountIdFromClaims(claims) : undefined;
 }
+function pickWorkspaceLikeLabel(input) {
+    if (!input)
+        return undefined;
+    return input.workspace_name ?? input.display_name ?? input.name ?? input.slug ?? input.id;
+}
+export function extractWorkspaceNameFromClaims(claims) {
+    return (claims.workspace_name
+        || claims["https://api.openai.com/auth"]?.workspace_name
+        || claims["https://api.openai.com/auth"]?.workspace_id
+        || claims["https://api.openai.com/auth"]?.organization_id
+        || pickWorkspaceLikeLabel(claims.workspace)
+        || pickWorkspaceLikeLabel(claims.organization)
+        || pickWorkspaceLikeLabel(claims.organizations?.[0]));
+}
+export function extractWorkspaceName(tokens) {
+    if (tokens.id_token) {
+        const claims = parseJwtClaims(tokens.id_token);
+        const workspaceName = claims && extractWorkspaceNameFromClaims(claims);
+        if (workspaceName)
+            return workspaceName;
+    }
+    if (!tokens.access_token)
+        return undefined;
+    const claims = parseJwtClaims(tokens.access_token);
+    return claims ? extractWorkspaceNameFromClaims(claims) : undefined;
+}
 function extractEmail(tokens) {
     if (tokens.id_token) {
         const claims = parseJwtClaims(tokens.id_token);
@@ -291,12 +317,14 @@ function normalizeTokens(tokens, now) {
     const access = tokens.access_token;
     if (!refresh && !access)
         return undefined;
+    const workspaceName = extractWorkspaceName(tokens);
     return {
         refresh,
         access,
         expires: now() + (tokens.expires_in ?? 3600) * 1000,
         accountId: extractAccountId(tokens),
         email: extractEmail(tokens),
+        ...(workspaceName ? { workspaceName } : {}),
     };
 }
 export async function runCodexOAuth(input = {}) {

package/dist/codex-status-command.js

@@ -1,6 +1,7 @@
 import { resolveCodexAuthSource } from "./codex-auth-source.js";
 import { fetchCodexStatus } from "./codex-status-fetcher.js";
 import { getActiveCodexAccount, normalizeCodexStore, readCodexStore, writeCodexStore, } from "./codex-store.js";
+import { getCodexDisplayName, recoverInvalidCodexAccount } from "./codex-invalid-account.js";
 import { readAuth } from "./store.js";
 export class CodexStatusCommandHandledError extends Error {
     constructor() {
@@ -44,6 +45,12 @@ function ratio(remaining, entitlement) {
 function value(value) {
     return value === undefined ? "n/a" : String(value);
 }
+function pickWorkspaceLabel(input) {
+    return input.workspaceName
+        ?? input.name
+        ?? input.email
+        ?? input.accountId;
+}
 function renderWindow(label, window) {
     if (window.entitlement === 100 && window.remaining !== undefined) {
         return `${label}: ${window.remaining}% left`;
@@ -51,16 +58,16 @@ function renderWindow(label, window) {
     return `${label}: ${ratio(window.remaining, window.entitlement)}`;
 }
 function renderStatus(status) {
+    const identity = status.identity;
     return [
-        "Codex status updated.",
-        "[identity]",
-        `account: ${value(status.identity.accountId)}`,
-        `email: ${value(status.identity.email)}`,
-        `plan: ${value(status.identity.plan)}`,
-        "[usage]",
+        `账号: ${value(identity.accountId ?? identity.email)}`,
+        `Workspace: ${value(pickWorkspaceLabel({
+            workspaceName: identity.workspaceName,
+            email: identity.email,
+            accountId: identity.accountId,
+        }))}`,
         renderWindow("5h", status.windows.primary),
         renderWindow("week", status.windows.secondary),
-        `credits: ${ratio(status.credits.remaining, status.credits.total)}`,
     ].join("\n");
 }
 function renderCachedStatus(store) {
@@ -68,14 +75,15 @@ function renderCachedStatus(store) {
     const entry = active?.entry;
     const snapshot = entry?.snapshot;
     return [
-        "[identity]",
-        `account: ${value(entry?.accountId ?? active?.name)}`,
-        `email: ${value(entry?.email)}`,
-        `plan: ${value(snapshot?.plan)}`,
-        "[usage]",
+        `账号: ${value(entry?.accountId ?? active?.name ?? entry?.email)}`,
+        `Workspace: ${value(pickWorkspaceLabel({
+            workspaceName: entry?.workspaceName,
+            name: entry?.name ?? active?.name,
+            email: entry?.email,
+            accountId: entry?.accountId,
+        }))}`,
         renderWindow("5h", snapshot?.usage5h ?? {}),
-        "week: n/a",
-        "credits: n/a",
+        renderWindow("week", snapshot?.usageWeek ?? {}),
     ].join("\n");
 }
 function getCachedAccountForSource(store, input) {
@@ -96,14 +104,15 @@ function renderCachedStatusForAccount(store, input) {
     const entry = active?.entry;
     const snapshot = entry?.snapshot;
     return [
-        "[identity]",
-        `account: ${value(entry?.accountId ?? active?.name)}`,
-        `email: ${value(entry?.email)}`,
-        `plan: ${value(snapshot?.plan)}`,
-        "[usage]",
+        `账号: ${value(entry?.accountId ?? active?.name ?? entry?.email)}`,
+        `Workspace: ${value(pickWorkspaceLabel({
+            workspaceName: entry?.workspaceName,
+            name: entry?.name ?? active?.name,
+            email: entry?.email,
+            accountId: entry?.accountId,
+        }))}`,
         renderWindow("5h", snapshot?.usage5h ?? {}),
-        "week: n/a",
-        "credits: n/a",
+        renderWindow("week", snapshot?.usageWeek ?? {}),
     ].join("\n");
 }
 function hasCachedStore(store) {
@@ -230,12 +239,55 @@ export async function handleCodexStatusCommand(input) {
         },
     }));
     if (!fetched.ok) {
+        if (fetched.error.kind === "invalid_account") {
+            const currentRaw = await readStore().catch(() => ({}));
+            const currentStore = normalizeCodexStore(currentRaw);
+            const invalid = getCachedAccountForSource(currentStore, { accountId: source.accountId });
+            const invalidName = invalid?.name ?? currentStore.active;
+            if (invalidName && currentStore.accounts[invalidName]) {
+                const recovered = await recoverInvalidCodexAccount({
+                    store: currentStore,
+                    invalidAccountName: invalidName,
+                    setAuth: input.client?.auth?.set
+                        ? async (next) => {
+                            const authClient = input.client?.auth;
+                            const setAuth = input.client?.auth?.set;
+                            if (!setAuth)
+                                return;
+                            await setAuth.call(authClient, next);
+                        }
+                        : undefined,
+                });
+                await writeStore(recovered.store);
+                const removedDisplay = getCodexDisplayName(invalid?.entry, recovered.removed);
+                const messageLines = [`无效账号${removedDisplay}已移除，请及时检查核对`];
+                if (recovered.replacement) {
+                    const replacementEntry = recovered.store.accounts[recovered.replacement];
+                    const replacementDisplay = getCodexDisplayName(replacementEntry, recovered.replacement);
+                    messageLines.push(`已切换到${replacementDisplay}`);
+                    if (recovered.weekRecoveryOnly) {
+                        messageLines.push("请检查账号状态");
+                    }
+                }
+                await showToast({
+                    client: input.client,
+                    message: messageLines.join("\n"),
+                    variant: "warning",
+                });
+                throw new CodexStatusCommandHandledError();
+            }
+        }
         const cachedRaw = await readStore().catch(() => ({}));
         const cached = normalizeCodexStore(cachedRaw);
         if (hasCachedStore(cached)) {
             await showToast({
                 client: input.client,
-                message: `Codex status fetch failed (${fetched.error.message}); showing cached snapshot.\n${renderCachedStatusForAccount(cached, { accountId: source.accountId })}`,
+                message: `Codex status fetch failed: ${fetched.error.message}`,
+                variant: "warning",
+            });
+            await showToast({
+                client: input.client,
+                message: renderCachedStatusForAccount(cached, { accountId: source.accountId }),
                 variant: "warning",
             });
         }
@@ -279,6 +331,7 @@ export async function handleCodexStatusCommand(input) {
                 providerId: previousEntry.providerId ?? "codex",
                 accountId: fetched.status.identity.accountId ?? previousEntry.accountId ?? source.accountId,
                 email: fetched.status.identity.email ?? previousEntry.email,
+                workspaceName: fetched.status.identity.workspaceName ?? previousEntry.workspaceName,
                 lastUsed: fetched.status.updatedAt,
                 snapshot: {
                     ...(previousEntry.snapshot ?? {}),

package/dist/codex-status-fetcher.d.ts

@@ -23,6 +23,10 @@ export type CodexStatusSnapshot = {
     updatedAt: number;
 };
 export type CodexStatusError = {
+    kind: "invalid_account";
+    status: 400;
+    message: string;
+} | {
     kind: "rate_limited";
     status: 429;
     message: string;
@@ -62,5 +66,6 @@ export declare function fetchCodexStatus(input: {
     accountId?: string;
     fetchImpl?: typeof globalThis.fetch;
     now?: () => number;
+    timeoutMs?: number;
     refreshTokens?: (oauth: OpenAIOAuthAuth) => Promise<OpenAIOAuthAuth | undefined>;
 }): Promise<CodexStatusFetcherResult>;

package/dist/codex-status-fetcher.js

@@ -1,4 +1,50 @@
 const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/codex/usage";
+const CODEX_USAGE_TIMEOUT_MS = 15_000;
+function isInvalidAccountRefreshError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const value = error;
+    return value.kind === "invalid_account"
+        && value.status === 400
+        && typeof value.message === "string"
+        && value.message.length > 0;
+}
+function readErrorStatus(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const value = error.status;
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function readErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    if (error && typeof error === "object") {
+        const message = error.message;
+        if (typeof message === "string" && message.length > 0)
+            return message;
+    }
+    return String(error);
+}
+function mapRefreshTokenError(error) {
+    if (isInvalidAccountRefreshError(error))
+        return error;
+    const message = readErrorMessage(error);
+    const status = readErrorStatus(error);
+    const hasRefresh400Message = /refresh/i.test(message) && /\b400\b/.test(message);
+    if (status === 400 || hasRefresh400Message) {
+        return {
+            kind: "invalid_account",
+            status: 400,
+            message,
+        };
+    }
+    return {
+        kind: "network_error",
+        message,
+    };
+}
 function asRecord(input) {
     if (!input || typeof input !== "object" || Array.isArray(input))
         return undefined;
@@ -113,24 +159,30 @@ async function requestUsage(input) {
             access: input.oauth.access,
             accountId: input.accountId,
         }),
+        signal: input.signal,
     });
 }
 export async function fetchCodexStatus(input) {
     const fetchImpl = input.fetchImpl ?? globalThis.fetch;
     const now = input.now ?? Date.now;
     const explicitAccountId = input.accountId;
+    const timeoutMs = input.timeoutMs ?? CODEX_USAGE_TIMEOUT_MS;
     let oauth = input.oauth;
     let authPatch;
     for (let attempt = 0; attempt < 2; attempt += 1) {
         let response;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
         try {
             response = await requestUsage({
                 oauth,
                 accountId: explicitAccountId ?? oauth.accountId,
                 fetchImpl,
+                signal: controller.signal,
             });
         }
         catch (error) {
+            clearTimeout(timeout);
             if (isTimeoutError(error)) {
                 return {
                     ok: false,
@@ -148,18 +200,19 @@ export async function fetchCodexStatus(input) {
                 },
             };
         }
+        finally {
+            clearTimeout(timeout);
+        }
         if (response.status === 401 && attempt === 0 && input.refreshTokens) {
             let refreshed;
             try {
                 refreshed = await input.refreshTokens(oauth);
             }
             catch (error) {
+                const mappedError = mapRefreshTokenError(error);
                 return {
                     ok: false,
-                    error: {
-                        kind: "network_error",
-                        message: error instanceof Error ? error.message : String(error),
-                    },
+                    error: mappedError,
                 };
             }
             if (!refreshed || !refreshed.access) {

package/dist/codex-store.d.ts

@@ -14,6 +14,7 @@ export type CodexAccountSnapshot = {
 export type CodexAccountEntry = {
     name?: string;
     providerId?: string;
+    workspaceName?: string;
     refresh?: string;
     access?: string;
     expires?: number;

package/dist/codex-store.js

@@ -60,6 +60,8 @@ function pickEntry(input) {
         next.name = pickString(source.name);
     if (pickString(source.providerId))
         next.providerId = pickString(source.providerId);
+    if (pickString(source.workspaceName))
+        next.workspaceName = pickString(source.workspaceName);
     if (pickString(source.refresh))
         next.refresh = pickString(source.refresh);
     if (pickString(source.access))

package/dist/menu-runtime.d.ts

@@ -6,6 +6,7 @@ type WriteMeta = {
 export type MenuAccountInfo = {
     id?: string;
     name: string;
+    workspaceName?: string;
     index: number;
     isCurrent?: boolean;
 };

package/dist/plugin-hooks.js

@@ -421,6 +421,8 @@ function pruneTouchWriteCache(input) {
     }
 }
 export function buildPluginHooks(input) {
+    const authProvider = input.auth.provider ?? COPILOT_PROVIDER_DESCRIPTOR.providerIDs[0] ?? "github-copilot";
+    const enableCopilotAuthLoader = isCopilotProviderID(authProvider);
     const compactionLoopSafetyBypass = createCompactionLoopSafetyBypass();
     const loadStore = input.loadStore ?? readStoreSafe;
     const loadStoreSync = input.loadStoreSync ?? readStoreSafeSync;
@@ -1121,9 +1123,9 @@ export function buildPluginHooks(input) {
     return {
         auth: {
             ...input.auth,
-            provider: input.auth.provider ?? COPILOT_PROVIDER_DESCRIPTOR.providerIDs[0] ?? "github-copilot",
+            provider: authProvider,
             methods: input.auth.methods,
-            loader,
+            loader: enableCopilotAuthLoader ? loader : undefined,
         },
         config: async (config) => {
             if (!config.command)

package/dist/providers/codex-menu-adapter.js

@@ -3,6 +3,7 @@ import { stdin as input, stdout as output } from "node:process";
 import { fetchCodexStatus } from "../codex-status-fetcher.js";
 import { runCodexOAuth } from "../codex-oauth.js";
 import { getActiveCodexAccount, readCodexStore, writeCodexStore, } from "../codex-store.js";
+import { recoverInvalidCodexAccount } from "../codex-invalid-account.js";
 import { readAuth } from "../store.js";
 function pickName(input) {
     const accountId = input.accountId?.trim();
@@ -44,6 +45,13 @@ function toMenuQuota(entry) {
         completions: undefined,
     };
 }
+function withoutRecoveryWarning(snapshot) {
+    if (!snapshot)
+        return undefined;
+    const next = { ...snapshot };
+    delete next.recoveryWarning;
+    return next;
+}
 async function promptText(message) {
     const rl = createInterface({ input, output });
     try {
@@ -66,8 +74,11 @@ export function createCodexMenuAdapter(inputDeps) {
     const authorizeOpenAIOAuth = inputDeps.runCodexOAuth ?? runCodexOAuth;
     const refreshSnapshots = async (store) => {
         const names = Object.keys(store.accounts);
+        const pendingRecoveryWarnings = new Map();
         for (const name of names) {
             const entry = store.accounts[name];
+            if (!entry)
+                continue;
             const oauth = toOAuth(entry);
             if (!oauth.access && !oauth.refresh) {
                 store.accounts[name] = {
@@ -88,6 +99,30 @@ export function createCodexMenuAdapter(inputDeps) {
                 },
             }));
             if (!result.ok) {
+                if (result.error.kind === "invalid_account") {
+                    const recovered = await recoverInvalidCodexAccount({
+                        store,
+                        invalidAccountName: name,
+                        setAuth: async (next) => {
+                            await inputDeps.client.auth.set(next);
+                        },
+                    });
+                    store.accounts = recovered.store.accounts;
+                    store.active = recovered.store.active;
+                    if (recovered.replacement) {
+                        const replacement = store.accounts[recovered.replacement];
+                        const weekRemaining = replacement?.snapshot?.usageWeek?.remaining ?? 0;
+                        const fiveHourRemaining = replacement?.snapshot?.usage5h?.remaining ?? 0;
+                        if (weekRemaining > 0 && fiveHourRemaining <= 0) {
+                            pendingRecoveryWarnings.set(recovered.replacement, {
+                                code: "week_recovery_only",
+                                removed: recovered.removed,
+                                replacement: recovered.replacement,
+                            });
+                        }
+                    }
+                    continue;
+                }
                 store.accounts[name] = {
                     ...entry,
                     snapshot: {
@@ -113,10 +148,11 @@ export function createCodexMenuAdapter(inputDeps) {
                 ...(result.authPatch?.accountId !== undefined ? { accountId: result.authPatch.accountId } : {}),
                 name: nextName,
                 providerId: "openai",
+                workspaceName: result.status.identity.workspaceName ?? entry.workspaceName,
                 accountId: result.status.identity.accountId ?? result.authPatch?.accountId ?? entry.accountId,
                 email: result.status.identity.email ?? entry.email,
                 snapshot: {
-                    ...(entry.snapshot ?? {}),
+                    ...(withoutRecoveryWarning(entry.snapshot) ?? {}),
                     plan: result.status.identity.plan ?? entry.snapshot?.plan,
                     usage5h: {
                         entitlement: result.status.windows.primary.entitlement,
@@ -141,6 +177,24 @@ export function createCodexMenuAdapter(inputDeps) {
             if (store.active === name || !store.active)
                 store.active = nextName;
         }
+        for (const [name, entry] of Object.entries(store.accounts)) {
+            const warning = pendingRecoveryWarnings.get(name);
+            const snapshot = withoutRecoveryWarning(entry.snapshot);
+            store.accounts[name] = {
+                ...entry,
+                ...(snapshot ? { snapshot } : {}),
+            };
+            if (!warning)
+                continue;
+            const nextSnapshot = {
+                ...(store.accounts[name].snapshot ?? {}),
+            };
+            nextSnapshot.recoveryWarning = warning;
+            store.accounts[name] = {
+                ...store.accounts[name],
+                snapshot: nextSnapshot,
+            };
+        }
     };
     return {
         key: "codex",
@@ -201,6 +255,7 @@ export function createCodexMenuAdapter(inputDeps) {
                     fallback: `openai-${now()}`,
                 }),
                 providerId: "openai",
+                workspaceName: oauth.workspaceName,
                 refresh,
                 access,
                 expires: oauth.expires,
@@ -215,6 +270,7 @@ export function createCodexMenuAdapter(inputDeps) {
             return Object.entries(store.accounts).map(([name, entry], index) => ({
                 id: entry.accountId ?? name,
                 name: entry.email ?? entry.accountId ?? name,
+                workspaceName: entry.workspaceName,
                 index,
                 isCurrent: store.active === name,
                 source: entry.source,

package/dist/ui/menu.d.ts

@@ -3,6 +3,7 @@ import { confirm } from "./confirm.js";
 export type AccountStatus = "active" | "expired" | "unknown";
 export interface AccountInfo {
     name: string;
+    workspaceName?: string;
     index: number;
     addedAt?: number;
     lastUsed?: number;

package/dist/ui/menu.js

@@ -318,6 +318,7 @@ export function buildMenuItems(input) {
             const numbered = `${account.index + 1}. ${account.name}`;
             const label = `${numbered}${currentBadge}${statusBadge ? " " + statusBadge : ""}${quotaBadge}`;
             const detail = [
+                account.workspaceName,
                 account.lastUsed ? formatRelativeTime(account.lastUsed) : undefined,
                 account.plan,
                 account.models ? `${account.models.enabled}/${account.models.enabled + account.models.disabled} mods` : undefined,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.13.2",
+  "version": "0.13.4",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",