opencode-openai-account-switcher 0.1.0

package/dist/plugin.js

@@ -0,0 +1,127 @@
+import { runProviderMenu, } from "./menu-runtime.js";
+import { buildPluginHooks } from "./plugin-hooks.js";
+import { readCommonSettingsStore, readCommonSettingsStoreSync, writeCommonSettingsStore } from "./common-settings-store.js";
+import { createCodexMenuAdapter } from "./providers/codex-menu-adapter.js";
+import { createProviderRegistry } from "./providers/registry.js";
+import { loadOfficialCodexAuthMethods } from "./upstream/codex-loader-adapter.js";
+import { isTTY } from "./ui/ansi.js";
+import { showMenu } from "./ui/menu.js";
+function now() {
+    return Date.now();
+}
+function toSharedRuntimeAction(action) {
+    if (action.type === "cancel")
+        return { type: "cancel" };
+    if (action.type === "add")
+        return { type: "add" };
+    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-experimental-slash-commands")
+        return { type: "provider", name: "toggle-experimental-slash-commands" };
+    if (action.type === "toggle-network-retry")
+        return { type: "provider", name: "toggle-network-retry" };
+    return undefined;
+}
+export const OpenAICodexAccountSwitcher = async (input) => {
+    const client = input.client;
+    const directory = input.directory;
+    const codexClient = {
+        auth: {
+            set: async (options) => client.auth.set({
+                path: { id: "openai" },
+                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 } : {}),
+                },
+            }),
+        },
+    };
+    async function runCodexMenu() {
+        if (!isTTY()) {
+            console.log("Interactive menu requires a TTY terminal");
+            return;
+        }
+        const adapter = createCodexMenuAdapter({
+            client: codexClient,
+            loadOfficialCodexAuthMethods: () => loadOfficialCodexAuthMethods({
+                client: {
+                    auth: {
+                        set: async (value) => client.auth.set(value),
+                    },
+                },
+            }),
+            readCommonSettings: readCommonSettingsStore,
+            writeCommonSettings: async (settings) => {
+                await writeCommonSettingsStore(settings);
+            },
+        });
+        const toRuntimeAction = async (accounts, store) => {
+            const common = await readCommonSettingsStore().catch(() => undefined);
+            const action = await showMenu(accounts, {
+                provider: "codex",
+                refresh: { enabled: store.autoRefresh === true, minutes: store.refreshMinutes ?? 15 },
+                experimentalSlashCommandsEnabled: common?.experimentalSlashCommandsEnabled,
+                networkRetryEnabled: common?.networkRetryEnabled === true,
+            });
+            const shared = toSharedRuntimeAction(action);
+            if (shared)
+                return shared;
+            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" };
+            return { type: "cancel" };
+        };
+        return runProviderMenu({
+            adapter,
+            showMenu: toRuntimeAction,
+            now,
+        });
+    }
+    const methods = [
+        {
+            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 } : {}),
+                        };
+                    },
+                };
+            },
+        },
+    ];
+    const registry = createProviderRegistry({ buildPluginHooks });
+    return registry.codex.descriptor.buildPluginHooks({
+        auth: {
+            provider: "openai",
+            methods,
+        },
+        client,
+        directory,
+        loadCommonSettings: readCommonSettingsStore,
+        loadCommonSettingsSync: readCommonSettingsStoreSync,
+    });
+};

package/dist/providers/codex-menu-adapter.d.ts

