opencode-openai-account-switcher 0.1.0

package/dist/codex-status-fetcher.js

@@ -0,0 +1,300 @@
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/codex/usage";
+const CODEX_USAGE_TIMEOUT_MS = 15_000;
+function isInvalidAccountRefreshError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const value = error;
+    return value.kind === "invalid_account"
+        && value.status === 400
+        && typeof value.message === "string"
+        && value.message.length > 0;
+}
+function readErrorStatus(error) {
+    if (!error || typeof error !== "object")
+        return undefined;
+    const value = error.status;
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function readErrorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === "string")
+        return error;
+    if (error && typeof error === "object") {
+        const message = error.message;
+        if (typeof message === "string" && message.length > 0)
+            return message;
+    }
+    return String(error);
+}
+function mapRefreshTokenError(error) {
+    if (isInvalidAccountRefreshError(error))
+        return error;
+    const message = readErrorMessage(error);
+    const status = readErrorStatus(error);
+    const hasRefresh400Message = /refresh/i.test(message) && /\b400\b/.test(message);
+    if (status === 400 || hasRefresh400Message) {
+        return {
+            kind: "invalid_account",
+            status: 400,
+            message,
+        };
+    }
+    return {
+        kind: "network_error",
+        message,
+    };
+}
+function asRecord(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return undefined;
+    return input;
+}
+function readString(input) {
+    return typeof input === "string" && input.length > 0 ? input : undefined;
+}
+function readNumber(input) {
+    return typeof input === "number" && Number.isFinite(input) ? input : undefined;
+}
+function readTimestamp(input) {
+    const value = readNumber(input);
+    if (value === undefined)
+        return undefined;
+    return value >= 1e12 ? value : value * 1000;
+}
+function pickRecord(source, keys) {
+    for (const key of keys) {
+        const value = asRecord(source[key]);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function pickWindow(source, key) {
+    const rateLimit = pickRecord(source, ["rate_limit", "rateLimit"]);
+    const rateLimitKey = key === "primary" ? "primary_window" : "secondary_window";
+    const rateLimitWindow = rateLimit ? asRecord(rateLimit[rateLimitKey]) : undefined;
+    const windows = pickRecord(source, ["windows", "usage_windows", "quota_windows"]);
+    const block = windows ? asRecord(windows[key]) : undefined;
+    const fallback = asRecord(source[key]);
+    const raw = rateLimitWindow ?? block ?? fallback;
+    if (!raw) {
+        return {
+            entitlement: undefined,
+            remaining: undefined,
+            used: undefined,
+            resetAt: undefined,
+        };
+    }
+    const entitlement = readNumber(raw.entitlement);
+    const remainingPercent = readNumber(raw.remaining_percent);
+    const usedPercent = readNumber(raw.used_percent);
+    const remaining = readNumber(raw.remaining) ?? remainingPercent;
+    const used = readNumber(raw.used) ?? usedPercent;
+    const percentBased = remainingPercent !== undefined || usedPercent !== undefined;
+    return {
+        entitlement: entitlement ?? (percentBased ? 100 : undefined),
+        remaining: remaining ?? (used !== undefined ? Math.max(0, 100 - used) : undefined),
+        used,
+        resetAt: readTimestamp(raw.resetAt ?? raw.reset_at),
+    };
+}
+function normalizeUsageStatus(payload, now) {
+    const source = asRecord(payload) ?? {};
+    const account = pickRecord(source, ["account", "identity", "user"]) ?? {};
+    const credits = pickRecord(source, ["credits", "credit_balance", "credit"]) ?? {};
+    return {
+        identity: {
+            accountId: readString(account.id) ?? readString(source.account_id) ?? readString(source.accountId),
+            email: readString(account.email) ?? readString(source.email),
+            plan: readString(account.plan) ?? readString(source.plan) ?? readString(source.plan_type),
+        },
+        windows: {
+            primary: pickWindow(source, "primary"),
+            secondary: pickWindow(source, "secondary"),
+        },
+        credits: {
+            total: readNumber(credits.total),
+            remaining: readNumber(credits.remaining),
+            used: readNumber(credits.used),
+        },
+        updatedAt: now(),
+    };
+}
+async function parseJsonResponse(response) {
+    const contentType = response.headers.get("content-type") ?? "";
+    if (!contentType.toLowerCase().includes("application/json"))
+        return undefined;
+    try {
+        return await response.json();
+    }
+    catch {
+        return undefined;
+    }
+}
+function isTimeoutError(error) {
+    if (!error || typeof error !== "object")
+        return false;
+    const err = error;
+    if (err.name === "AbortError")
+        return true;
+    const message = typeof err.message === "string" ? err.message.toLowerCase() : "";
+    return message.includes("timeout");
+}
+function buildHeaders(input) {
+    const headers = new Headers({
+        Accept: "application/json",
+        "User-Agent": "Codex CLI",
+    });
+    if (input.access)
+        headers.set("Authorization", `Bearer ${input.access}`);
+    if (input.accountId)
+        headers.set("ChatGPT-Account-Id", input.accountId);
+    return headers;
+}
+async function requestUsage(input) {
+    return input.fetchImpl(CODEX_USAGE_URL, {
+        method: "GET",
+        headers: buildHeaders({
+            access: input.oauth.access,
+            accountId: input.accountId,
+        }),
+        signal: input.signal,
+    });
+}
+export async function fetchCodexStatus(input) {
+    const fetchImpl = input.fetchImpl ?? globalThis.fetch;
+    const now = input.now ?? Date.now;
+    const explicitAccountId = input.accountId;
+    const timeoutMs = input.timeoutMs ?? CODEX_USAGE_TIMEOUT_MS;
+    let oauth = input.oauth;
+    let authPatch;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        let response;
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            response = await requestUsage({
+                oauth,
+                accountId: explicitAccountId ?? oauth.accountId,
+                fetchImpl,
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            clearTimeout(timeout);
+            if (isTimeoutError(error)) {
+                return {
+                    ok: false,
+                    error: {
+                        kind: "timeout",
+                        message: "codex usage request timed out",
+                    },
+                };
+            }
+            return {
+                ok: false,
+                error: {
+                    kind: "network_error",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+        if (response.status === 401 && attempt === 0 && input.refreshTokens) {
+            let refreshed;
+            try {
+                refreshed = await input.refreshTokens(oauth);
+            }
+            catch (error) {
+                const mappedError = mapRefreshTokenError(error);
+                return {
+                    ok: false,
+                    error: mappedError,
+                };
+            }
+            if (!refreshed || !refreshed.access) {
+                return {
+                    ok: false,
+                    error: {
+                        kind: "unauthorized",
+                        status: 401,
+                        message: "codex usage request unauthorized",
+                    },
+                };
+            }
+            oauth = refreshed;
+            authPatch = {
+                access: refreshed.access,
+                refresh: refreshed.refresh,
+                expires: refreshed.expires,
+                accountId: refreshed.accountId,
+            };
+            continue;
+        }
+        if (response.status === 429) {
+            return {
+                ok: false,
+                error: {
+                    kind: "rate_limited",
+                    status: 429,
+                    message: "codex usage request was rate limited",
+                },
+            };
+        }
+        if (response.status >= 500 && response.status <= 599) {
+            return {
+                ok: false,
+                error: {
+                    kind: "server_error",
+                    status: response.status,
+                    message: "codex usage request failed with server error",
+                },
+            };
+        }
+        if (response.status === 401) {
+            return {
+                ok: false,
+                error: {
+                    kind: "unauthorized",
+                    status: 401,
+                    message: "codex usage request unauthorized",
+                },
+            };
+        }
+        if (!response.ok) {
+            return {
+                ok: false,
+                error: {
+                    kind: "network_error",
+                    message: `codex usage request failed with status ${response.status}`,
+                },
+            };
+        }
+        const payload = await parseJsonResponse(response);
+        if (payload === undefined) {
+            return {
+                ok: false,
+                error: {
+                    kind: "invalid_response",
+                    message: "codex usage response was not json",
+                },
+            };
+        }
+        return {
+            ok: true,
+            status: normalizeUsageStatus(payload, now),
+            ...(authPatch ? { authPatch } : {}),
+        };
+    }
+    return {
+        ok: false,
+        error: {
+            kind: "unauthorized",
+            status: 401,
+            message: "codex usage request unauthorized",
+        },
+    };
+}

package/dist/codex-store.d.ts

@@ -0,0 +1,49 @@
+type CodexUsageWindow = {
+    entitlement?: number;
+    remaining?: number;
+    used?: number;
+    resetAt?: number;
+};
+export type CodexAccountSnapshot = {
+    plan?: string;
+    usage5h?: CodexUsageWindow;
+    usageWeek?: CodexUsageWindow;
+    updatedAt?: number;
+    error?: string;
+};
+export type CodexAccountEntry = {
+    name?: string;
+    providerId?: string;
+    workspaceName?: string;
+    refresh?: string;
+    access?: string;
+    expires?: number;
+    accountId?: string;
+    email?: string;
+    addedAt?: number;
+    lastUsed?: number;
+    source?: string;
+    snapshot?: CodexAccountSnapshot;
+};
+export type CodexStoreFile = {
+    accounts: Record<string, CodexAccountEntry>;
+    active?: string;
+    activeAccountNames?: string[];
+    autoRefresh?: boolean;
+    refreshMinutes?: number;
+    lastSnapshotRefresh?: number;
+    bootstrapAuthImportTried?: boolean;
+    bootstrapAuthImportAt?: number;
+};
+export declare function normalizeCodexStore(input: unknown): CodexStoreFile;
+export declare function parseCodexStore(raw: string): CodexStoreFile;
+export declare function getActiveCodexAccount(store: CodexStoreFile): {
+    name: string;
+    entry: CodexAccountEntry;
+} | undefined;
+export declare function codexStorePath(): string;
+export declare function readCodexStore(filePath?: string): Promise<CodexStoreFile>;
+export declare function writeCodexStore(store: CodexStoreFile, options?: {
+    filePath?: string;
+}): Promise<void>;
+export {};

package/dist/codex-store.js

@@ -0,0 +1,267 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { codexAccountsPath, legacyCodexStorePath } from "./store-paths.js";
+function asRecord(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        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.workspaceName))
+        next.workspaceName = pickString(source.workspaceName);
+    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);
+    }
+    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 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() {
+    return codexAccountsPath();
+}
+export async function readCodexStore(filePath = codexStorePath()) {
+    const raw = await fs.readFile(filePath, "utf8").catch(async (error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+        if (filePath !== codexStorePath())
+            return "";
+        return fs.readFile(legacyCodexStorePath(), "utf8").catch((legacyError) => {
+            if (legacyError.code === "ENOENT")
+                return "";
+            throw legacyError;
+        });
+    });
+    return parseCodexStore(raw);
+}
+export async function writeCodexStore(store, options) {
+    const file = options?.filePath ?? codexStorePath();
+    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/common-settings-actions.d.ts

@@ -0,0 +1,15 @@
+import type { CommonSettingsStore } from "./common-settings-store.js";
+export type CommonSettingsActionType = "toggle-experimental-slash-commands" | "toggle-network-retry";
+type WriteMeta = {
+    reason?: string;
+    source?: string;
+    actionType?: string;
+};
+export declare function applyCommonSettingsAction(input: {
+    action: {
+        type: CommonSettingsActionType;
+    };
+    readSettings: () => Promise<CommonSettingsStore>;
+    writeSettings: (settings: CommonSettingsStore, meta?: WriteMeta) => Promise<void>;
+}): Promise<boolean>;
+export {};

package/dist/common-settings-actions.js

@@ -0,0 +1,22 @@
+export async function applyCommonSettingsAction(input) {
+    const settings = await input.readSettings();
+    if (input.action.type === "toggle-experimental-slash-commands") {
+        settings.experimentalSlashCommandsEnabled = settings.experimentalSlashCommandsEnabled !== true;
+        await input.writeSettings(settings, {
+            reason: "toggle-experimental-slash-commands",
+            source: "applyCommonSettingsAction",
+            actionType: "toggle-experimental-slash-commands",
+        });
+        return true;
+    }
+    if (input.action.type === "toggle-network-retry") {
+        settings.networkRetryEnabled = settings.networkRetryEnabled !== true;
+        await input.writeSettings(settings, {
+            reason: "toggle-network-retry",
+            source: "applyCommonSettingsAction",
+            actionType: "toggle-network-retry",
+        });
+        return true;
+    }
+    return false;
+}

package/dist/common-settings-store.d.ts

@@ -0,0 +1,17 @@
+export type CommonSettingsStore = {
+    networkRetryEnabled?: boolean;
+    experimentalSlashCommandsEnabled?: boolean;
+    experimentalStatusSlashCommandEnabled?: boolean;
+};
+export declare function normalizeCommonSettingsStore(input: CommonSettingsStore | undefined): CommonSettingsStore;
+export declare function parseCommonSettingsStore(raw: string): CommonSettingsStore;
+export declare function commonSettingsPath(): string;
+export declare function readCommonSettingsStore(options?: {
+    filePath?: string;
+}): Promise<CommonSettingsStore>;
+export declare function readCommonSettingsStoreSync(options?: {
+    filePath?: string;
+}): CommonSettingsStore | undefined;
+export declare function writeCommonSettingsStore(store: CommonSettingsStore, options?: {
+    filePath?: string;
+}): Promise<void>;