opencode-copilot-account-switcher 0.13.4 → 0.13.6

package/dist/providers/registry.js

@@ -1,5 +1,9 @@
 import { CODEX_PROVIDER_DESCRIPTOR, COPILOT_PROVIDER_DESCRIPTOR } from "./descriptor.js";
 import { createCodexProviderDescriptor, createCopilotProviderDescriptor } from "./descriptor.js";
+import { createCopilotRetryingFetch } from "../copilot-network-retry.js";
+import { createCodexRetryingFetch } from "../codex-network-retry.js";
+import { loadOfficialCopilotChatHeaders, loadOfficialCopilotConfig } from "../upstream/copilot-loader-adapter.js";
+import { loadOfficialCodexChatHeaders, loadOfficialCodexConfig } from "../upstream/codex-loader-adapter.js";
 const PROVIDER_DESCRIPTORS = [
     COPILOT_PROVIDER_DESCRIPTOR,
     CODEX_PROVIDER_DESCRIPTOR,
@@ -16,13 +20,45 @@ export function getProviderDescriptorByProviderID(providerID) {
 export function isProviderIDSupportedByAnyDescriptor(providerID) {
     return getProviderDescriptorByProviderID(providerID) !== undefined;
 }
+function hasCapability(descriptor, capability) {
+    return descriptor.capabilities.includes(capability);
+}
 export function createProviderRegistry(input) {
+    const copilotCapabilities = COPILOT_PROVIDER_DESCRIPTOR;
+    const codexCapabilities = CODEX_PROVIDER_DESCRIPTOR;
+    const buildCopilotPluginHooks = (hookInput) => input.buildPluginHooks({
+        ...hookInput,
+        authLoaderMode: hasCapability(copilotCapabilities, "auth") ? "copilot" : "none",
+        enableModelRouting: hasCapability(copilotCapabilities, "model-routing"),
+        loadOfficialConfig: hasCapability(copilotCapabilities, "auth") ? loadOfficialCopilotConfig : undefined,
+        loadOfficialChatHeaders: hasCapability(copilotCapabilities, "chat-headers") ? loadOfficialCopilotChatHeaders : undefined,
+        createRetryFetch: hasCapability(copilotCapabilities, "network-retry") ? createCopilotRetryingFetch : undefined,
+    });
+    const buildCodexPluginHooks = (hookInput) => input.buildPluginHooks({
+        ...hookInput,
+        authLoaderMode: hasCapability(codexCapabilities, "auth") ? "codex" : "none",
+        enableModelRouting: hasCapability(codexCapabilities, "model-routing"),
+        loadOfficialConfig: hasCapability(codexCapabilities, "auth")
+            ? ({ getAuth, baseFetch, version }) => loadOfficialCodexConfig({
+                getAuth: getAuth,
+                baseFetch,
+                version,
+                client: hookInput.client,
+            })
+            : undefined,
+        loadOfficialChatHeaders: hasCapability(codexCapabilities, "chat-headers")
+            ? loadOfficialCodexChatHeaders
+            : undefined,
+        createRetryFetch: hasCapability(codexCapabilities, "network-retry")
+            ? createCodexRetryingFetch
+            : undefined,
+    });
     return {
         copilot: {
-            descriptor: createCopilotProviderDescriptor({ buildPluginHooks: input.buildPluginHooks }),
+            descriptor: createCopilotProviderDescriptor({ buildPluginHooks: buildCopilotPluginHooks }),
         },
         codex: {
-            descriptor: createCodexProviderDescriptor({ enabled: true }),
+            descriptor: createCodexProviderDescriptor({ buildPluginHooks: buildCodexPluginHooks, enabled: true }),
         },
     };
 }

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/retry/copilot-policy.d.ts

@@ -1,16 +1,7 @@
 import type { NetworkRetryPolicy } from "../network-retry-engine.js";
+import { type RetryableApiCallError } from "./common-policy.js";
 export declare const COPILOT_RETRYABLE_MESSAGES: string[];
 export type RetryableErrorGroup = "transport" | "status" | "stream";
-type RetryableApiCallError = Error & {
-    url: string;
-    requestBodyValues: unknown;
-    statusCode?: number;
-    responseHeaders?: Record<string, string>;
-    responseBody?: string;
-    isRetryable: boolean;
-    cause: unknown;
-    [key: symbol]: unknown;
-};
 type CopilotStreamErrorInput = {
     error: unknown;
     request: Request | URL | string;

package/dist/retry/copilot-policy.js

@@ -1,5 +1,4 @@
-const AI_ERROR_MARKER = Symbol.for("vercel.ai.error");
-const API_CALL_ERROR_MARKER = Symbol.for("vercel.ai.error.AI_APICallError");
+import { createMessageRetryClassifier, getErrorMessage, isAbortError, isRetryableApiCallError as isRetryableApiCallErrorByMarker, normalizeRetryableStatusResponse, toRequestUrl, toRetryableApiCallError as toRetryableApiCallErrorByCommon, } from "./common-policy.js";
 export const COPILOT_RETRYABLE_MESSAGES = [
     "load failed",
     "failed to fetch",
@@ -13,15 +12,6 @@ export const COPILOT_RETRYABLE_MESSAGES = [
     "unable to verify the first certificate",
     "self-signed certificate in certificate chain",
 ];
-function toRequestUrl(request) {
-    return request instanceof Request ? request.url : request instanceof URL ? request.href : String(request);
-}
-function getErrorMessage(error) {
-    return String(error instanceof Error ? error.message : error).toLowerCase();
-}
-function isAbortError(error) {
-    return error instanceof Error && error.name === "AbortError";
-}
 function isSseReadTimeoutError(error) {
     return getErrorMessage(error).includes("sse read timed out");
 }
@@ -96,57 +86,33 @@ export function isCopilotUrl(request) {
         return false;
     }
 }
+const isRetryableCopilotTransportErrorByMessage = createMessageRetryClassifier({
+    retryableMessages: COPILOT_RETRYABLE_MESSAGES,
+    isAbortError,
+});
 export function isRetryableCopilotTransportError(error) {
-    if (!error || isAbortError(error))
-        return false;
-    const message = getErrorMessage(error);
-    return COPILOT_RETRYABLE_MESSAGES.some((part) => message.includes(part));
-}
-function buildRetryableApiCallMessage(group, detail) {
-    return `Copilot retryable error [${group}]: ${detail}`;
+    return isRetryableCopilotTransportErrorByMessage(error);
 }
 export function toRetryableApiCallError(error, request, options) {
-    const base = error instanceof Error ? error : new Error(String(error));
-    const wrapped = new Error(buildRetryableApiCallMessage(options?.group ?? "transport", 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;
+    return toRetryableApiCallErrorByCommon(error, request, {
+        providerLabel: "Copilot",
+        group: options?.group ?? "transport",
+        requestBodyValues: options?.requestBodyValues,
+        statusCode: options?.statusCode,
+        responseHeaders: options?.responseHeaders,
+        responseBody: options?.responseBody,
+    });
 }
 export function isRetryableApiCallError(error) {
-    return Boolean(error
-        && typeof error === "object"
-        && error[AI_ERROR_MARKER] === true
-        && error[API_CALL_ERROR_MARKER] === true);
-}
-function normalizeRetryableStatusResponse(response, request) {
-    if (response.status !== 499)
-        return response;
-    return response.clone().text().catch(() => "").then((responseBody) => {
-        throw toRetryableApiCallError(new Error(responseBody || `status code ${response.status}`), request, {
-            group: "status",
-            statusCode: response.status,
-            responseHeaders: response.headers,
-            responseBody: responseBody || undefined,
-        });
+    return isRetryableApiCallErrorByMarker(error);
+}
+function normalizeRetryableStatusResponseForCopilot(response, request) {
+    return normalizeRetryableStatusResponse({
+        response,
+        request,
+        providerLabel: "Copilot",
+        group: "status",
+        isRetryableStatus: (status) => status === 499,
     });
 }
 export function createCopilotRetryPolicy(options) {
@@ -161,7 +127,7 @@ export function createCopilotRetryPolicy(options) {
             }
             return { retryable: false, category: "none" };
         },
-        handleResponse: async ({ response, request }) => normalizeRetryableStatusResponse(response, request),
+        handleResponse: async ({ response, request }) => normalizeRetryableStatusResponseForCopilot(response, request),
         normalizeFailure: ({ error, classification, request }) => {
             if (classification.retryable && classification.category === "transport") {
                 return toRetryableApiCallError(error, request);

package/dist/store-paths.d.ts

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

package/dist/store-paths.js

@@ -0,0 +1,24 @@
+import path from "node:path";
+import os from "node:os";
+import { xdgConfig } from "xdg-basedir";
+function configBaseDir() {
+    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 copilotAccountsPath() {
+    return path.join(accountSwitcherConfigDir(), "copilot-accounts.json");
+}
+export function codexAccountsPath() {
+    return path.join(accountSwitcherConfigDir(), "codex-accounts.json");
+}
+export function legacyCopilotStorePath() {
+    return path.join(configBaseDir(), "opencode", "copilot-accounts.json");
+}
+export function legacyCodexStorePath() {
+    return path.join(configBaseDir(), "opencode", "codex-store.json");
+}

package/dist/store.js

@@ -3,7 +3,7 @@ import os from "node:os";
 import { promises as fs } from "node:fs";
 import { readFileSync } from "node:fs";
 import { xdgConfig, xdgData } from "xdg-basedir";
-const filename = "copilot-accounts.json";
+import { copilotAccountsPath, legacyCopilotStorePath } from "./store-paths.js";
 const authFile = "auth.json";
 const defaultStoreDebugLogFile = (() => {
     const tmp = process.env.TEMP || process.env.TMP || "/tmp";
@@ -57,8 +57,7 @@ async function logStoreWrite(input) {
     }
 }
 export function storePath() {
-    const base = xdgConfig ?? path.join(os.homedir(), ".config");
-    return path.join(base, "opencode", filename);
+    return copilotAccountsPath();
 }
 export function authPath() {
     const dataDir = xdgData ?? path.join(os.homedir(), ".local", "share");
@@ -134,16 +133,32 @@ export function parseStore(raw) {
     return store;
 }
 export async function readStore(filePath = storePath()) {
-    const raw = await fs.readFile(filePath, "utf-8").catch((error) => {
-        if (error.code === "ENOENT")
+    const raw = await fs.readFile(filePath, "utf-8").catch(async (error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+        if (filePath !== storePath())
             return "";
-        throw error;
+        return fs.readFile(legacyCopilotStorePath(), "utf-8").catch((legacyError) => {
+            if (legacyError.code === "ENOENT")
+                return "";
+            throw legacyError;
+        });
     });
     return parseStore(raw);
 }
 export async function readStoreSafe(filePath = storePath()) {
     try {
-        const raw = await fs.readFile(filePath, "utf-8");
+        const raw = await fs.readFile(filePath, "utf-8").catch(async (error) => {
+            if (error.code !== "ENOENT")
+                throw error;
+            if (filePath !== storePath())
+                return "";
+            return fs.readFile(legacyCopilotStorePath(), "utf-8").catch((legacyError) => {
+                if (legacyError.code === "ENOENT")
+                    return "";
+                throw legacyError;
+            });
+        });
         return parseStore(raw);
     }
     catch (error) {
@@ -159,8 +174,19 @@ export function readStoreSafeSync(filePath = storePath()) {
     }
     catch (error) {
         const issue = error;
-        if (issue.code === "ENOENT")
+        if (issue.code === "ENOENT") {
+            try {
+                if (filePath === storePath()) {
+                    return parseStore(readFileSync(legacyCopilotStorePath(), "utf-8"));
+                }
+            }
+            catch (legacyError) {
+                const legacyIssue = legacyError;
+                if (legacyIssue.code !== "ENOENT")
+                    return undefined;
+            }
             return parseStore("");
+        }
         return undefined;
     }
 }

package/dist/ui/menu.d.ts

@@ -102,6 +102,8 @@ export declare function getMenuCopy(language?: MenuLanguage, provider?: MenuProv
     menuSubtitle: string;
     switchLanguageLabel: string;
     actionsHeading: string;
+    commonSettingsHeading: string;
+    providerSettingsHeading: string;
     addAccount: string;
     addAccountHint: string;
     importAuth: string;