opencode-openai-account-switcher 0.1.0

package/dist/providers/registry.js

@@ -0,0 +1,49 @@
+import { createCodexRetryingFetch } from "../codex-network-retry.js";
+import { loadOfficialCodexChatHeaders, loadOfficialCodexConfig, } from "../upstream/codex-loader-adapter.js";
+import { CODEX_PROVIDER_DESCRIPTOR, createCodexProviderDescriptor, } from "./descriptor.js";
+const PROVIDER_DESCRIPTORS = [CODEX_PROVIDER_DESCRIPTOR];
+function hasCapability(descriptor, capability) {
+    return descriptor.capabilities.includes(capability);
+}
+export function listProviderDescriptors() {
+    return [...PROVIDER_DESCRIPTORS];
+}
+export function getProviderDescriptorByKey(key) {
+    return PROVIDER_DESCRIPTORS.find((descriptor) => descriptor.key === key);
+}
+export function getProviderDescriptorByProviderID(providerID) {
+    return PROVIDER_DESCRIPTORS.find((descriptor) => descriptor.providerIDs.includes(providerID));
+}
+export function isProviderIDSupportedByAnyDescriptor(providerID) {
+    return getProviderDescriptorByProviderID(providerID) !== undefined;
+}
+export function createProviderRegistry(input) {
+    const buildCodexPluginHooks = (hookInput) => {
+        const loadOfficialConfig = hasCapability(CODEX_PROVIDER_DESCRIPTOR, "auth")
+            ? (args) => loadOfficialCodexConfig({
+                getAuth: args.getAuth,
+                provider: args.provider,
+                baseFetch: args.baseFetch,
+                version: args.version,
+                client: hookInput.client,
+            })
+            : undefined;
+        return input.buildPluginHooks({
+            ...hookInput,
+            authLoaderMode: hasCapability(CODEX_PROVIDER_DESCRIPTOR, "auth") ? "codex" : "none",
+            enableModelRouting: false,
+            loadOfficialConfig,
+            loadOfficialChatHeaders: hasCapability(CODEX_PROVIDER_DESCRIPTOR, "chat-headers")
+                ? loadOfficialCodexChatHeaders
+                : undefined,
+            createRetryFetch: hasCapability(CODEX_PROVIDER_DESCRIPTOR, "network-retry")
+                ? createCodexRetryingFetch
+                : undefined,
+        });
+    };
+    return {
+        codex: {
+            descriptor: createCodexProviderDescriptor({ buildPluginHooks: buildCodexPluginHooks }),
+        },
+    };
+}

package/dist/retry/codex-policy.d.ts

@@ -0,0 +1,5 @@
+import type { NetworkRetryPolicy } from "../network-retry-engine.js";
+export declare const CODEX_RETRYABLE_MESSAGES: string[];
+export type CodexRetryableErrorGroup = "transport" | "status";
+export declare function isRetryableCodexTransportError(error: unknown): boolean;
+export declare function createCodexRetryPolicy(): NetworkRetryPolicy;

package/dist/retry/codex-policy.js

@@ -0,0 +1,75 @@
+import { createMessageRetryClassifier, isAbortError, isRetryableApiCallError, normalizeRetryableStatusResponse, toRequestUrl, toRetryableApiCallError, } from "./common-policy.js";
+export const CODEX_RETRYABLE_MESSAGES = [
+    "load failed",
+    "failed to fetch",
+    "network request failed",
+    "unable to connect",
+    "connection reset",
+    "connection aborted",
+    "econnreset",
+    "etimedout",
+    "timeout",
+    "socket hang up",
+];
+function isCodexUrl(request) {
+    const raw = toRequestUrl(request);
+    try {
+        const url = new URL(raw);
+        return url.hostname === "chatgpt.com" && url.pathname.startsWith("/backend-api/codex/");
+    }
+    catch {
+        return false;
+    }
+}
+const isRetryableCodexTransportErrorByMessage = createMessageRetryClassifier({
+    retryableMessages: CODEX_RETRYABLE_MESSAGES,
+    isAbortError,
+});
+export function isRetryableCodexTransportError(error) {
+    return isRetryableCodexTransportErrorByMessage(error);
+}
+function isRetryableCodexStatus(status) {
+    if (status === 429)
+        return true;
+    return status >= 500 && status <= 599;
+}
+function normalizeRetryableStatusResponseForCodex(response, request) {
+    return normalizeRetryableStatusResponse({
+        response,
+        request,
+        providerLabel: "Codex",
+        group: "status",
+        isRetryableStatus: isRetryableCodexStatus,
+    });
+}
+function toCodexRetryableApiCallError(error, request, options) {
+    return toRetryableApiCallError(error, request, {
+        providerLabel: "Codex",
+        group: options?.group ?? "transport",
+        statusCode: options?.statusCode,
+        responseHeaders: options?.responseHeaders,
+        responseBody: options?.responseBody,
+    });
+}
+export function createCodexRetryPolicy() {
+    return {
+        matchesRequest: (request) => isCodexUrl(request),
+        classifyFailure: async ({ error }) => {
+            if (isRetryableApiCallError(error)) {
+                return { retryable: false, category: "already-normalized" };
+            }
+            if (isRetryableCodexTransportError(error)) {
+                return { retryable: true, category: "transport" };
+            }
+            return { retryable: false, category: "none" };
+        },
+        handleResponse: async ({ response, request }) => normalizeRetryableStatusResponseForCodex(response, request),
+        normalizeFailure: ({ error, classification, request }) => {
+            if (classification.retryable && classification.category === "transport") {
+                return toCodexRetryableApiCallError(error, request);
+            }
+            return error;
+        },
+        buildRepairPlan: async () => undefined,
+    };
+}

