opencode-copilot-account-switcher 0.12.3 → 0.13.0

package/dist/codex-store.js

@@ -3,52 +3,244 @@ import os from "node:os";
 import { promises as fs } from "node:fs";
 import { xdgConfig } from "xdg-basedir";
 const filename = "codex-store.json";
-function pickCodexStore(input) {
+function asRecord(input) {
     if (!input || typeof input !== "object" || Array.isArray(input))
-        return {};
-    const source = input;
-    const store = {};
-    if (typeof source.activeProvider === "string")
-        store.activeProvider = source.activeProvider;
-    if (typeof source.activeAccountId === "string")
-        store.activeAccountId = source.activeAccountId;
-    if (typeof source.activeEmail === "string")
-        store.activeEmail = source.activeEmail;
-    if (typeof source.lastStatusRefresh === "number" && !Number.isNaN(source.lastStatusRefresh)) {
-        store.lastStatusRefresh = source.lastStatusRefresh;
-    }
-    if (source.account && typeof source.account === "object" && !Array.isArray(source.account)) {
-        const account = source.account;
-        const next = {};
-        if (typeof account.id === "string")
-            next.id = account.id;
-        if (typeof account.email === "string")
-            next.email = account.email;
-        if (typeof account.plan === "string")
-            next.plan = account.plan;
-        if (Object.keys(next).length > 0)
-            store.account = next;
+        return undefined;
+    return input;
+}
+function pickString(input) {
+    return typeof input === "string" && input.length > 0 ? input : undefined;
+}
+function pickNumber(input) {
+    return typeof input === "number" && Number.isFinite(input) ? input : undefined;
+}
+function pickBoolean(input) {
+    return typeof input === "boolean" ? input : undefined;
+}
+function pickUsageWindow(input) {
+    const source = asRecord(input);
+    if (!source)
+        return undefined;
+    const next = {};
+    if (pickNumber(source.entitlement) !== undefined)
+        next.entitlement = pickNumber(source.entitlement);
+    if (pickNumber(source.remaining) !== undefined)
+        next.remaining = pickNumber(source.remaining);
+    if (pickNumber(source.used) !== undefined)
+        next.used = pickNumber(source.used);
+    if (pickNumber(source.resetAt) !== undefined)
+        next.resetAt = pickNumber(source.resetAt);
+    return Object.keys(next).length > 0 ? next : undefined;
+}
+function pickSnapshot(input) {
+    const source = asRecord(input);
+    if (!source)
+        return undefined;
+    const next = {};
+    if (pickString(source.plan))
+        next.plan = pickString(source.plan);
+    const usage5h = pickUsageWindow(source.usage5h);
+    if (usage5h)
+        next.usage5h = usage5h;
+    const usageWeek = pickUsageWindow(source.usageWeek);
+    if (usageWeek)
+        next.usageWeek = usageWeek;
+    if (pickNumber(source.updatedAt) !== undefined)
+        next.updatedAt = pickNumber(source.updatedAt);
+    if (pickString(source.error))
+        next.error = pickString(source.error);
+    return Object.keys(next).length > 0 ? next : undefined;
+}
+function pickEntry(input) {
+    const source = asRecord(input);
+    if (!source)
+        return undefined;
+    const next = {};
+    if (pickString(source.name))
+        next.name = pickString(source.name);
+    if (pickString(source.providerId))
+        next.providerId = pickString(source.providerId);
+    if (pickString(source.refresh))
+        next.refresh = pickString(source.refresh);
+    if (pickString(source.access))
+        next.access = pickString(source.access);
+    if (pickNumber(source.expires) !== undefined)
+        next.expires = pickNumber(source.expires);
+    if (pickString(source.accountId))
+        next.accountId = pickString(source.accountId);
+    if (pickString(source.email))
+        next.email = pickString(source.email);
+    if (pickNumber(source.addedAt) !== undefined)
+        next.addedAt = pickNumber(source.addedAt);
+    if (pickNumber(source.lastUsed) !== undefined)
+        next.lastUsed = pickNumber(source.lastUsed);
+    if (pickString(source.source))
+        next.source = pickString(source.source);
+    const snapshot = pickSnapshot(source.snapshot);
+    if (snapshot)
+        next.snapshot = snapshot;
+    return next;
+}
+function pickActiveAccountNames(input, accounts) {
+    if (!Array.isArray(input))
+        return undefined;
+    const seen = new Set();
+    const next = [];
+    for (const item of input) {
+        const name = pickString(item);
+        if (!name || seen.has(name) || !accounts[name])
+            continue;
+        seen.add(name);
+        next.push(name);
     }
-    if (source.status && typeof source.status === "object" && !Array.isArray(source.status)) {
-        const status = source.status;
-        if (status.premium && typeof status.premium === "object" && !Array.isArray(status.premium)) {
-            const premium = status.premium;
-            const nextPremium = {};
-            if (typeof premium.entitlement === "number" && !Number.isNaN(premium.entitlement)) {
-                nextPremium.entitlement = premium.entitlement;
-            }
-            if (typeof premium.remaining === "number" && !Number.isNaN(premium.remaining)) {
-                nextPremium.remaining = premium.remaining;
-            }
-            if (Object.keys(nextPremium).length > 0)
-                store.status = { premium: nextPremium };
+    return next.length > 0 ? next : undefined;
+}
+function normalizeNewStore(source) {
+    const accounts = {};
+    const sourceAccounts = asRecord(source.accounts);
+    if (sourceAccounts) {
+        for (const [name, value] of Object.entries(sourceAccounts)) {
+            const entry = pickEntry(value);
+            if (!entry)
+                continue;
+            accounts[name] = {
+                ...entry,
+                ...(entry.name ? {} : { name }),
+            };
         }
     }
+    const store = { accounts };
+    const active = pickString(source.active);
+    if (active && accounts[active])
+        store.active = active;
+    const activeNames = pickActiveAccountNames(source.activeAccountNames, accounts);
+    if (activeNames)
+        store.activeAccountNames = activeNames;
+    if (pickBoolean(source.autoRefresh) !== undefined)
+        store.autoRefresh = pickBoolean(source.autoRefresh);
+    if (pickNumber(source.refreshMinutes) !== undefined)
+        store.refreshMinutes = pickNumber(source.refreshMinutes);
+    if (pickNumber(source.lastSnapshotRefresh) !== undefined)
+        store.lastSnapshotRefresh = pickNumber(source.lastSnapshotRefresh);
+    if (pickBoolean(source.bootstrapAuthImportTried) !== undefined) {
+        store.bootstrapAuthImportTried = pickBoolean(source.bootstrapAuthImportTried);
+    }
+    if (pickNumber(source.bootstrapAuthImportAt) !== undefined) {
+        store.bootstrapAuthImportAt = pickNumber(source.bootstrapAuthImportAt);
+    }
     return store;
 }
+function normalizeLegacyStore(source) {
+    const legacyAccount = asRecord(source.account);
+    const legacyStatus = asRecord(source.status);
+    const legacyPremium = asRecord(legacyStatus?.premium);
+    const accountId = pickString(source.activeAccountId) ?? pickString(legacyAccount?.id);
+    const email = pickString(source.activeEmail) ?? pickString(legacyAccount?.email);
+    const plan = pickString(legacyAccount?.plan);
+    const entitlement = pickNumber(legacyPremium?.entitlement);
+    const remaining = pickNumber(legacyPremium?.remaining);
+    const updatedAt = pickNumber(source.lastStatusRefresh);
+    const hasLegacy = Boolean(accountId
+        || email
+        || plan
+        || entitlement !== undefined
+        || remaining !== undefined);
+    const store = {
+        accounts: {},
+    };
+    if (pickBoolean(source.bootstrapAuthImportTried) !== undefined) {
+        store.bootstrapAuthImportTried = pickBoolean(source.bootstrapAuthImportTried);
+    }
+    if (pickNumber(source.bootstrapAuthImportAt) !== undefined) {
+        store.bootstrapAuthImportAt = pickNumber(source.bootstrapAuthImportAt);
+    }
+    if (updatedAt !== undefined)
+        store.lastSnapshotRefresh = updatedAt;
+    if (!hasLegacy)
+        return store;
+    const name = accountId ?? email ?? "default";
+    const snapshot = {};
+    if (plan)
+        snapshot.plan = plan;
+    if (entitlement !== undefined || remaining !== undefined) {
+        snapshot.usage5h = {
+            ...(entitlement !== undefined ? { entitlement } : {}),
+            ...(remaining !== undefined ? { remaining } : {}),
+        };
+    }
+    if (updatedAt !== undefined)
+        snapshot.updatedAt = updatedAt;
+    store.accounts[name] = {
+        name,
+        providerId: "codex",
+        ...(accountId ? { accountId } : {}),
+        ...(email ? { email } : {}),
+        ...(Object.keys(snapshot).length > 0 ? { snapshot } : {}),
+    };
+    store.active = name;
+    return store;
+}
+function mergeLegacyIntoStore(store, source) {
+    const legacy = normalizeLegacyStore(source);
+    if (Object.keys(legacy.accounts).length === 0) {
+        return {
+            ...store,
+            lastSnapshotRefresh: store.lastSnapshotRefresh ?? legacy.lastSnapshotRefresh,
+            ...(legacy.bootstrapAuthImportTried !== undefined ? { bootstrapAuthImportTried: legacy.bootstrapAuthImportTried } : {}),
+            ...(legacy.bootstrapAuthImportAt !== undefined ? { bootstrapAuthImportAt: legacy.bootstrapAuthImportAt } : {}),
+        };
+    }
+    if (Object.keys(store.accounts).length > 0) {
+        return {
+            ...store,
+            lastSnapshotRefresh: store.lastSnapshotRefresh ?? legacy.lastSnapshotRefresh,
+            bootstrapAuthImportTried: store.bootstrapAuthImportTried ?? legacy.bootstrapAuthImportTried,
+            bootstrapAuthImportAt: store.bootstrapAuthImportAt ?? legacy.bootstrapAuthImportAt,
+        };
+    }
+    return {
+        ...legacy,
+        ...store,
+        accounts: {
+            ...legacy.accounts,
+            ...store.accounts,
+        },
+        active: store.active ?? legacy.active,
+        activeAccountNames: store.activeAccountNames ?? legacy.activeAccountNames,
+        autoRefresh: store.autoRefresh ?? legacy.autoRefresh,
+        refreshMinutes: store.refreshMinutes ?? legacy.refreshMinutes,
+        lastSnapshotRefresh: store.lastSnapshotRefresh ?? legacy.lastSnapshotRefresh,
+        bootstrapAuthImportTried: store.bootstrapAuthImportTried ?? legacy.bootstrapAuthImportTried,
+        bootstrapAuthImportAt: store.bootstrapAuthImportAt ?? legacy.bootstrapAuthImportAt,
+    };
+}
+export function normalizeCodexStore(input) {
+    const source = asRecord(input);
+    if (!source)
+        return { accounts: {} };
+    if (source.accounts && asRecord(source.accounts)) {
+        return mergeLegacyIntoStore(normalizeNewStore(source), source);
+    }
+    return normalizeLegacyStore(source);
+}
 export function parseCodexStore(raw) {
     const parsed = raw ? JSON.parse(raw) : {};
-    return pickCodexStore(parsed);
+    return normalizeCodexStore(parsed);
+}
+export function getActiveCodexAccount(store) {
+    if (store.active && store.accounts[store.active]) {
+        return {
+            name: store.active,
+            entry: store.accounts[store.active],
+        };
+    }
+    const first = Object.entries(store.accounts)[0];
+    if (!first)
+        return undefined;
+    return {
+        name: first[0],
+        entry: first[1],
+    };
 }
 export function codexStorePath() {
     const base = xdgConfig ?? path.join(os.homedir(), ".config");
@@ -64,7 +256,7 @@ export async function readCodexStore(filePath = codexStorePath()) {
 }
 export async function writeCodexStore(store, options) {
     const file = options?.filePath ?? codexStorePath();
-    const next = pickCodexStore(store);
+    const next = normalizeCodexStore(store);
     await fs.mkdir(path.dirname(file), { recursive: true });
     await fs.writeFile(file, JSON.stringify(next, null, 2), { mode: 0o600 });
 }

package/dist/menu-runtime.d.ts

@@ -0,0 +1,69 @@
+type WriteMeta = {
+    reason: string;
+    source: string;
+    actionType?: string;
+};
+export type MenuAccountInfo = {
+    id?: string;
+    name: string;
+    index: number;
+    isCurrent?: boolean;
+};
+export type MenuActionAccount = {
+    id?: string;
+    name: string;
+};
+type SharedActionResult = boolean | {
+    changed: boolean;
+    persistHandled?: boolean;
+};
+export type MenuAction = {
+    type: "add";
+} | {
+    type: "cancel";
+} | {
+    type: "remove";
+    account: MenuActionAccount;
+} | {
+    type: "remove-all";
+} | {
+    type: "switch";
+    account: MenuActionAccount;
+} | {
+    type: "provider";
+    name: string;
+    payload?: unknown;
+};
+export type ProviderMenuAdapter<TStore, TEntry> = {
+    key: string;
+    loadStore: () => Promise<TStore>;
+    writeStore: (store: TStore, meta: WriteMeta) => Promise<void>;
+    bootstrapAuthImport: (store: TStore) => Promise<boolean>;
+    authorizeNewAccount: (store: TStore) => Promise<TEntry | undefined>;
+    refreshSnapshots: (store: TStore) => Promise<void>;
+    toMenuInfo: (store: TStore) => Promise<MenuAccountInfo[]>;
+    getCurrentEntry: (store: TStore) => TEntry | undefined;
+    getRefreshConfig: (store: TStore) => {
+        enabled: boolean;
+        minutes: number;
+    };
+    getAccountByName: (store: TStore, name: string) => {
+        name: string;
+        entry: TEntry;
+    } | undefined;
+    addAccount?: (store: TStore, entry: TEntry) => Promise<SharedActionResult> | SharedActionResult;
+    removeAccount?: (store: TStore, name: string) => Promise<SharedActionResult> | SharedActionResult;
+    removeAllAccounts?: (store: TStore) => Promise<SharedActionResult> | SharedActionResult;
+    switchAccount: (store: TStore, name: string, entry: TEntry) => Promise<{
+        persistHandled?: boolean;
+    } | void>;
+    applyAction?: (store: TStore, action: Extract<MenuAction, {
+        type: "provider";
+    }>) => Promise<boolean>;
+};
+export declare function runProviderMenu<TStore, TEntry>(input: {
+    adapter: ProviderMenuAdapter<TStore, TEntry>;
+    showMenu: (accounts: MenuAccountInfo[], store: TStore) => Promise<MenuAction>;
+    now?: () => number;
+}): Promise<TEntry | undefined>;
+export {};

package/dist/menu-runtime.js

@@ -0,0 +1,108 @@
+function parseSharedActionResult(result) {
+    if (typeof result === "object" && result) {
+        return {
+            changed: result.changed === true,
+            persistHandled: result.persistHandled === true,
+        };
+    }
+    return {
+        changed: result === true,
+        persistHandled: false,
+    };
+}
+export async function runProviderMenu(input) {
+    const now = input.now ?? Date.now;
+    const store = await input.adapter.loadStore();
+    if (await input.adapter.bootstrapAuthImport(store)) {
+        await input.adapter.writeStore(store, {
+            reason: "bootstrap-auth-import",
+            source: "menu-runtime",
+            actionType: "bootstrap-auth-import",
+        });
+    }
+    let nextRefreshAt = 0;
+    while (true) {
+        const refresh = input.adapter.getRefreshConfig(store);
+        if (refresh.enabled && now() >= nextRefreshAt) {
+            await input.adapter.refreshSnapshots(store);
+            await input.adapter.writeStore(store, {
+                reason: "auto-refresh",
+                source: "menu-runtime",
+                actionType: "auto-refresh",
+            });
+            nextRefreshAt = now() + refresh.minutes * 60_000;
+        }
+        const accounts = await input.adapter.toMenuInfo(store);
+        const action = await input.showMenu(accounts, store);
+        if (action.type === "cancel")
+            return input.adapter.getCurrentEntry(store);
+        if (action.type === "add") {
+            const entry = await input.adapter.authorizeNewAccount(store);
+            const result = !entry ? undefined : await input.adapter.addAccount?.(store, entry);
+            const parsed = parseSharedActionResult(result);
+            if (!entry || !parsed.changed)
+                continue;
+            if (!parsed.persistHandled) {
+                await input.adapter.writeStore(store, {
+                    reason: "add-account",
+                    source: "menu-runtime",
+                    actionType: "add",
+                });
+            }
+            continue;
+        }
+        if (action.type === "remove-all") {
+            const result = await input.adapter.removeAllAccounts?.(store);
+            const parsed = parseSharedActionResult(result);
+            if (!parsed.changed)
+                continue;
+            if (!parsed.persistHandled) {
+                await input.adapter.writeStore(store, {
+                    reason: "remove-all",
+                    source: "menu-runtime",
+                    actionType: "remove-all",
+                });
+            }
+            continue;
+        }
+        if (action.type === "remove") {
+            const accountName = action.account.id ?? action.account.name;
+            const result = await input.adapter.removeAccount?.(store, accountName);
+            const parsed = parseSharedActionResult(result);
+            if (!parsed.changed)
+                continue;
+            if (!parsed.persistHandled) {
+                await input.adapter.writeStore(store, {
+                    reason: "remove-account",
+                    source: "menu-runtime",
+                    actionType: "remove",
+                });
+            }
+            continue;
+        }
+        if (action.type === "switch") {
+            const accountName = action.account.id ?? action.account.name;
+            const selected = input.adapter.getAccountByName(store, accountName);
+            if (!selected)
+                continue;
+            const switchResult = await input.adapter.switchAccount(store, selected.name, selected.entry);
+            if (!switchResult?.persistHandled) {
+                await input.adapter.writeStore(store, {
+                    reason: "persist-account-switch",
+                    source: "menu-runtime",
+                    actionType: "switch",
+                });
+            }
+            continue;
+        }
+        if (!input.adapter.applyAction)
+            continue;
+        if (!await input.adapter.applyAction(store, action))
+            continue;
+        await input.adapter.writeStore(store, {
+            reason: `provider-action:${action.name}`,
+            source: "menu-runtime",
+            actionType: action.name,
+        });
+    }
+}