@@ -0,0 +1,58 @@
+import { type CodexStatusFetcherResult } from "../codex-status-fetcher.js";
+import { type OfficialCodexAuthMethod } from "../upstream/codex-loader-adapter.js";
+import { type CodexAccountEntry, type CodexStoreFile } from "../codex-store.js";
+import type { ProviderMenuAdapter } from "../menu-runtime.js";
+import { type AccountEntry } from "../auth-store.js";
+import { type CommonSettingsStore } from "../common-settings-store.js";
+type WriteMeta = {
+    reason?: string;
+    source?: string;
+    actionType?: string;
+};
+type AuthClient = {
+    auth: {
+        set: (input: {
+            path: {
+                id: string;
+            };
+            body: {
+                type: "oauth";
+                refresh?: string;
+                access?: string;
+                expires?: number;
+                accountId?: string;
+            };
+        }) => Promise<unknown>;
+    };
+    tui?: {
+        showToast?: (options: {
+            body: {
+                message: string;
+                variant: "success" | "warning";
+            };
+        }) => Promise<unknown>;
+    };
+};
+type AdapterDependencies = {
+    client: AuthClient;
+    now?: () => number;
+    promptText?: (message: string) => Promise<string>;
+    readStore?: () => Promise<CodexStoreFile>;
+    writeStore?: (store: CodexStoreFile, meta: WriteMeta) => Promise<void>;
+    readAuthEntries?: () => Promise<Record<string, AccountEntry>>;
+    fetchStatus?: (input: {
+        oauth: {
+            type: "oauth";
+            refresh?: string;
+            access?: string;
+            expires?: number;
+            accountId?: string;
+        };
+        accountId?: string;
+    }) => Promise<CodexStatusFetcherResult>;
+    loadOfficialCodexAuthMethods?: () => Promise<OfficialCodexAuthMethod[]>;
+    readCommonSettings?: () => Promise<CommonSettingsStore>;
+    writeCommonSettings?: (settings: CommonSettingsStore, meta?: WriteMeta) => Promise<void>;
+};
+export declare function createCodexMenuAdapter(inputDeps: AdapterDependencies): ProviderMenuAdapter<CodexStoreFile, CodexAccountEntry>;
+export {};

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