package/dist/retry/common-policy.d.ts

@@ -0,0 +1,37 @@
+import type { NetworkRetryRequest } from "../network-retry-engine.js";
+export type RetryableApiCallError = Error & {
+    url: string;
+    requestBodyValues: unknown;
+    statusCode?: number;
+    responseHeaders?: Record<string, string>;
+    responseBody?: string;
+    isRetryable: boolean;
+    cause: unknown;
+    [key: symbol]: unknown;
+};
+export declare function toRequestUrl(request: Request | URL | string): string;
+export declare function getErrorMessage(error: unknown): string;
+export declare function isAbortError(error: unknown): boolean;
+export declare function createMessageRetryClassifier(options: {
+    retryableMessages: string[];
+    isAbortError?: (error: unknown) => boolean;
+}): (error: unknown) => boolean;
+export declare function toRetryableApiCallError(error: unknown, request: {
+    url: string;
+    body?: string;
+}, options: {
+    providerLabel: string;
+    group: string;
+    requestBodyValues?: unknown;
+    statusCode?: number;
+    responseHeaders?: Headers | Record<string, string>;
+    responseBody?: string;
+}): RetryableApiCallError;
+export declare function isRetryableApiCallError(error: unknown): error is RetryableApiCallError;
+export declare function normalizeRetryableStatusResponse(input: {
+    response: Response;
+    request: NetworkRetryRequest;
+    providerLabel: string;
+    group: string;
+    isRetryableStatus: (status: number) => boolean;
+}): Promise<Response>;

package/dist/retry/common-policy.js

@@ -0,0 +1,68 @@
+const AI_ERROR_MARKER = Symbol.for("vercel.ai.error");
+const API_CALL_ERROR_MARKER = Symbol.for("vercel.ai.error.AI_APICallError");
+export function toRequestUrl(request) {
+    return request instanceof Request ? request.url : request instanceof URL ? request.href : String(request);
+}
+export function getErrorMessage(error) {
+    return String(error instanceof Error ? error.message : error).toLowerCase();
+}
+export function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+export function createMessageRetryClassifier(options) {
+    return function isRetryableByMessage(error) {
+        if (!error)
+            return false;
+        if (options.isAbortError?.(error) ?? isAbortError(error))
+            return false;
+        const message = getErrorMessage(error);
+        return options.retryableMessages.some((part) => message.includes(part));
+    };
+}
+function buildRetryableApiCallMessage(providerLabel, group, detail) {
+    return `${providerLabel} retryable error [${group}]: ${detail}`;
+}
+export function toRetryableApiCallError(error, request, options) {
+    const base = error instanceof Error ? error : new Error(String(error));
+    const wrapped = new Error(buildRetryableApiCallMessage(options.providerLabel, options.group, base.message));
+    wrapped.name = "AI_APICallError";
+    wrapped.url = request.url;
+    wrapped.requestBodyValues = options.requestBodyValues ?? (() => {
+        if (!request.body)
+            return {};
+        try {
+            return JSON.parse(request.body);
+        }
+        catch {
+            return {};
+        }
+    })();
+    wrapped.statusCode = options.statusCode;
+    wrapped.responseHeaders = options.responseHeaders instanceof Headers
+        ? Object.fromEntries(options.responseHeaders.entries())
+        : options.responseHeaders;
+    wrapped.responseBody = options.responseBody;
+    wrapped.isRetryable = true;
+    wrapped.cause = error;
+    wrapped[AI_ERROR_MARKER] = true;
+    wrapped[API_CALL_ERROR_MARKER] = true;
+    return wrapped;
+}
+export function isRetryableApiCallError(error) {
+    return Boolean(error
+        && typeof error === "object"
+        && error[AI_ERROR_MARKER] === true
+        && error[API_CALL_ERROR_MARKER] === true);
+}
+export async function normalizeRetryableStatusResponse(input) {
+    if (!input.isRetryableStatus(input.response.status))
+        return input.response;
+    const responseBody = await input.response.clone().text().catch(() => "");
+    throw toRetryableApiCallError(new Error(responseBody || `status code ${input.response.status}`), input.request, {
+        providerLabel: input.providerLabel,
+        group: input.group,
+        statusCode: input.response.status,
+        responseHeaders: input.response.headers,
+        responseBody: responseBody || undefined,
+    });
+}

