opencode-copilot-account-switcher 0.12.3 → 0.13.0

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

@@ -0,0 +1,47 @@
+import { type CodexStatusFetcherResult } from "../codex-status-fetcher.js";
+import { type CodexOAuthAccount } from "../codex-oauth.js";
+import { type CodexAccountEntry, type CodexStoreFile } from "../codex-store.js";
+import type { ProviderMenuAdapter } from "../menu-runtime.js";
+import { type AccountEntry } from "../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>;
+    };
+};
+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>;
+    runCodexOAuth?: () => Promise<CodexOAuthAccount | undefined>;
+};
+export declare function createCodexMenuAdapter(inputDeps: AdapterDependencies): ProviderMenuAdapter<CodexStoreFile, CodexAccountEntry>;
+export {};

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

@@ -0,0 +1,307 @@
+import { createInterface } from "node:readline/promises";
+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 { readAuth } from "../store.js";
+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,
+    };
+}
+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 authorizeOpenAIOAuth = inputDeps.runCodexOAuth ?? runCodexOAuth;
+    const refreshSnapshots = async (store) => {
+        const names = Object.keys(store.accounts);
+        for (const name of names) {
+            const entry = store.accounts[name];
+            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) {
+                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",
+                accountId: result.status.identity.accountId ?? result.authPatch?.accountId ?? entry.accountId,
+                email: result.status.identity.email ?? entry.email,
+                snapshot: {
+                    ...(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;
+        }
+    };
+    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 oauth = await authorizeOpenAIOAuth();
+            if (!oauth || (!oauth.refresh && !oauth.access))
+                return undefined;
+            const refresh = oauth.refresh ?? oauth.access;
+            const access = oauth.access ?? oauth.refresh;
+            await inputDeps.client.auth.set({
+                path: { id: "openai" },
+                body: {
+                    type: "oauth",
+                    refresh,
+                    access,
+                    expires: oauth.expires,
+                    accountId: oauth.accountId,
+                },
+            });
+            return {
+                name: pickName({
+                    accountId: oauth.accountId,
+                    email: oauth.email,
+                    fallback: `openai-${now()}`,
+                }),
+                providerId: "openai",
+                refresh,
+                access,
+                expires: oauth.expires,
+                accountId: oauth.accountId,
+                email: oauth.email,
+                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,
+                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;
+            }
+            return false;
+        },
+    };
+}

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

@@ -0,0 +1,65 @@
+import type { ProviderMenuAdapter } from "../menu-runtime.js";
+import { type AccountEntry, type StoreFile, type StoreWriteDebugMeta } from "../store.js";
+type AuthClient = {
+    auth: {
+        set: (input: {
+            path: {
+                id: string;
+            };
+            body: {
+                type: "oauth";
+                refresh: string;
+                access: string;
+                expires: number;
+                enterpriseUrl?: string;
+            };
+        }) => Promise<unknown>;
+    };
+};
+type DebugMeta = StoreWriteDebugMeta;
+type AdapterDependencies = {
+    client: AuthClient;
+    readStore?: () => Promise<StoreFile>;
+    writeStore?: (store: StoreFile, meta?: DebugMeta) => Promise<void>;
+    readAuth?: (filePath?: string) => Promise<Record<string, AccountEntry>>;
+    authorizeNewAccount?: (store: StoreFile) => Promise<AccountEntry | undefined>;
+    now?: () => number;
+    fetchUser?: (entry: AccountEntry) => Promise<{
+        login?: string;
+        email?: string;
+        orgs?: string[];
+    } | undefined>;
+    fetchModels?: (entry: AccountEntry) => Promise<AccountEntry["models"]>;
+    fetchQuota?: (entry: AccountEntry) => Promise<AccountEntry["quota"]>;
+    configureDefaultAccountGroup?: (store: StoreFile, selectors?: {
+        selectAccounts?: (options: Array<{
+            label: string;
+            value: string;
+            hint?: string;
+        }>) => Promise<string[] | null>;
+    }) => Promise<boolean>;
+    configureModelAccountAssignments?: (store: StoreFile, selectors?: {
+        selectModel?: (options: Array<{
+            label: string;
+            value: string;
+            hint?: string;
+        }>) => Promise<string | null>;
+        selectAccounts?: (options: Array<{
+            label: string;
+            value: string;
+            hint?: string;
+        }>) => Promise<string[] | null>;
+    }) => Promise<boolean>;
+    clearAllAccounts?: (store: StoreFile) => void;
+    removeAccountFromStore?: (store: StoreFile, name: string) => void;
+    activateAddedAccount?: (input: {
+        store: StoreFile;
+        name: string;
+        switchAccount: () => Promise<void>;
+        writeStore: (store: StoreFile, meta?: StoreWriteDebugMeta) => Promise<void>;
+        now?: () => number;
+    }) => Promise<void>;
+    logSwitchHint?: () => void;
+};
+export declare function createCopilotMenuAdapter(inputDeps: AdapterDependencies): ProviderMenuAdapter<StoreFile, AccountEntry>;
+export {};