@@ -0,0 +1,429 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { fetchCodexStatus } from "../codex-status-fetcher.js";
+import { loadOfficialCodexAuthMethods, } from "../upstream/codex-loader-adapter.js";
+import { getActiveCodexAccount, readCodexStore, writeCodexStore, } from "../codex-store.js";
+import { recoverInvalidCodexAccount } from "../codex-invalid-account.js";
+import { readAuth } from "../auth-store.js";
+import { readCommonSettingsStore, writeCommonSettingsStore, } from "../common-settings-store.js";
+import { applyCommonSettingsAction } from "../common-settings-actions.js";
+function pickOfficialOauthMethodByKind(methods, kind) {
+    return methods.find((method) => {
+        if (method.type !== "oauth")
+            return false;
+        if (typeof method.authorize !== "function")
+            return false;
+        const label = method.label.toLowerCase();
+        if (kind === "browser")
+            return label.includes("browser");
+        return label.includes("headless") || label.includes("device");
+    });
+}
+function parseOfficialOauthSelection(raw) {
+    const value = raw.trim().toLowerCase();
+    if (!value)
+        return "cancel";
+    if (value === "1" || value === "browser" || value === "b")
+        return "browser";
+    if (value === "2" || value === "headless" || value === "h" || value === "device")
+        return "headless";
+    return undefined;
+}
+function pickName(input) {
+    const accountId = input.accountId?.trim();
+    if (accountId)
+        return accountId;
+    const email = input.email?.trim();
+    if (email)
+        return email;
+    return input.fallback ?? "openai";
+}
+function ensureUniqueAccountName(store, preferred, currentName) {
+    if (!store.accounts[preferred] || preferred === currentName)
+        return preferred;
+    let index = 2;
+    while (store.accounts[`${preferred}#${index}`]) {
+        index += 1;
+    }
+    return `${preferred}#${index}`;
+}
+function toOAuth(entry) {
+    return {
+        type: "oauth",
+        refresh: entry.refresh,
+        access: entry.access,
+        expires: entry.expires,
+        accountId: entry.accountId,
+    };
+}
+function toMenuQuota(entry) {
+    return {
+        premium: {
+            remaining: entry.snapshot?.usage5h?.remaining,
+            entitlement: entry.snapshot?.usage5h?.entitlement,
+        },
+        chat: {
+            remaining: entry.snapshot?.usageWeek?.remaining,
+            entitlement: entry.snapshot?.usageWeek?.entitlement,
+        },
+        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 {
+        return (await rl.question(message)).trim();
+    }
+    finally {
+        rl.close();
+    }
+}
+export function createCodexMenuAdapter(inputDeps) {
+    const now = inputDeps.now ?? Date.now;
+    const loadStore = inputDeps.readStore ?? readCodexStore;
+    const prompt = inputDeps.promptText ?? promptText;
+    const persistStore = inputDeps.writeStore ?? (async (store, meta) => {
+        await writeCodexStore(store);
+        void meta;
+    });
+    const loadAuth = inputDeps.readAuthEntries ?? readAuth;
+    const fetchStatus = inputDeps.fetchStatus ?? ((input) => fetchCodexStatus(input));
+    const loadOfficialMethods = inputDeps.loadOfficialCodexAuthMethods
+        ?? (() => loadOfficialCodexAuthMethods({
+            client: {
+                auth: {
+                    set: async (value) => inputDeps.client.auth.set(value),
+                },
+            },
+        }));
+    const readCommonSettings = inputDeps.readCommonSettings ?? readCommonSettingsStore;
+    const writeCommonSettings = async (settings, meta) => {
+        if (inputDeps.writeCommonSettings) {
+            await inputDeps.writeCommonSettings(settings, meta);
+            return;
+        }
+        await writeCommonSettingsStore(settings);
+    };
+    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] = {
+                    ...entry,
+                    snapshot: {
+                        ...(entry.snapshot ?? {}),
+                        updatedAt: now(),
+                        error: "missing-openai-oauth",
+                    },
+                };
+                continue;
+            }
+            const result = await fetchStatus({ oauth, accountId: entry.accountId }).catch((error) => ({
+                ok: false,
+                error: {
+                    kind: "network_error",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            }));
+            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: {
+                        ...(entry.snapshot ?? {}),
+                        updatedAt: now(),
+                        error: result.error.message,
+                    },
+                };
+                continue;
+            }
+            const nextName = ensureUniqueAccountName(store, pickName({
+                accountId: result.status.identity.accountId,
+                email: result.status.identity.email,
+                fallback: name,
+            }), name);
+            const existing = store.accounts[nextName] ?? {};
+            const nextEntry = {
+                ...existing,
+                ...entry,
+                ...(result.authPatch?.refresh !== undefined ? { refresh: result.authPatch.refresh } : {}),
+                ...(result.authPatch?.access !== undefined ? { access: result.authPatch.access } : {}),
+                ...(result.authPatch?.expires !== undefined ? { expires: result.authPatch.expires } : {}),
+                ...(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: {
+                    ...(withoutRecoveryWarning(entry.snapshot) ?? {}),
+                    plan: result.status.identity.plan ?? entry.snapshot?.plan,
+                    usage5h: {
+                        entitlement: result.status.windows.primary.entitlement,
+                        remaining: result.status.windows.primary.remaining,
+                        used: result.status.windows.primary.used,
+                        resetAt: result.status.windows.primary.resetAt,
+                    },
+                    usageWeek: {
+                        entitlement: result.status.windows.secondary.entitlement,
+                        remaining: result.status.windows.secondary.remaining,
+                        used: result.status.windows.secondary.used,
+                        resetAt: result.status.windows.secondary.resetAt,
+                    },
+                    updatedAt: result.status.updatedAt,
+                    error: undefined,
+                },
+            };
+            if (nextName !== name)
+                delete store.accounts[name];
+            store.accounts[nextName] = nextEntry;
+            store.lastSnapshotRefresh = result.status.updatedAt;
+            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",
+        loadStore,
+        writeStore: persistStore,
+        bootstrapAuthImport: async (store) => {
+            if (store.bootstrapAuthImportTried === true)
+                return false;
+            store.bootstrapAuthImportTried = true;
+            store.bootstrapAuthImportAt = now();
+            const authEntries = await loadAuth().catch(() => ({}));
+            const openai = authEntries.openai;
+            if (openai && (openai.refresh || openai.access)) {
+                const refresh = openai.refresh ?? openai.access;
+                const access = openai.access ?? openai.refresh;
+                const accountName = pickName({
+                    accountId: openai.accountId,
+                    email: openai.email,
+                    fallback: "openai",
+                });
+                store.accounts[accountName] = {
+                    ...(store.accounts[accountName] ?? {}),
+                    name: accountName,
+                    providerId: "openai",
+                    refresh,
+                    access,
+                    expires: openai.expires,
+                    accountId: openai.accountId,
+                    email: openai.email,
+                    source: "auth",
+                    addedAt: store.accounts[accountName]?.addedAt ?? now(),
+                };
+                if (!store.active)
+                    store.active = accountName;
+            }
+            return true;
+        },
+        authorizeNewAccount: async () => {
+            const methods = await loadOfficialMethods();
+            const browserMethod = pickOfficialOauthMethodByKind(methods, "browser");
+            const headlessMethod = pickOfficialOauthMethodByKind(methods, "headless");
+            const selectedKey = parseOfficialOauthSelection(await prompt("Choose Codex auth method (1/browser/b, 2/headless/h/device, Enter to cancel): "));
+            if (selectedKey === "cancel" || !selectedKey)
+                return undefined;
+            const selectedMethod = selectedKey === "browser" ? browserMethod : headlessMethod;
+            if (!selectedMethod || typeof selectedMethod.authorize !== "function")
+                return undefined;
+            const pending = await selectedMethod.authorize();
+            if (pending.method && pending.method !== "auto") {
+                throw new Error(`Unsupported official Codex auth method: ${pending.method}`);
+            }
+            if (typeof pending.callback !== "function")
+                return undefined;
+            if (pending.url) {
+                console.log(`Go to: ${pending.url}`);
+            }
+            if (pending.instructions) {
+                console.log(pending.instructions);
+            }
+            const result = await pending.callback();
+            if (result.type !== "success" || (!result.refresh && !result.access))
+                return undefined;
+            const refresh = result.refresh ?? result.access;
+            const access = result.access ?? result.refresh;
+            await inputDeps.client.auth.set({
+                path: { id: "openai" },
+                body: {
+                    type: "oauth",
+                    refresh,
+                    access,
+                    expires: result.expires,
+                    accountId: result.accountId,
+                },
+            });
+            return {
+                name: pickName({
+                    accountId: result.accountId,
+                    fallback: `openai-${now()}`,
+                }),
+                providerId: "openai",
+                refresh,
+                access,
+                expires: result.expires,
+                accountId: result.accountId,
+                source: "manual",
+                addedAt: now(),
+            };
+        },
+        refreshSnapshots,
+        toMenuInfo: async (store) => {
+            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,
+                plan: entry.snapshot?.plan,
+                quota: toMenuQuota(entry),
+                addedAt: entry.addedAt,
+                lastUsed: entry.lastUsed,
+            }));
+        },
+        getCurrentEntry: (store) => getActiveCodexAccount(store)?.entry,
+        getRefreshConfig: (store) => ({ enabled: store.autoRefresh === true, minutes: store.refreshMinutes ?? 15 }),
+        getAccountByName: (store, name) => {
+            const direct = store.accounts[name];
+            if (direct)
+                return { name, entry: direct };
+            const match = Object.entries(store.accounts).find(([, entry]) => entry.accountId === name);
+            if (!match)
+                return undefined;
+            return { name: match[0], entry: match[1] };
+        },
+        addAccount: (store, entry) => {
+            const name = entry.name ?? pickName({ accountId: entry.accountId, email: entry.email, fallback: "openai" });
+            store.accounts[name] = {
+                ...entry,
+                name,
+            };
+            store.active = store.active ?? name;
+            return true;
+        },
+        removeAccount: (store, name) => {
+            const resolved = store.accounts[name]
+                ? name
+                : Object.entries(store.accounts).find(([, entry]) => entry.accountId === name)?.[0];
+            if (!resolved)
+                return false;
+            delete store.accounts[resolved];
+            if (store.active === resolved)
+                store.active = Object.keys(store.accounts)[0];
+            return true;
+        },
+        removeAllAccounts: (store) => {
+            if (Object.keys(store.accounts).length === 0)
+                return false;
+            store.accounts = {};
+            store.active = undefined;
+            return true;
+        },
+        switchAccount: async (store, name, entry) => {
+            await inputDeps.client.auth.set({
+                path: { id: "openai" },
+                body: {
+                    type: "oauth",
+                    refresh: entry.refresh,
+                    access: entry.access,
+                    expires: entry.expires,
+                    accountId: entry.accountId,
+                },
+            });
+            store.active = name;
+            store.accounts[name] = {
+                ...entry,
+                name,
+                providerId: "openai",
+                lastUsed: now(),
+            };
+        },
+        applyAction: async (store, action) => {
+            if (action.name === "refresh-snapshot") {
+                await refreshSnapshots(store);
+                return true;
+            }
+            if (action.name === "toggle-refresh") {
+                store.autoRefresh = store.autoRefresh !== true;
+                store.refreshMinutes = store.refreshMinutes ?? 15;
+                return true;
+            }
+            if (action.name === "set-interval") {
+                const raw = await prompt("Refresh interval (minutes): ");
+                if (!raw)
+                    return false;
+                const value = Number(raw);
+                if (!Number.isFinite(value))
+                    return false;
+                store.refreshMinutes = Math.max(1, Math.min(180, value));
+                return true;
+            }
+            if (action.name === "toggle-experimental-slash-commands"
+                || action.name === "toggle-network-retry") {
+                await applyCommonSettingsAction({
+                    action: { type: action.name },
+                    readSettings: readCommonSettings,
+                    writeSettings: writeCommonSettings,
+                });
+                return false;
+            }
+            return false;
+        },
+    };
+}

