opencode-copilot-account-switcher 0.13.3 → 0.13.5

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

@@ -0,0 +1,2 @@
+export type FetchLike = (request: Request | URL | string, init?: RequestInit) => Promise<Response>;
+export declare function createCodexRetryingFetch(baseFetch: FetchLike): (request: Request | URL | string, init?: RequestInit) => Promise<Response>;

package/dist/codex-network-retry.js

@@ -0,0 +1,9 @@
+import { createNetworkRetryEngine } from "./network-retry-engine.js";
+import { createCodexRetryPolicy } from "./retry/codex-policy.js";
+export function createCodexRetryingFetch(baseFetch) {
+    const policy = createCodexRetryPolicy();
+    const retryEngine = createNetworkRetryEngine({
+        policy,
+    });
+    return retryEngine(baseFetch);
+}

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

@@ -66,5 +66,6 @@ export declare function fetchCodexStatus(input: {
     accountId?: string;
     fetchImpl?: typeof globalThis.fetch;
     now?: () => number;
+    timeoutMs?: number;
     refreshTokens?: (oauth: OpenAIOAuthAuth) => Promise<OpenAIOAuthAuth | undefined>;
 }): Promise<CodexStatusFetcherResult>;

package/dist/codex-status-fetcher.js

@@ -1,4 +1,5 @@
 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;
@@ -158,24 +159,30 @@ async function requestUsage(input) {
             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,
@@ -193,6 +200,9 @@ export async function fetchCodexStatus(input) {
                 },
             };
         }