package/dist/store-paths.d.ts

@@ -0,0 +1,4 @@
+export declare function accountSwitcherConfigDir(): string;
+export declare function commonSettingsPath(): string;
+export declare function codexAccountsPath(): string;
+export declare function legacyCodexStorePath(): string;

package/dist/store-paths.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import os from "node:os";
+import { xdgConfig } from "xdg-basedir";
+function configBaseDir() {
+    const override = process.env.XDG_CONFIG_HOME;
+    if (typeof override === "string" && override.trim().length > 0) {
+        return override.trim();
+    }
+    return xdgConfig ?? path.join(os.homedir(), ".config");
+}
+export function accountSwitcherConfigDir() {
+    return path.join(configBaseDir(), "opencode", "account-switcher");
+}
+export function commonSettingsPath() {
+    return path.join(accountSwitcherConfigDir(), "settings.json");
+}
+export function codexAccountsPath() {
+    return path.join(accountSwitcherConfigDir(), "codex-accounts.json");
+}
+export function legacyCodexStorePath() {
+    return path.join(configBaseDir(), "opencode", "codex-store.json");
+}

package/dist/ui/ansi.d.ts

@@ -0,0 +1,18 @@
+export declare const ANSI: {
+    readonly hide: "\u001B[?25l";
+    readonly show: "\u001B[?25h";
+    readonly up: (n?: number) => string;
+    readonly clearLine: "\u001B[2K";
+    readonly clearScreen: "\u001B[2J";
+    readonly moveTo: (row: number, col: number) => string;
+    readonly cyan: "\u001B[36m";
+    readonly green: "\u001B[32m";
+    readonly red: "\u001B[31m";
+    readonly yellow: "\u001B[33m";
+    readonly dim: "\u001B[2m";
+    readonly bold: "\u001B[1m";
+    readonly reset: "\u001B[0m";
+};
+export type KeyAction = "up" | "down" | "enter" | "escape" | "escape-start" | null;
+export declare function parseKey(data: Buffer): KeyAction;
+export declare function isTTY(): boolean;

package/dist/ui/ansi.js

@@ -0,0 +1,32 @@
+export const ANSI = {
+    hide: "\x1b[?25l",
+    show: "\x1b[?25h",
+    up: (n = 1) => `\x1b[${n}A`,
+    clearLine: "\x1b[2K",
+    clearScreen: "\x1b[2J",
+    moveTo: (row, col) => `\x1b[${row};${col}H`,
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    dim: "\x1b[2m",
+    bold: "\x1b[1m",
+    reset: "\x1b[0m",
+};
+export function parseKey(data) {
+    const s = data.toString();
+    if (s === "\x1b[A" || s === "\x1bOA")
+        return "up";
+    if (s === "\x1b[B" || s === "\x1bOB")
+        return "down";
+    if (s === "\r" || s === "\n")
+        return "enter";
+    if (s === "\x03")
+        return "escape";
+    if (s === "\x1b")
+        return "escape-start";
+    return null;
+}
+export function isTTY() {
+    return Boolean(process.stdin.isTTY);
+}

package/dist/ui/confirm.d.ts

@@ -0,0 +1 @@
+export declare function confirm(message: string, defaultYes?: boolean): Promise<boolean>;

package/dist/ui/confirm.js

@@ -0,0 +1,14 @@
+import { select } from "./select.js";
+export async function confirm(message, defaultYes = false) {
+    const items = defaultYes
+        ? [
+            { label: "Yes", value: true },
+            { label: "No", value: false },
+        ]
+        : [
+            { label: "No", value: false },
+            { label: "Yes", value: true },
+        ];
+    const result = await select(items, { message });
+    return result ?? false;
+}

package/dist/ui/menu.d.ts

