opencode-copilot-account-switcher 0.13.4 → 0.13.6

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-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,122 @@
+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 = {
+        loopSafetyEnabled: normalized.loopSafetyEnabled,
+        loopSafetyProviderScope: normalized.loopSafetyProviderScope,
+        networkRetryEnabled: normalized.networkRetryEnabled,
+        experimentalSlashCommandsEnabled: normalized.experimentalSlashCommandsEnabled,
+    };
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, JSON.stringify(persisted, null, 2), { mode: 0o600 });
+}

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 {};