package/dist/providers/descriptor.d.ts

@@ -0,0 +1,24 @@
+import type { buildPluginHooks as buildPluginHooksFn } from "../plugin-hooks.js";
+export type ProviderCapability = "auth" | "chat-headers" | "network-retry" | "slash-commands";
+export type ProviderDescriptor = {
+    key: string;
+    providerIDs: string[];
+    storeNamespace: string;
+    commands: string[];
+    menuEntries: string[];
+    capabilities: ProviderCapability[];
+};
+type BuildPluginHooks = typeof buildPluginHooksFn;
+export type AssembledProviderDescriptor = {
+    key: string;
+    auth: {
+        provider: string;
+    };
+    buildPluginHooks: BuildPluginHooks;
+    enabledByDefault: boolean;
+};
+export declare const CODEX_PROVIDER_DESCRIPTOR: ProviderDescriptor;
+export declare function createCodexProviderDescriptor(input: {
+    buildPluginHooks: BuildPluginHooks;
+}): AssembledProviderDescriptor;
+export {};

package/dist/providers/descriptor.js

@@ -0,0 +1,16 @@
+export const CODEX_PROVIDER_DESCRIPTOR = {
+    key: "codex",
+    providerIDs: ["openai"],
+    storeNamespace: "codex",
+    commands: ["codex-status"],
+    menuEntries: ["switch-account", "add-account", "refresh-snapshot"],
+    capabilities: ["auth", "chat-headers", "network-retry", "slash-commands"],
+};
+export function createCodexProviderDescriptor(input) {
+    return {
+        key: "codex",
+        auth: { provider: "openai" },
+        buildPluginHooks: input.buildPluginHooks,
+        enabledByDefault: true,
+    };
+}

package/dist/providers/registry.d.ts

@@ -0,0 +1,15 @@
+import type { buildPluginHooks as buildPluginHooksFn } from "../plugin-hooks.js";
+import { type ProviderDescriptor } from "./descriptor.js";
+type BuildPluginHooks = typeof buildPluginHooksFn;
+export declare function listProviderDescriptors(): ProviderDescriptor[];
+export declare function getProviderDescriptorByKey(key: string): ProviderDescriptor | undefined;
+export declare function getProviderDescriptorByProviderID(providerID: string): ProviderDescriptor | undefined;
+export declare function isProviderIDSupportedByAnyDescriptor(providerID: string): boolean;
+export declare function createProviderRegistry(input: {
+    buildPluginHooks: BuildPluginHooks;
+}): {
+    codex: {
+        descriptor: import("./descriptor.js").AssembledProviderDescriptor;
+    };
+};
+export {};