opencode-copilot-account-switcher 0.11.0 → 0.12.0

package/dist/codex-auth-source.d.ts

@@ -0,0 +1,16 @@
+export type OpenAIOAuthAuth = {
+    type: "oauth";
+    refresh?: string;
+    access?: string;
+    expires?: number;
+    accountId?: string;
+};
+export type CodexAuthSource = {
+    providerId: "openai";
+    oauth: OpenAIOAuthAuth;
+    accountId?: string;
+    suggestedWriteBack?: {
+        accountId: string;
+    };
+};
+export declare function resolveCodexAuthSource(auth: unknown): CodexAuthSource | undefined;

package/dist/codex-auth-source.js

@@ -0,0 +1,63 @@
+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 decodeJwtPayload(token) {
+    const parts = token.split(".");
+    if (parts.length < 2)
+        return undefined;
+    const payloadPart = parts[1];
+    if (!payloadPart)
+        return undefined;
+    try {
+        const json = Buffer.from(payloadPart, "base64url").toString("utf8");
+        return asRecord(JSON.parse(json));
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractAccountIdFromClaims(access) {
+    if (!access)
+        return undefined;
+    const claims = decodeJwtPayload(access);
+    if (!claims)
+        return undefined;
+    return readString(claims.accountId) ?? readString(claims.account_id);
+}
+export function resolveCodexAuthSource(auth) {
+    const authRecord = asRecord(auth);
+    if (!authRecord)
+        return undefined;
+    const openai = asRecord(authRecord.openai);
+    if (!openai || openai.type !== "oauth")
+        return undefined;
+    const oauth = openai;
+    const directAccountId = readString(oauth.accountId);
+    if (directAccountId) {
+        return {
+            providerId: "openai",
+            oauth,
+            accountId: directAccountId,
+        };
+    }
+    const accountIdFromClaims = extractAccountIdFromClaims(readString(oauth.access));
+    if (!accountIdFromClaims) {
+        return {
+            providerId: "openai",
+            oauth,
+        };
+    }
+    return {
+        providerId: "openai",
+        oauth,
+        accountId: accountIdFromClaims,
+        suggestedWriteBack: {
+            accountId: accountIdFromClaims,
+        },
+    };
+}

package/dist/codex-status-command.d.ts

@@ -0,0 +1,53 @@
+import { type OpenAIOAuthAuth } from "./codex-auth-source.js";
+import { type CodexStatusFetcherResult } from "./codex-status-fetcher.js";
+import { type CodexStoreFile } from "./codex-store.js";
+type ToastVariant = "info" | "success" | "warning" | "error";
+type ToastClient = {
+    tui?: {
+        showToast?: (options: {
+            body: {
+                message: string;
+                variant: ToastVariant;
+            };
+            query?: undefined;
+        }) => Promise<unknown>;
+    };
+    auth?: {
+        get?: (input: {
+            path: {
+                id: string;
+            };
+            throwOnError?: boolean;
+        }) => Promise<unknown>;
+        set?: (input: {
+            path: {
+                id: string;
+            };
+            body: {
+                type: "oauth";
+                refresh?: string;
+                access?: string;
+                expires?: number;
+                accountId?: string;
+            };
+        }) => Promise<unknown>;
+    };
+};
+type AuthPayload = {
+    openai?: OpenAIOAuthAuth;
+} & Record<string, unknown>;
+export declare class CodexStatusCommandHandledError extends Error {
+    constructor();
+}
+export declare function handleCodexStatusCommand(input: {
+    client?: ToastClient;
+    loadAuth?: () => Promise<AuthPayload | undefined>;
+    persistAuth?: (auth: AuthPayload) => Promise<void>;
+    fetchStatus?: (input: {
+        oauth: OpenAIOAuthAuth;
+        accountId?: string;
+    }) => Promise<CodexStatusFetcherResult>;
+    readStore?: () => Promise<CodexStoreFile>;
+    writeStore?: (store: CodexStoreFile) => Promise<void>;
+}): Promise<never>;
+export {};

package/dist/codex-status-command.js

@@ -0,0 +1,215 @@
+import { resolveCodexAuthSource } from "./codex-auth-source.js";
+import { fetchCodexStatus } from "./codex-status-fetcher.js";
+import { readCodexStore, writeCodexStore } from "./codex-store.js";
+export class CodexStatusCommandHandledError extends Error {
+    constructor() {
+        super("codex-status-command-handled");
+        this.name = "CodexStatusCommandHandledError";
+    }
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function pickString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function pickNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+async function showToast(input) {
+    const show = input.client?.tui?.showToast;
+    if (!show)
+        return;
+    try {
+        await show({
+            body: {
+                message: input.message,
+                variant: input.variant,
+            },
+        });
+    }
+    catch {
+        // fail open for toast dispatch
+    }
+}
+function ratio(remaining, entitlement) {
+    if (remaining === undefined && entitlement === undefined)
+        return "n/a";
+    return `${remaining ?? "n/a"}/${entitlement ?? "n/a"}`;
+}
+function value(value) {
+    return value === undefined ? "n/a" : String(value);
+}
+function renderStatus(status) {
+    return [
+        "Codex status updated.",
+        "[identity]",
+        `account: ${value(status.identity.accountId)}`,
+        `email: ${value(status.identity.email)}`,
+        `plan: ${value(status.identity.plan)}`,
+        "[usage]",
+        `primary: ${ratio(status.windows.primary.remaining, status.windows.primary.entitlement)}`,
+        `secondary: ${ratio(status.windows.secondary.remaining, status.windows.secondary.entitlement)}`,
+        `credits: ${ratio(status.credits.remaining, status.credits.total)}`,
+    ].join("\n");
+}
+function renderCachedStatus(store) {
+    return [
+        "[identity]",
+        `account: ${value(store.account?.id ?? store.activeAccountId)}`,
+        `email: ${value(store.account?.email ?? store.activeEmail)}`,
+        `plan: ${value(store.account?.plan)}`,
+        "[usage]",
+        `primary: ${ratio(store.status?.premium?.remaining, store.status?.premium?.entitlement)}`,
+        "secondary: n/a",
+        "credits: n/a",
+    ].join("\n");
+}
+function hasCachedStore(store) {
+    return Boolean(store.activeAccountId
+        || store.activeEmail
+        || store.account?.id
+        || store.account?.email
+        || store.account?.plan
+        || store.status?.premium?.entitlement !== undefined
+        || store.status?.premium?.remaining !== undefined);
+}
+async function defaultLoadAuth(client) {
+    const getAuth = client?.auth?.get;
+    if (!getAuth)
+        return undefined;
+    try {
+        const result = await getAuth({ path: { id: "openai" }, throwOnError: true });
+        const withData = asRecord(result)?.data;
+        const payload = asRecord(withData) ?? asRecord(result);
+        if (!payload)
+            return undefined;
+        return {
+            openai: payload,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function defaultPersistAuth(client, auth) {
+    const setAuth = client?.auth?.set;
+    if (!setAuth)
+        return;
+    const openai = asRecord(auth.openai);
+    if (!openai)
+        return;
+    await setAuth({
+        path: { id: "openai" },
+        body: {
+            type: "oauth",
+            refresh: pickString(openai.refresh),
+            access: pickString(openai.access),
+            expires: pickNumber(openai.expires),
+            accountId: pickString(openai.accountId),
+        },
+    });
+}
+function patchAuth(auth, patch) {
+    const base = asRecord(auth) ?? {};
+    const openai = asRecord(base.openai) ?? { type: "oauth" };
+    return {
+        ...base,
+        openai: {
+            ...openai,
+            type: "oauth",
+            ...(patch.access !== undefined ? { access: patch.access } : {}),
+            ...(patch.refresh !== undefined ? { refresh: patch.refresh } : {}),
+            ...(patch.expires !== undefined ? { expires: patch.expires } : {}),
+            ...(patch.accountId !== undefined ? { accountId: patch.accountId } : {}),
+        },
+    };
+}
+export async function handleCodexStatusCommand(input) {
+    const loadAuth = input.loadAuth ?? (() => defaultLoadAuth(input.client));
+    const persistAuth = input.persistAuth ?? ((nextAuth) => defaultPersistAuth(input.client, nextAuth));
+    const fetchStatus = input.fetchStatus ?? ((next) => fetchCodexStatus(next));
+    const readStore = input.readStore ?? (() => readCodexStore());
+    const writeStore = input.writeStore ?? ((store) => writeCodexStore(store));
+    await showToast({
+        client: input.client,
+        message: "Fetching Codex status...",
+        variant: "info",
+    });
+    const auth = await loadAuth().catch(() => undefined);
+    const source = resolveCodexAuthSource(auth);
+    if (!source) {
+        await showToast({
+            client: input.client,
+            message: "OpenAI OAuth auth is missing for Codex status.",
+            variant: "error",
+        });
+        throw new CodexStatusCommandHandledError();
+    }
+    const fetched = await fetchStatus({
+        oauth: source.oauth,
+        accountId: source.accountId,
+    }).catch((error) => ({
+        ok: false,
+        error: {
+            kind: "network_error",
+            message: error instanceof Error ? error.message : String(error),
+        },
+    }));
+    if (!fetched.ok) {
+        const cached = await readStore().catch(() => ({}));
+        if (hasCachedStore(cached)) {
+            await showToast({
+                client: input.client,
+                message: `Codex status fetch failed (${fetched.error.message}); showing cached snapshot.\n${renderCachedStatus(cached)}`,
+                variant: "warning",
+            });
+        }
+        else {
+            await showToast({
+                client: input.client,
+                message: `Codex status fetch failed: ${fetched.error.message}`,
+                variant: "error",
+            });
+        }
+        throw new CodexStatusCommandHandledError();
+    }
+    if (fetched.authPatch) {
+        const nextAuth = patchAuth(auth, fetched.authPatch);
+        await persistAuth(nextAuth).catch(async (error) => {
+            await showToast({
+                client: input.client,
+                message: `Codex auth refresh succeeded but auth persistence failed: ${error instanceof Error ? error.message : String(error)}`,
+                variant: "warning",
+            });
+        });
+    }
+    const previousStore = await readStore().catch(() => ({}));
+    const nextStore = {
+        ...previousStore,
+        activeProvider: "codex",
+        activeAccountId: fetched.status.identity.accountId ?? source.accountId ?? previousStore.activeAccountId,
+        activeEmail: fetched.status.identity.email ?? previousStore.activeEmail,
+        lastStatusRefresh: fetched.status.updatedAt,
+        account: {
+            id: fetched.status.identity.accountId ?? previousStore.account?.id,
+            email: fetched.status.identity.email ?? previousStore.account?.email,
+            plan: fetched.status.identity.plan ?? previousStore.account?.plan,
+        },
+        status: {
+            premium: {
+                entitlement: fetched.status.windows.primary.entitlement,
+                remaining: fetched.status.windows.primary.remaining,
+            },
+        },
+    };
+    await writeStore(nextStore);
+    await showToast({
+        client: input.client,
+        message: renderStatus(fetched.status),
+        variant: "success",
+    });
+    throw new CodexStatusCommandHandledError();
+}

package/dist/codex-status-fetcher.d.ts

@@ -0,0 +1,66 @@
+import type { OpenAIOAuthAuth } from "./codex-auth-source.js";
+export type CodexWindowSnapshot = {
+    entitlement?: number;
+    remaining?: number;
+    used?: number;
+    resetAt?: number;
+};
+export type CodexStatusSnapshot = {
+    identity: {
+        accountId?: string;
+        email?: string;
+        plan?: string;
+    };
+    windows: {
+        primary: CodexWindowSnapshot;
+        secondary: CodexWindowSnapshot;
+    };
+    credits: {
+        total?: number;
+        remaining?: number;
+        used?: number;
+    };
+    updatedAt: number;
+};
+export type CodexStatusError = {
+    kind: "rate_limited";
+    status: 429;
+    message: string;
+} | {
+    kind: "timeout";
+    message: string;
+} | {
+    kind: "server_error";
+    status: number;
+    message: string;
+} | {
+    kind: "invalid_response";
+    message: string;
+} | {
+    kind: "unauthorized";
+    status: 401;
+    message: string;
+} | {
+    kind: "network_error";
+    message: string;
+};
+export type CodexStatusFetcherResult = {
+    ok: true;
+    status: CodexStatusSnapshot;
+    authPatch?: {
+        access?: string;
+        refresh?: string;
+        expires?: number;
+        accountId?: string;
+    };
+} | {
+    ok: false;
+    error: CodexStatusError;
+};
+export declare function fetchCodexStatus(input: {
+    oauth: OpenAIOAuthAuth;
+    accountId?: string;
+    fetchImpl?: typeof globalThis.fetch;
+    now?: () => number;
+    refreshTokens?: (oauth: OpenAIOAuthAuth) => Promise<OpenAIOAuthAuth | undefined>;
+}): Promise<CodexStatusFetcherResult>;

package/dist/codex-status-fetcher.js

@@ -0,0 +1,232 @@
+const CODEX_USAGE_URL = "https://chatgpt.com/backend-api/codex/usage";
+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 pickRecord(source, keys) {
+    for (const key of keys) {
+        const value = asRecord(source[key]);
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+function pickWindow(source, key) {
+    const windows = pickRecord(source, ["windows", "usage_windows", "quota_windows"]);
+    const block = windows ? asRecord(windows[key]) : undefined;
+    const fallback = asRecord(source[key]);
+    const raw = block ?? fallback;
+    if (!raw) {
+        return {
+            entitlement: undefined,
+            remaining: undefined,
+            used: undefined,
+            resetAt: undefined,
+        };
+    }
+    return {
+        entitlement: readNumber(raw.entitlement),
+        remaining: readNumber(raw.remaining),
+        used: readNumber(raw.used),
+        resetAt: readNumber(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),
+        },
+        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,
+        }),
+    });
+}
+export async function fetchCodexStatus(input) {
+    const fetchImpl = input.fetchImpl ?? globalThis.fetch;
+    const now = input.now ?? Date.now;
+    const explicitAccountId = input.accountId;
+    let oauth = input.oauth;
+    let authPatch;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        let response;
+        try {
+            response = await requestUsage({
+                oauth,
+                accountId: explicitAccountId ?? oauth.accountId,
+                fetchImpl,
+            });
+        }
+        catch (error) {
+            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),
+                },
+            };
+        }
+        if (response.status === 401 && attempt === 0 && input.refreshTokens) {
+            let refreshed;
+            try {
+                refreshed = await input.refreshTokens(oauth);
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    error: {
+                        kind: "network_error",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                };
+            }
+            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,25 @@
+export type CodexAccountSnapshot = {
+    id?: string;
+    email?: string;
+    plan?: string;
+};
+export type CodexStatusSnapshot = {
+    premium?: {
+        entitlement?: number;
+        remaining?: number;
+    };
+};
+export type CodexStoreFile = {
+    activeProvider?: string;
+    activeAccountId?: string;
+    activeEmail?: string;
+    lastStatusRefresh?: number;
+    account?: CodexAccountSnapshot;
+    status?: CodexStatusSnapshot;
+};
+export declare function parseCodexStore(raw: string): CodexStoreFile;
+export declare function codexStorePath(): string;
+export declare function readCodexStore(filePath?: string): Promise<CodexStoreFile>;
+export declare function writeCodexStore(store: CodexStoreFile, options?: {
+    filePath?: string;
+}): Promise<void>;