opencode-copilot-account-switcher 0.12.4 → 0.13.0

package/dist/plugin.js

@@ -1,257 +1,17 @@
-import { createInterface } from "node:readline/promises";
-import { stdin as input, stdout as output } from "node:process";
-import { fetchQuota } from "./active-account-quota.js";
-import { getGitHubToken, normalizeDomain } from "./copilot-api-helpers.js";
+import { normalizeDomain } from "./copilot-api-helpers.js";
 import { listAssignableAccountsForModel, listKnownCopilotModels, rewriteModelAccountAssignments, } from "./model-account-map.js";
-import { applyMenuAction, persistAccountSwitch } from "./plugin-actions.js";
+import { runProviderMenu } from "./menu-runtime.js";
+import { persistAccountSwitch } from "./plugin-actions.js";
 import { buildPluginHooks } from "./plugin-hooks.js";
+import { createCodexMenuAdapter } from "./providers/codex-menu-adapter.js";
+import { createCopilotMenuAdapter } from "./providers/copilot-menu-adapter.js";
 import { isTTY } from "./ui/ansi.js";
-import { showAccountActions, showMenu } from "./ui/menu.js";
+import { showMenu } from "./ui/menu.js";
 import { select, selectMany } from "./ui/select.js";
-import { authPath, readAuth, readStore, writeStore } from "./store.js";
+import { readAuth, readStore, writeStore } from "./store.js";
 function now() {
     return Date.now();
 }