+        finally {
+            clearTimeout(timeout);
+        }
         if (response.status === 401 && attempt === 0 && input.refreshTokens) {
             let refreshed;
             try {

package/dist/codex-store.js

@@ -1,8 +1,6 @@
 import path from "node:path";
-import os from "node:os";
 import { promises as fs } from "node:fs";
-import { xdgConfig } from "xdg-basedir";
-const filename = "codex-store.json";
+import { codexAccountsPath, legacyCodexStorePath } from "./store-paths.js";
 function asRecord(input) {
     if (!input || typeof input !== "object" || Array.isArray(input))
         return undefined;
@@ -245,14 +243,19 @@ export function getActiveCodexAccount(store) {
     };
 }
 export function codexStorePath() {
-    const base = xdgConfig ?? path.join(os.homedir(), ".config");
-    return path.join(base, "opencode", filename);
+    return codexAccountsPath();
 }
 export async function readCodexStore(filePath = codexStorePath()) {
-    const raw = await fs.readFile(filePath, "utf8").catch((error) => {
-        if (error.code === "ENOENT")
+    const raw = await fs.readFile(filePath, "utf8").catch(async (error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+        if (filePath !== codexStorePath())
             return "";
-        throw error;
+        return fs.readFile(legacyCodexStorePath(), "utf8").catch((legacyError) => {
+            if (legacyError.code === "ENOENT")
+                return "";
+            throw legacyError;
+        });
     });
     return parseCodexStore(raw);
 }

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

@@ -0,0 +1,15 @@
+import type { CommonSettingsStore } from "./common-settings-store.js";
+export type CommonSettingsActionType = "toggle-loop-safety" | "toggle-loop-safety-provider-scope" | "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,42 @@
+export async function applyCommonSettingsAction(input) {
+    const settings = await input.readSettings();
+    if (input.action.type === "toggle-loop-safety") {
+        settings.loopSafetyEnabled = settings.loopSafetyEnabled !== true;
+        await input.writeSettings(settings, {
+            reason: "toggle-loop-safety",
+            source: "applyCommonSettingsAction",
+            actionType: "toggle-loop-safety",
+        });
+        return true;
+    }
+    if (input.action.type === "toggle-loop-safety-provider-scope") {
+        settings.loopSafetyProviderScope = settings.loopSafetyProviderScope === "all-models"
+            ? "copilot-only"
+            : "all-models";
+        await input.writeSettings(settings, {
+            reason: "toggle-loop-safety-provider-scope",
+            source: "applyCommonSettingsAction",
+            actionType: "toggle-loop-safety-provider-scope",
+        });
+        return true;
+    }
+    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,20 @@
+export type CommonSettingsStore = {
+    loopSafetyEnabled?: boolean;
+    loopSafetyProviderScope?: "copilot-only" | "all-models";
+    networkRetryEnabled?: boolean;
+    experimentalSlashCommandsEnabled?: boolean;
+    experimentalStatusSlashCommandEnabled?: boolean;
+};
+export declare function parseCommonSettingsStore(raw: string): CommonSettingsStore;
+export declare function commonSettingsPath(): string;
+export declare function readCommonSettingsStore(options?: {
+    filePath?: string;
+    legacyCopilotFilePath?: string;
+}): Promise<CommonSettingsStore>;
+export declare function readCommonSettingsStoreSync(options?: {
+    filePath?: string;
+    legacyCopilotFilePath?: string;
+}): CommonSettingsStore | undefined;
+export declare function writeCommonSettingsStore(store: CommonSettingsStore, options?: {
+    filePath?: string;
+}): Promise<void>;

package/dist/common-settings-store.js

@@ -0,0 +1,125 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { readFileSync } from "node:fs";
+import { commonSettingsPath as defaultCommonSettingsPath, legacyCopilotStorePath } from "./store-paths.js";
+import { parseStore } from "./store.js";
+function normalizeCommonSettingsStore(input) {
+    const source = input ?? {};
+    const legacySlashCommandsEnabled = source.experimentalStatusSlashCommandEnabled;
+    return {
+        ...(source.loopSafetyEnabled !== false ? { loopSafetyEnabled: true } : { loopSafetyEnabled: false }),
+        loopSafetyProviderScope: source.loopSafetyProviderScope === "all-models" ? "all-models" : "copilot-only",
+        ...(source.networkRetryEnabled === true ? { networkRetryEnabled: true } : { networkRetryEnabled: false }),
+        experimentalSlashCommandsEnabled: source.experimentalSlashCommandsEnabled === true || source.experimentalSlashCommandsEnabled === false
+            ? source.experimentalSlashCommandsEnabled
+            : legacySlashCommandsEnabled === false
+                ? false
+                : true,
+    };
+}
+function parsePartialCommonSettingsStore(raw) {
+    const parsed = raw ? JSON.parse(raw) : {};
+    const partial = {};
+    if (parsed.loopSafetyEnabled === true || parsed.loopSafetyEnabled === false) {
+        partial.loopSafetyEnabled = parsed.loopSafetyEnabled;
+    }
+    if (parsed.loopSafetyProviderScope === "all-models" || parsed.loopSafetyProviderScope === "copilot-only") {
+        partial.loopSafetyProviderScope = parsed.loopSafetyProviderScope;
+    }
+    if (parsed.networkRetryEnabled === true || parsed.networkRetryEnabled === false) {
+        partial.networkRetryEnabled = parsed.networkRetryEnabled;
+    }
+    if (parsed.experimentalSlashCommandsEnabled === true || parsed.experimentalSlashCommandsEnabled === false) {
+        partial.experimentalSlashCommandsEnabled = parsed.experimentalSlashCommandsEnabled;
+    }
+    if (parsed.experimentalStatusSlashCommandEnabled === true || parsed.experimentalStatusSlashCommandEnabled === false) {
+        partial.experimentalStatusSlashCommandEnabled = parsed.experimentalStatusSlashCommandEnabled;
+    }
+    return partial;
+}
+function readLegacyCommonSettings(store) {
+    if (!store)
+        return {};
+    return normalizeCommonSettingsStore({
+        loopSafetyEnabled: store.loopSafetyEnabled,
+        loopSafetyProviderScope: store.loopSafetyProviderScope,
+        networkRetryEnabled: store.networkRetryEnabled,
+        experimentalSlashCommandsEnabled: store.experimentalSlashCommandsEnabled,
+        experimentalStatusSlashCommandEnabled: store.experimentalStatusSlashCommandEnabled,
+    });
+}
+function mergeCommonSettings(current, legacy) {
+    return normalizeCommonSettingsStore({
+        loopSafetyEnabled: current.loopSafetyEnabled ?? legacy.loopSafetyEnabled,
+        loopSafetyProviderScope: current.loopSafetyProviderScope ?? legacy.loopSafetyProviderScope,
+        networkRetryEnabled: current.networkRetryEnabled ?? legacy.networkRetryEnabled,
+        experimentalSlashCommandsEnabled: current.experimentalSlashCommandsEnabled ?? legacy.experimentalSlashCommandsEnabled,
+        experimentalStatusSlashCommandEnabled: current.experimentalStatusSlashCommandEnabled ?? legacy.experimentalStatusSlashCommandEnabled,
+    });
+}
+export function parseCommonSettingsStore(raw) {
+    return normalizeCommonSettingsStore(parsePartialCommonSettingsStore(raw));
+}
+export function commonSettingsPath() {
+    return defaultCommonSettingsPath();
+}
+export async function readCommonSettingsStore(options) {
+    const file = options?.filePath ?? commonSettingsPath();
+    const raw = await fs.readFile(file, "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+            return "";
+        throw error;
+    });
+    const current = parsePartialCommonSettingsStore(raw);
+    const legacyFile = options?.legacyCopilotFilePath ?? legacyCopilotStorePath();
+    const legacyRaw = await fs.readFile(legacyFile, "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+            return "";
+        throw error;
+    });
+    if (!legacyRaw)
+        return normalizeCommonSettingsStore(current);
+    const legacy = readLegacyCommonSettings(parseStore(legacyRaw));
+    return mergeCommonSettings(current, legacy);
+}
+export function readCommonSettingsStoreSync(options) {
+    const file = options?.filePath ?? commonSettingsPath();
+    let current = "";
+    try {
+        current = readFileSync(file, "utf8");
+    }
+    catch (error) {
+        const issue = error;
+        if (issue.code !== "ENOENT")
+            return undefined;
+    }
+    const legacyFile = options?.legacyCopilotFilePath ?? legacyCopilotStorePath();
+    let legacyRaw = "";
+    try {
+        legacyRaw = readFileSync(legacyFile, "utf8");
+    }
+    catch (error) {
+        const issue = error;
+        if (issue.code !== "ENOENT")
+            return undefined;
+    }
+    const partial = parsePartialCommonSettingsStore(current);
+    if (!legacyRaw)
+        return normalizeCommonSettingsStore(partial);
+    return mergeCommonSettings(partial, readLegacyCommonSettings(parseStore(legacyRaw)));
+}
+export async function writeCommonSettingsStore(store, options) {
+    const file = options?.filePath ?? commonSettingsPath();
+    const normalized = normalizeCommonSettingsStore(store);
+    const persisted = {};
+    if (normalized.loopSafetyEnabled === false)
+        persisted.loopSafetyEnabled = false;
+    if (normalized.loopSafetyProviderScope === "all-models")
+        persisted.loopSafetyProviderScope = "all-models";
+    if (normalized.networkRetryEnabled === true)
+        persisted.networkRetryEnabled = true;
+    if (normalized.experimentalSlashCommandsEnabled === false)
+        persisted.experimentalSlashCommandsEnabled = false;
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, JSON.stringify(persisted, null, 2), { mode: 0o600 });
+}

package/dist/menu-runtime.d.ts

@@ -6,6 +6,7 @@ type WriteMeta = {
 export type MenuAccountInfo = {
     id?: string;
     name: string;
+    workspaceName?: string;
     index: number;
     isCurrent?: boolean;
 };

package/dist/plugin-actions.d.ts

@@ -1,5 +1,6 @@
 import type { StoreFile } from "./store.js";
 import type { MenuAction } from "./ui/menu.js";
+import type { CommonSettingsStore } from "./common-settings-store.js";
 export declare function persistAccountSwitch(input: {
     store: StoreFile;
     name: string;
@@ -22,4 +23,12 @@ export declare function applyMenuAction(input: {
         inputStage?: string;
         parsedKey?: string;
     }) => Promise<void>;
+    readCommonSettings?: () => Promise<CommonSettingsStore>;
+    writeCommonSettings?: (settings: CommonSettingsStore, meta?: {
+        reason?: string;
+        source?: string;
+        actionType?: string;
+        inputStage?: string;
+        parsedKey?: string;
+    }) => Promise<void>;
 }): Promise<boolean>;

package/dist/plugin-actions.js

@@ -1,3 +1,10 @@
+import { applyCommonSettingsAction } from "./common-settings-actions.js";
+function isCommonSettingsAction(action) {
+    return action.type === "toggle-loop-safety"
+        || action.type === "toggle-loop-safety-provider-scope"
+        || action.type === "toggle-experimental-slash-commands"
+        || action.type === "toggle-network-retry";
+}
 export async function persistAccountSwitch(input) {
     input.store.active = input.name;
     if (!Array.isArray(input.store.activeAccountNames) || input.store.activeAccountNames.length === 0) {
@@ -12,41 +19,14 @@ export async function persistAccountSwitch(input) {
     });
 }
 export async function applyMenuAction(input) {
-    if (input.action.type === "toggle-loop-safety") {
-        input.store.loopSafetyEnabled = input.store.loopSafetyEnabled !== true;
-        await input.writeStore(input.store, {
-            reason: "toggle-loop-safety",
-            source: "applyMenuAction",
-            actionType: "toggle-loop-safety",
-        });
-        return true;
-    }
-    if (input.action.type === "toggle-loop-safety-provider-scope") {
-        input.store.loopSafetyProviderScope = input.store.loopSafetyProviderScope === "all-models"
-            ? "copilot-only"
-            : "all-models";
-        await input.writeStore(input.store, {
-            reason: "toggle-loop-safety-provider-scope",
-            source: "applyMenuAction",
-            actionType: "toggle-loop-safety-provider-scope",
-        });
-        return true;
-    }
-    if (input.action.type === "toggle-experimental-slash-commands") {
-        input.store.experimentalSlashCommandsEnabled = input.store.experimentalSlashCommandsEnabled !== true;
-        await input.writeStore(input.store, {
-            reason: "toggle-experimental-slash-commands",
-            source: "applyMenuAction",
-            actionType: "toggle-experimental-slash-commands",
-        });
-        return true;
-    }
-    if (input.action.type === "toggle-network-retry") {
-        input.store.networkRetryEnabled = input.store.networkRetryEnabled !== true;
-        await input.writeStore(input.store, {
-            reason: "toggle-network-retry",
-            source: "applyMenuAction",
-            actionType: "toggle-network-retry",
+    if (isCommonSettingsAction(input.action)) {
+        if (!input.readCommonSettings || !input.writeCommonSettings) {
+            throw new Error(`Common settings action ${input.action.type} requires common settings store dependencies`);
+        }
+        await applyCommonSettingsAction({
+            action: { type: input.action.type },
+            readSettings: input.readCommonSettings,
+            writeSettings: input.writeCommonSettings,
         });
         return true;
     }

package/dist/plugin-hooks.d.ts

@@ -3,6 +3,7 @@ import { type CopilotRetryContext, type FetchLike } from "./copilot-network-retr
 import { type ResolvedModelAccountCandidate } from "./model-account-map.js";
 import { type StoreFile, type StoreWriteDebugMeta } from "./store.js";
 import { type CopilotAuthState, type CopilotProviderConfig, type OfficialCopilotConfig, type OfficialChatHeadersHook } from "./upstream/copilot-loader-adapter.js";
+import type { CommonSettingsStore } from "./common-settings-store.js";
 import { type RefreshActiveAccountQuotaResult } from "./active-account-quota.js";
 import { handleStatusCommand } from "./status-command.js";
 import { handleCodexStatusCommand } from "./codex-status-command.js";
@@ -56,6 +57,8 @@ export declare function buildPluginHooks(input: {
     auth: NonNullable<CopilotPluginHooks["auth"]>;
     loadStore?: () => Promise<StoreFile | undefined>;
     loadStoreSync?: () => StoreFile | undefined;
+    loadCommonSettings?: () => Promise<CommonSettingsStore | undefined>;
+    loadCommonSettingsSync?: () => CommonSettingsStore | undefined;
     writeStore?: (store: StoreFile, meta?: StoreWriteDebugMeta) => Promise<void>;
     loadOfficialConfig?: (input: {
         getAuth: () => Promise<CopilotAuthState | undefined>;
@@ -108,5 +111,7 @@ export declare function buildPluginHooks(input: {
     touchWriteCacheIdleTtlMs?: number;
     touchWriteCacheMaxEntries?: number;
     random?: () => number;
+    authLoaderMode?: "copilot" | "codex" | "none";
+    enableModelRouting?: boolean;
 }): CopilotPluginHooksWithChatHeaders;
 export {};