@@ -0,0 +1,168 @@
+import { select, type MenuItem } from "./select.js";
+import { confirm } from "./confirm.js";
+export type AccountStatus = "active" | "expired" | "unknown";
+export interface AccountInfo {
+    name: string;
+    workspaceName?: string;
+    index: number;
+    addedAt?: number;
+    lastUsed?: number;
+    status?: AccountStatus;
+    isCurrent?: boolean;
+    source?: "auth" | "manual";
+    orgs?: string[];
+    plan?: string;
+    sku?: string;
+    reset?: string;
+    models?: {
+        enabled: number;
+        disabled: number;
+    };
+    modelsError?: string;
+    modelList?: {
+        available: string[];
+        disabled: string[];
+    };
+    quota?: {
+        premium?: {
+            remaining?: number;
+            entitlement?: number;
+            unlimited?: boolean;
+        };
+        chat?: {
+            remaining?: number;
+            entitlement?: number;
+            unlimited?: boolean;
+        };
+        completions?: {
+            remaining?: number;
+            entitlement?: number;
+            unlimited?: boolean;
+        };
+    };
+}
+export type MenuAction = {
+    type: "add";
+} | {
+    type: "import";
+} | {
+    type: "quota";
+} | {
+    type: "refresh-identity";
+} | {
+    type: "check-models";
+} | {
+    type: "configure-default-group";
+} | {
+    type: "assign-models";
+} | {
+    type: "toggle-refresh";
+} | {
+    type: "set-interval";
+} | {
+    type: "toggle-language";
+} | {
+    type: "toggle-experimental-slash-commands";
+} | {
+    type: "toggle-network-retry";
+} | {
+    type: "toggle-synthetic-agent-initiator";
+} | {
+    type: "switch";
+    account: AccountInfo;
+} | {
+    type: "remove";
+    account: AccountInfo;
+} | {
+    type: "remove-all";
+} | {
+    type: "cancel";
+};
+export type MenuLanguage = "zh" | "en";
+export type MenuProvider = "codex";
+export type ShowMenuInput = {
+    provider?: MenuProvider;
+    refresh?: {
+        enabled: boolean;
+        minutes: number;
+    };
+    lastQuotaRefresh?: number;
+    modelAccountAssignmentCount?: number;
+    defaultAccountGroupCount?: number;
+    networkRetryEnabled?: boolean;
+    syntheticAgentInitiatorEnabled?: boolean;
+    experimentalSlashCommandsEnabled?: boolean;
+    capabilities?: Partial<MenuCapabilities>;
+    language?: MenuLanguage;
+};
+type MenuCapabilities = {
+    importAuth: boolean;
+    quota: boolean;
+    refreshIdentity: boolean;
+    checkModels: boolean;
+    defaultAccountGroup: boolean;
+    assignModels: boolean;
+    experimentalSlashCommands: boolean;
+    networkRetry: boolean;
+    syntheticAgentInitiator: boolean;
+};
+export declare function getMenuCopy(language?: MenuLanguage, provider?: MenuProvider): {
+    menuTitle: string;
+    menuSubtitle: string;
+    switchLanguageLabel: string;
+    actionsHeading: string;
+    commonSettingsHeading: string;
+    providerSettingsHeading: string;
+    addAccount: string;
+    addAccountHint: string;
+    importAuth: string;
+    checkQuotas: string;
+    refreshIdentity: string;
+    checkModels: string;
+    defaultAccountGroup: string;
+    assignModels: string;
+    autoRefreshOn: string;
+    autoRefreshOff: string;
+    setRefresh: string;
+    experimentalSlashCommandsOn: string;
+    experimentalSlashCommandsOff: string;
+    experimentalSlashCommandsHint: string;
+    retryOn: string;
+    retryOff: string;
+    retryHint: string;
+    syntheticInitiatorOn: string;
+    syntheticInitiatorOff: string;
+    syntheticInitiatorHint: string;
+    accountsHeading: string;
+    dangerHeading: string;
+    removeAll: string;
+};
+export declare function buildMenuItems(input: {
+    provider?: MenuProvider;
+    accounts: AccountInfo[];
+    refresh?: {
+        enabled: boolean;
+        minutes: number;
+    };
+    lastQuotaRefresh?: number;
+    modelAccountAssignmentCount?: number;
+    defaultAccountGroupCount?: number;
+    networkRetryEnabled: boolean;
+    syntheticAgentInitiatorEnabled?: boolean;
+    experimentalSlashCommandsEnabled?: boolean;
+    capabilities?: Partial<MenuCapabilities>;
+    language?: MenuLanguage;
+}): MenuItem<MenuAction>[];
+export declare function showMenu(accounts: AccountInfo[], input?: ShowMenuInput): Promise<MenuAction>;
+export declare function showMenuWithDeps(accounts: AccountInfo[], input?: ShowMenuInput, deps?: {
+    select?: typeof select;
+    confirm?: typeof confirm;
+    showAccountActions?: typeof showAccountActions;
+}): Promise<MenuAction>;
+export declare function buildAccountActionItems(account: AccountInfo, input?: {
+    provider?: MenuProvider;
+}): MenuItem<"switch" | "remove" | "back" | "models">[];
+export declare function showAccountActions(account: AccountInfo, input?: {
+    provider?: MenuProvider;
+}): Promise<"switch" | "remove" | "back">;
+export {};