-const CLIENT_ID = "Ov23li8tweQw6odWQebz";
-const OAUTH_POLLING_SAFETY_MARGIN_MS = 3000;
-function getUrls(domain) {
-    return {
-        DEVICE_CODE_URL: `https://${domain}/login/device/code`,
-        ACCESS_TOKEN_URL: `https://${domain}/login/oauth/access_token`,
-    };
-}
-async function sleep(ms) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-}
-function toInfo(name, entry, index, active) {
-    const status = entry.expires && entry.expires > 0 && entry.expires < now() ? "expired" : "active";
-    const labelName = name.startsWith("github.com:") ? name.slice("github.com:".length) : name;
-    const hasUser = entry.user ? labelName.includes(entry.user) : false;
-    const hasEmail = entry.email ? labelName.includes(entry.email) : false;
-    const suffix = entry.user
-        ? hasUser
-            ? ""
-            : ` (${entry.user})`
-        : entry.email
-            ? ` (${entry.email})`
-            : "";
-    const label = `${labelName}${suffix}`;
-    return {
-        name: label,
-        index,
-        addedAt: entry.addedAt,
-        lastUsed: entry.lastUsed,
-        status,
-        isCurrent: active === name,
-    };
-}
-async function promptText(message) {
-    const rl = createInterface({ input, output });
-    try {
-        const answer = await rl.question(message);
-        return answer.trim();
-    }
-    finally {
-        rl.close();
-    }
-}
-async function promptAccountName(existing) {
-    while (true) {
-        const name = await promptText("Account name: ");
-        if (!name)
-            continue;
-        if (!existing.includes(name))
-            return name;
-        console.log(`Name already exists: ${name}`);
-    }
-}
-async function promptAccountEntry(existing) {
-    const name = await promptAccountName(existing);
-    const refresh = await promptText("OAuth refresh/access token: ");
-    const access = await promptText("Copilot access token (optional, press Enter to skip): ");
-    const expiresRaw = await promptText("Access token expires (unix ms, optional): ");
-    const enterpriseUrl = await promptText("Enterprise URL (optional): ");
-    const expires = Number(expiresRaw);
-    const entry = {
-        name,
-        refresh,
-        access: access || refresh,
-        expires: Number.isFinite(expires) ? expires : 0,
-        enterpriseUrl: enterpriseUrl || undefined,
-        addedAt: now(),
-        source: "manual",
-    };
-    return { name, entry };
-}
-async function loginOauth(deployment, enterpriseUrl) {
-    const domain = deployment === "enterprise" ? normalizeDomain(enterpriseUrl ?? "") : "github.com";
-    const urls = getUrls(domain);
-    const deviceResponse = await fetch(urls.DEVICE_CODE_URL, {
-        method: "POST",
-        headers: {
-            Accept: "application/json",
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            client_id: CLIENT_ID,
-            scope: "read:user user:email",
-        }),
-    });
-    if (!deviceResponse.ok)
-        throw new Error("Failed to initiate device authorization");
-    const deviceData = (await deviceResponse.json());
-    console.log(`Go to: ${deviceData.verification_uri}`);
-    console.log(`Enter code: ${deviceData.user_code}`);
-    while (true) {
-        const response = await fetch(urls.ACCESS_TOKEN_URL, {
-            method: "POST",
-            headers: {
-                Accept: "application/json",
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                client_id: CLIENT_ID,
-                device_code: deviceData.device_code,
-                grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-            }),
-        });
-        if (!response.ok)
-            throw new Error("Failed to poll token");
-        const data = (await response.json());
-        if (data.access_token) {
-            const entry = {
-                name: deployment === "enterprise" ? `enterprise:${domain}` : "github.com",
-                refresh: data.access_token,
-                access: data.access_token,
-                expires: 0,
-                enterpriseUrl: deployment === "enterprise" ? domain : undefined,
-                addedAt: now(),
-                source: "auth",
-            };
-            const user = await fetchUser(entry);
-            if (user?.login)
-                entry.user = user.login;
-            if (user?.email)
-                entry.email = user.email;
-            if (user?.orgs?.length)
-                entry.orgs = user.orgs;
-            return entry;
-        }
-        if (data.error === "authorization_pending") {
-            await sleep(deviceData.interval * 1000 + OAUTH_POLLING_SAFETY_MARGIN_MS);
-            continue;
-        }
-        if (data.error === "slow_down") {
-            const serverInterval = data.interval;
-            const next = (serverInterval && serverInterval > 0 ? serverInterval : deviceData.interval + 5) * 1000;
-            await sleep(next + OAUTH_POLLING_SAFETY_MARGIN_MS);
-            continue;
-        }
-        throw new Error("Authorization failed");
-    }
-}
-async function promptFilePath(message, defaultValue) {
-    const rl = createInterface({ input, output });
-    try {
-        const answer = await rl.question(`${message} (${defaultValue}): `);
-        return answer.trim() || defaultValue;
-    }
-    finally {
-        rl.close();
-    }
-}
-function buildName(entry, login) {
-    const user = login ?? entry.user;
-    if (!user)
-        return entry.name;
-    if (!entry.enterpriseUrl)
-        return user;
-    const host = normalizeDomain(entry.enterpriseUrl);
-    return `${host}:${user}`;
-}
-function score(entry) {
-    return (entry.user ? 2 : 0) + (entry.email ? 2 : 0) + (entry.orgs?.length ? 1 : 0);
-}
-function key(entry) {
-    if (entry.refresh)
-        return `refresh:${entry.refresh}`;
-    return undefined;
-}
-function dedupe(store) {
-    const seen = new Map();
-    for (const [name, entry] of Object.entries(store.accounts)) {
-        const k = key(entry);
-        if (!k)
-            continue;
-        const current = seen.get(k);
-        if (!current) {
-            seen.set(k, name);
-            continue;
-        }
-        const currentEntry = store.accounts[current];
-        if (score(entry) > score(currentEntry)) {
-            rewriteModelAccountAssignments(store, { [current]: name });
-            delete store.accounts[current];
-            seen.set(k, name);
-            if (store.active === current)
-                store.active = name;
-            continue;
-        }
-        rewriteModelAccountAssignments(store, { [name]: current });
-        delete store.accounts[name];
-        if (store.active === name)
-            store.active = current;
-    }
-}
-function mergeAuth(store, imported) {
-    dedupe(store);
-    const byRefresh = new Map();
-    for (const [name, entry] of Object.entries(store.accounts)) {
-        if (entry.refresh)
-            byRefresh.set(entry.refresh, name);
-    }
-    for (const [key, entry] of imported) {
-        const match = byRefresh.get(entry.refresh);
-        if (match) {
-            store.accounts[match] = {
-                ...store.accounts[match],
-                ...entry,
-                name: store.accounts[match].name,
-                source: "auth",
-                providerId: key,
-            };
-            if (!store.active)
-                store.active = match;
-            continue;
-        }
-        const name = entry.name || `auth:${key}`;
-        store.accounts[name] = {
-            ...entry,
-            name,
-            source: "auth",
-            providerId: key,
-        };
-        if (!store.active)
-            store.active = name;
-    }
-}
-function renameAccounts(store, items) {
-    const counts = new Map();
-    const renamed = items.map((item) => {
-        const count = (counts.get(item.base) ?? 0) + 1;
-        counts.set(item.base, count);
-        const name = count === 1 ? item.base : `${item.base}#${count}`;
-        return { ...item, name, entry: { ...item.entry, name } };
-    });
-    store.accounts = renamed.reduce((acc, item) => {
-        acc[item.name] = item.entry;
-        return acc;
-    }, {});
-    rewriteModelAccountAssignments(store, Object.fromEntries(renamed.map((item) => [item.oldName, item.name])));
-    const active = renamed.find((item) => item.oldName === store.active);
-    if (active)
-        store.active = active.name;
-}
 export async function configureDefaultAccountGroup(store, selectors) {
     const accountEntries = Object.entries(store.accounts);
     if (accountEntries.length === 0) {
@@ -389,137 +149,6 @@ async function configureModelAccountAssignmentsWithSelection(store, selectors) {
     };
     return true;
 }
-async function refreshIdentity(store) {
-    const items = await Promise.all(Object.entries(store.accounts).map(async ([name, entry]) => {
-        const user = await fetchUser(entry);
-        const base = buildName(entry, user?.login ?? entry.user);
-        return {
-            oldName: name,
-            base,
-            entry: {
-                ...entry,
-                user: user?.login ?? entry.user,
-                email: user?.email ?? entry.email,
-                orgs: user?.orgs ?? entry.orgs,
-                name: base,
-            },
-        };
-    }));
-    renameAccounts(store, items);
-}
-async function fetchModels(entry) {
-    try {
-        const headers = {
-            Accept: "application/json",
-            Authorization: `Bearer ${entry.access}`,
-            "User-Agent": "GitHubCopilotChat/0.26.7",
-            "Editor-Version": "vscode/1.96.2",
-            "Editor-Plugin-Version": "copilot/1.159.0",
-            "Copilot-Integration-Id": "vscode-chat",
-            "X-Github-Api-Version": "2025-04-01",
-        };
-        const modelsUrl = entry.enterpriseUrl
-            ? `https://copilot-api.${normalizeDomain(entry.enterpriseUrl)}/models`
-            : "https://api.githubcopilot.com/models";
-        const modelRes = await fetch(modelsUrl, { headers });
-        if (!modelRes.ok) {
-            const base = entry.enterpriseUrl ? `https://api.${normalizeDomain(entry.enterpriseUrl)}` : "https://api.github.com";
-            const tokenRes = await fetch(`${base}/copilot_internal/v2/token`, {
-                headers: {
-                    Accept: "application/json",
-                    Authorization: `token ${getGitHubToken(entry)}`,
-                    "User-Agent": "GitHubCopilotChat/0.26.7",
-                    "Editor-Version": "vscode/1.96.2",
-                    "Editor-Plugin-Version": "copilot/1.159.0",
-                    "X-Github-Api-Version": "2025-04-01",
-                },
-            });
-            if (!tokenRes.ok)
-                return { available: [], disabled: [], error: `token ${tokenRes.status}` };
-            const tokenData = (await tokenRes.json());
-            if (!tokenData.token)
-                return { available: [], disabled: [], error: "token missing" };
-            // Update entry with new session token
-            entry.access = tokenData.token;
-            if (tokenData.expires_at)
-                entry.expires = tokenData.expires_at * 1000;
-            const fallbackRes = await fetch(modelsUrl, {
-                headers: {
-                    Accept: "application/json",
-                    Authorization: `Bearer ${tokenData.token}`,
-                    "User-Agent": "GitHubCopilotChat/0.26.7",
-                    "Editor-Version": "vscode/1.96.2",
-                    "Editor-Plugin-Version": "copilot/1.159.0",
-                    "Copilot-Integration-Id": "vscode-chat",
-                    "X-Github-Api-Version": "2025-04-01",
-                },
-            });
-            if (!fallbackRes.ok)
-                return { available: [], disabled: [], error: `models ${fallbackRes.status}` };
-            return parseModels((await fallbackRes.json()));
-        }
-        return parseModels((await modelRes.json()));
-    }
-    catch (error) {
-        return { available: [], disabled: [], error: error instanceof Error ? error.message : String(error) };
-    }
-}
-function parseModels(modelData) {
-    const available = [];
-    const disabled = [];
-    for (const item of modelData.data ?? []) {
-        if (!item.id)
-            continue;
-        const enabled = item.model_picker_enabled === true && item.policy?.state !== "disabled";
-        if (enabled)
-            available.push(item.id);
-        else
-            disabled.push(item.id);
-    }
-    return { available, disabled, updatedAt: now() };
-}
-async function fetchUser(entry) {
-    try {
-        const base = entry.enterpriseUrl ? `https://api.${normalizeDomain(entry.enterpriseUrl)}` : "https://api.github.com";
-        const headers = {
-            Accept: "application/json",
-            Authorization: `token ${getGitHubToken(entry)}`,
-            "User-Agent": "GitHubCopilotChat/0.26.7",
-        };
-        const userRes = await fetch(`${base}/user`, { headers });
-        if (!userRes.ok)
-            return undefined;
-        const user = (await userRes.json());
-        let email = user.email;
-        if (!email) {
-            const emailRes = await fetch(`${base}/user/emails`, { headers });
-            if (emailRes.ok) {
-                const items = (await emailRes.json());
-                const primary = items.find((item) => item.primary && item.verified);
-                email = primary?.email ?? items[0]?.email;
-            }
-        }
-        const orgRes = await fetch(`${base}/user/orgs`, { headers });
-        const orgs = orgRes.ok ? (await orgRes.json()).map((o) => o.login).filter(Boolean) : undefined;
-        return { login: user.login, email, orgs };
-    }
-    catch {
-        return undefined;
-    }
-}
-async function switchAccount(client, entry) {
-    const payload = {
-        type: "oauth",
-        refresh: entry.refresh,
-        access: entry.access,
-        expires: entry.expires,
-        ...(entry.enterpriseUrl ? { enterpriseUrl: entry.enterpriseUrl } : {}),
-    };
-    await client.auth.set({
-        path: { id: entry.enterpriseUrl ? "github-copilot-enterprise" : "github-copilot" },
-        body: payload,
-    });
-}
 export async function activateAddedAccount(input) {
     await input.writeStore(input.store, {
         reason: "activate-added-account",
@@ -539,6 +168,20 @@ export const CopilotAccountSwitcher = async (input) => {
     const directory = input.directory;
     const serverUrl = input.serverUrl;
     const persistStore = (store, meta) => writeStore(store, { debug: meta });
+    const codexClient = {
+        auth: {
+            set: async (options) => client.auth.set({
+                path: options.path,
+                body: {
+                    type: "oauth",
+                    refresh: options.body.refresh ?? options.body.access ?? "",
+                    access: options.body.access ?? options.body.refresh ?? "",
+                    expires: options.body.expires ?? 0,
+                    ...(options.body.accountId ? { accountId: options.body.accountId } : {}),
+                },
+            }),
+        },
+    };
     const methods = [
         {
             type: "oauth",
@@ -564,98 +207,54 @@ export const CopilotAccountSwitcher = async (input) => {
                 };
             },
         },
+        {
+            type: "oauth",
+            label: "Manage OpenAI Codex accounts",
+            async authorize() {
+                const entry = await runCodexMenu();
+                return {
+                    url: "",
+                    instructions: "",
+                    method: "auto",
+                    async callback() {
+                        if (!entry)
+                            return { type: "failed" };
+                        return {
+                            type: "success",
+                            provider: "openai",
+                            refresh: entry.refresh ?? "",
+                            access: entry.access ?? entry.refresh ?? "",
+                            expires: entry.expires ?? 0,
+                            ...(entry.accountId ? { accountId: entry.accountId } : {}),
+                        };
+                    },
+                };
+            },
+        },
     ];
     async function runMenu() {
-        const store = await readStore();
-        const auth = await readAuth().catch(() => ({}));
-        const imported = Object.entries(auth).filter(([key]) => key === "github-copilot" || key === "github-copilot-enterprise");
-        if (imported.length > 0) {
-            mergeAuth(store, imported);
-            const preferred = imported.find(([key]) => key === "github-copilot") ?? imported[0];
-            if (!store.active)
-                store.active = preferred?.[1].name;
-        }
-        if (Object.keys(store.accounts).length > 0
-            && !Object.values(store.accounts).some((entry) => entry.user || entry.email || (entry.orgs && entry.orgs.length > 0))) {
-            await refreshIdentity(store);
-            dedupe(store);
-            await persistStore(store, {
-                reason: "refresh-identity-bootstrap",
-                source: "plugin.runMenu",
-            });
-        }
         if (!isTTY()) {
             console.log("Interactive menu requires a TTY terminal");
             return;
         }
-        let nextRefresh = 0;
-        while (true) {
-            if (store.autoRefresh === true && now() >= nextRefresh) {
-                const updated = await Promise.all(Object.entries(store.accounts).map(async ([name, entry]) => ({
-                    name,
-                    entry: {
-                        ...entry,
-                        quota: await fetchQuota(entry),
-                    },
-                })));
-                for (const item of updated) {
-                    store.accounts[item.name] = item.entry;
-                }
-                store.lastQuotaRefresh = now();
-                await persistStore(store, {
-                    reason: "auto-refresh",
-                    source: "plugin.runMenu",
-                    actionType: "toggle-refresh",
-                });
-                nextRefresh = now() + (store.refreshMinutes ?? 15) * 60_000;
-            }
-            const entries = Object.entries(store.accounts);
-            const refreshed = await Promise.all(entries.map(async ([name, entry]) => {
-                if (entry.user || entry.email || (entry.orgs && entry.orgs.length > 0))
-                    return { name, entry };
-                const user = await fetchUser(entry);
-                return {
-                    name,
-                    entry: {
-                        ...entry,
-                        user: user?.login ?? entry.user,
-                        email: user?.email ?? entry.email,
-                        orgs: user?.orgs ?? entry.orgs,
-                    },
-                };
-            }));
-            for (const item of refreshed) {
-                store.accounts[item.name] = item.entry;
-            }
-            const accounts = entries.map(([name, entry], index) => ({
-                ...toInfo(name, entry, index, store.active),
-                source: entry.source,
-                orgs: entry.orgs,
-                plan: entry.quota?.plan,
-                sku: entry.quota?.sku,
-                reset: entry.quota?.reset,
-                models: entry.models
-                    ? {
-                        enabled: entry.models.available.length,
-                        disabled: entry.models.disabled.length,
-                    }
-                    : undefined,
-                modelsError: entry.models?.error,
-                modelList: entry.models
-                    ? {
-                        available: entry.models.available,
-                        disabled: entry.models.disabled,
-                    }
-                    : undefined,
-                quota: entry.quota?.snapshots
-                    ? {
-                        premium: entry.quota.snapshots.premium,
-                        chat: entry.quota.snapshots.chat,
-                        completions: entry.quota.snapshots.completions,
-                    }
-                    : undefined,
-            }));
+        const adapter = createCopilotMenuAdapter({
+            client,
+            readStore,
+            writeStore: persistStore,
+            readAuth,
+            now,
+            configureDefaultAccountGroup,
+            configureModelAccountAssignments,
+            clearAllAccounts,
+            removeAccountFromStore,
+            activateAddedAccount,
+            logSwitchHint: () => {
+                console.log("Switched account. If a later Copilot session hits input[*].id too long after switching, enable Copilot Network Retry from the menu.");
+            },
+        });
+        const toRuntimeAction = async (accounts, store) => {
             const action = await showMenu(accounts, {
+                provider: "copilot",
                 refresh: { enabled: store.autoRefresh === true, minutes: store.refreshMinutes ?? 15 },
                 lastQuotaRefresh: store.lastQuotaRefresh,
                 modelAccountAssignmentCount: Object.keys(store.modelAccountAssignments ?? {}).length,
@@ -666,226 +265,86 @@ export const CopilotAccountSwitcher = async (input) => {
                 networkRetryEnabled: store.networkRetryEnabled === true,
                 syntheticAgentInitiatorEnabled: store.syntheticAgentInitiatorEnabled === true,
             });
-            if (action.type === "cancel") {
-                const active = store.active ? store.accounts[store.active] : undefined;
-                return active;
-            }
-            if (await applyMenuAction({ action, store, writeStore: persistStore })) {
-                continue;
-            }
-            if (action.type === "add") {
-                const mode = await promptText("Add via device login? (y/n): ");
-                const useDevice = mode.toLowerCase() === "y" || mode.toLowerCase() === "yes";
-                if (useDevice) {
-                    const dep = await promptText("Enterprise? (y/n): ");
-                    const isEnterprise = dep.toLowerCase() === "y" || dep.toLowerCase() === "yes";
-                    const domain = isEnterprise ? await promptText("Enterprise URL or domain: ") : undefined;
-                    const entry = await loginOauth(isEnterprise ? "enterprise" : "github.com", domain);
-                    const user = await fetchUser(entry);
-                    if (user?.login)
-                        entry.user = user.login;
-                    if (user?.email)
-                        entry.email = user.email;
-                    if (user?.orgs?.length)
-                        entry.orgs = user.orgs;
-                    entry.name = buildName(entry, user?.login);
-                    store.accounts[entry.name] = entry;
-                    store.active = store.active ?? entry.name;
-                    if (store.active === entry.name) {
-                        await activateAddedAccount({
-                            store,
-                            name: entry.name,
-                            switchAccount: () => switchAccount(client, entry),
-                            writeStore: persistStore,
-                        });
-                    }
-                    else {
-                        await persistStore(store, {
-                            reason: "add-account-device-login",
-                            source: "plugin.runMenu",
-                            actionType: "add",
-                        });
-                    }
-                    continue;
-                }
-                const manual = await promptAccountEntry(Object.keys(store.accounts));
-                const user = await fetchUser(manual.entry);
-                if (user?.login)
-                    manual.entry.user = user.login;
-                if (user?.email)
-                    manual.entry.email = user.email;
-                if (user?.orgs?.length)
-                    manual.entry.orgs = user.orgs;
-                manual.entry.name = buildName(manual.entry, user?.login);
-                store.accounts[manual.entry.name] = manual.entry;
-                store.active = store.active ?? manual.entry.name;
-                if (store.active === manual.entry.name) {
-                    await activateAddedAccount({
-                        store,
-                        name: manual.entry.name,
-                        switchAccount: () => switchAccount(client, manual.entry),
-                        writeStore: persistStore,
-                    });
-                }
-                else {
-                    await persistStore(store, {
-                        reason: "add-account-manual",
-                        source: "plugin.runMenu",
-                        actionType: "add",
-                    });
-                }
-                continue;
-            }
-            if (action.type === "import") {
-                const file = await promptFilePath("auth.json path", authPath());
-                const auth = await readAuth(file).catch(() => ({}));
-                const imported = Object.entries(auth).filter(([key]) => key === "github-copilot" || key === "github-copilot-enterprise");
-                for (const [key, entry] of imported) {
-                    const user = await fetchUser(entry);
-                    if (user?.login)
-                        entry.user = user.login;
-                    if (user?.email)
-                        entry.email = user.email;
-                    if (user?.orgs?.length)
-                        entry.orgs = user.orgs;
-                    entry.name = buildName(entry, user?.login);
-                }
-                mergeAuth(store, imported);
-                await persistStore(store, {
-                    reason: "import-auth",
-                    source: "plugin.runMenu",
-                    actionType: "import",
-                });
-                continue;
-            }
-            if (action.type === "refresh-identity") {
-                await refreshIdentity(store);
-                dedupe(store);
-                await persistStore(store, {
-                    reason: "refresh-identity",
-                    source: "plugin.runMenu",
-                    actionType: "refresh-identity",
-                });
-                continue;
-            }
-            if (action.type === "toggle-refresh") {
-                store.autoRefresh = !store.autoRefresh;
-                store.refreshMinutes = store.refreshMinutes ?? 15;
-                await persistStore(store, {
-                    reason: "toggle-refresh",
-                    source: "plugin.runMenu",
-                    actionType: "toggle-refresh",
-                });
-                continue;
-            }
-            if (action.type === "set-interval") {
-                const value = await promptText("Refresh interval (minutes): ");
-                const minutes = Math.max(1, Math.min(180, Number(value)));
-                if (Number.isFinite(minutes))
-                    store.refreshMinutes = minutes;
-                await persistStore(store, {
-                    reason: "set-interval",
-                    source: "plugin.runMenu",
-                    actionType: "set-interval",
-                });
-                continue;
-            }
-            if (action.type === "quota") {
-                const updated = await Promise.all(entries.map(async ([name, entry]) => ({
-                    name,
-                    entry: {
-                        ...entry,
-                        quota: await fetchQuota(entry),
-                    },
-                })));
-                for (const item of updated) {
-                    store.accounts[item.name] = item.entry;
-                }
-                store.lastQuotaRefresh = now();
-                await persistStore(store, {
-                    reason: "quota-refresh",
-                    source: "plugin.runMenu",
-                    actionType: "quota",
-                });
-                continue;
-            }
-            if (action.type === "check-models") {
-                const updated = await Promise.all(entries.map(async ([name, entry]) => ({
-                    name,
-                    entry: {
-                        ...entry,
-                        models: await fetchModels(entry),
-                    },
-                })));
-                for (const item of updated) {
-                    store.accounts[item.name] = item.entry;
-                }
-                await persistStore(store, {
-                    reason: "check-models",
-                    source: "plugin.runMenu",
-                    actionType: "check-models",
-                });
-                continue;
-            }
-            if (action.type === "configure-default-group") {
-                const changed = await configureDefaultAccountGroup(store);
-                if (!changed)
-                    continue;
-                await persistStore(store, {
-                    reason: "configure-default-account-group",
-                    source: "plugin.runMenu",
-                    actionType: "configure-default-account-group",
-                });
-                continue;
-            }
-            if (action.type === "assign-models") {
-                const changed = await configureModelAccountAssignments(store);
-                if (!changed)
-                    continue;
-                await persistStore(store, {
-                    reason: "assign-model-account",
-                    source: "plugin.runMenu",
-                    actionType: "assign-model-account",
-                });
-                continue;
-            }
-            if (action.type === "remove-all") {
-                clearAllAccounts(store);
-                await persistStore(store, {
-                    reason: "remove-all",
-                    source: "plugin.runMenu",
-                    actionType: "remove-all",
-                });
-                continue;
-            }
-            if (action.type === "switch") {
-                const selected = entries[action.account.index];
-                if (!selected)
-                    continue;
-                const [name, entry] = selected;
-                const decision = await showAccountActions(action.account);
-                if (decision === "back")
-                    continue;
-                if (decision === "remove") {
-                    removeAccountFromStore(store, name);
-                    await persistStore(store, {
-                        reason: "remove-account",
-                        source: "plugin.runMenu",
-                        actionType: "remove",
-                    });
-                    continue;
-                }
-                await switchAccount(client, entry);
-                await persistAccountSwitch({
-                    store,
-                    name,
-                    at: now(),
-                    writeStore: persistStore,
-                });
-                console.log("Switched account. If a later Copilot session hits input[*].id too long after switching, enable Copilot Network Retry from the menu.");
-                continue;
-            }
+            if (action.type === "cancel")
+                return { type: "cancel" };
+            if (action.type === "add")
+                return { type: "add" };
+            if (action.type === "import")
+                return { type: "provider", name: "import-auth" };
+            if (action.type === "refresh-identity")
+                return { type: "provider", name: "refresh-identity" };
+            if (action.type === "toggle-refresh")
+                return { type: "provider", name: "toggle-refresh" };
+            if (action.type === "set-interval")
+                return { type: "provider", name: "set-interval" };
+            if (action.type === "quota")
+                return { type: "provider", name: "quota-refresh" };
+            if (action.type === "check-models")
+                return { type: "provider", name: "check-models" };
+            if (action.type === "configure-default-group")
+                return { type: "provider", name: "configure-default-group" };
+            if (action.type === "assign-models")
+                return { type: "provider", name: "assign-models" };
+            if (action.type === "remove-all")
+                return { type: "remove-all" };
+            if (action.type === "switch")
+                return { type: "switch", account: action.account };
+            if (action.type === "remove")
+                return { type: "remove", account: action.account };
+            if (action.type === "toggle-loop-safety")
+                return { type: "provider", name: "toggle-loop-safety" };
+            if (action.type === "toggle-loop-safety-provider-scope")
+                return { type: "provider", name: "toggle-loop-safety-provider-scope" };
+            if (action.type === "toggle-experimental-slash-commands")
+                return { type: "provider", name: "toggle-experimental-slash-commands" };
+            if (action.type === "toggle-network-retry")
+                return { type: "provider", name: "toggle-network-retry" };
+            if (action.type === "toggle-synthetic-agent-initiator")
+                return { type: "provider", name: "toggle-synthetic-agent-initiator" };
+            return { type: "cancel" };
+        };
+        return runProviderMenu({
+            adapter,
+            showMenu: toRuntimeAction,
+            now,
+        });
+    }
+    async function runCodexMenu() {
+        if (!isTTY()) {
+            console.log("Interactive menu requires a TTY terminal");
+            return;
         }
+        const adapter = createCodexMenuAdapter({
+            client: codexClient,
+        });
+        const toRuntimeAction = async (accounts, store) => {
+            const action = await showMenu(accounts, {
+                provider: "codex",
+                refresh: { enabled: store.autoRefresh === true, minutes: store.refreshMinutes ?? 15 },
+            });
+            if (action.type === "cancel")
+                return { type: "cancel" };
+            if (action.type === "add")
+                return { type: "add" };
+            if (action.type === "quota")
+                return { type: "provider", name: "refresh-snapshot" };
+            if (action.type === "toggle-refresh")
+                return { type: "provider", name: "toggle-refresh" };
+            if (action.type === "set-interval")
+                return { type: "provider", name: "set-interval" };
+            if (action.type === "remove-all")
+                return { type: "remove-all" };
+            if (action.type === "switch")
+                return { type: "switch", account: action.account };
+            if (action.type === "remove")
+                return { type: "remove", account: action.account };
+            return { type: "cancel" };
+        };
+        return runProviderMenu({
+            adapter,
+            showMenu: toRuntimeAction,
+            now,
+        });
     }
     return buildPluginHooks({
         auth: {