opencode-openai-account-switcher 0.1.0

package/dist/common-settings-store.js

@@ -0,0 +1,72 @@
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import { readFileSync } from "node:fs";
+import { commonSettingsPath as defaultCommonSettingsPath } from "./store-paths.js";
+export function normalizeCommonSettingsStore(input) {
+    const source = input ?? {};
+    const legacySlashCommandsEnabled = source.experimentalStatusSlashCommandEnabled;
+    return {
+        networkRetryEnabled: source.networkRetryEnabled === true,
+        experimentalSlashCommandsEnabled: source.experimentalSlashCommandsEnabled === true || source.experimentalSlashCommandsEnabled === false
+            ? source.experimentalSlashCommandsEnabled
+            : legacySlashCommandsEnabled !== false,
+        ...(source.experimentalStatusSlashCommandEnabled === true || source.experimentalStatusSlashCommandEnabled === false
+            ? { experimentalStatusSlashCommandEnabled: source.experimentalStatusSlashCommandEnabled }
+            : {}),
+    };
+}
+function parsePartialCommonSettingsStore(raw) {
+    const parsed = raw ? JSON.parse(raw) : {};
+    const partial = {};
+    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;
+}
+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;
+    });
+    return normalizeCommonSettingsStore(parsePartialCommonSettingsStore(raw));
+}
+export function readCommonSettingsStoreSync(options) {
+    const file = options?.filePath ?? commonSettingsPath();
+    let raw = "";
+    try {
+        raw = readFileSync(file, "utf8");
+    }
+    catch (error) {
+        const issue = error;
+        if (issue.code !== "ENOENT")
+            return undefined;
+    }
+    return normalizeCommonSettingsStore(parsePartialCommonSettingsStore(raw));
+}
+export async function writeCommonSettingsStore(store, options) {
+    const file = options?.filePath ?? commonSettingsPath();
+    const normalized = normalizeCommonSettingsStore(store);
+    const persisted = {
+        networkRetryEnabled: normalized.networkRetryEnabled,
+        experimentalSlashCommandsEnabled: normalized.experimentalSlashCommandsEnabled,
+        ...(normalized.experimentalStatusSlashCommandEnabled === true || normalized.experimentalStatusSlashCommandEnabled === false
+            ? { experimentalStatusSlashCommandEnabled: normalized.experimentalStatusSlashCommandEnabled }
+            : {}),
+    };
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, JSON.stringify(persisted, null, 2), { mode: 0o600 });
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { OpenAICodexAccountSwitcher } from "./plugin.js";

package/dist/index.js

@@ -0,0 +1 @@
+export { OpenAICodexAccountSwitcher } from "./plugin.js";

package/dist/menu-runtime.d.ts

@@ -0,0 +1,81 @@
+type WriteMeta = {
+    reason: string;
+    source: string;
+    actionType?: string;
+};
+export type ProviderActionResult = boolean | {
+    handled: boolean;
+    persistHandled?: boolean;
+    result?: unknown;
+};
+export type ProviderActionOutput = {
+    name: string;
+    payload?: unknown;
+    result: unknown;
+};
+export type MenuAccountInfo = {
+    id?: string;
+    name: string;
+    workspaceName?: string;
+    index: number;
+    isCurrent?: boolean;
+};
+export type MenuActionAccount = {
+    id?: string;
+    name: string;
+};
+type SharedActionResult = boolean | {
+    changed: boolean;
+    persistHandled?: boolean;
+};
+export type MenuAction = {
+    type: "add";
+} | {
+    type: "cancel";
+} | {
+    type: "remove";
+    account: MenuActionAccount;
+} | {
+    type: "remove-all";
+} | {
+    type: "switch";
+    account: MenuActionAccount;
+} | {
+    type: "provider";
+    name: string;
+    payload?: unknown;
+};
+export type ProviderMenuAdapter<TStore, TEntry> = {
+    key: string;
+    loadStore: () => Promise<TStore>;
+    writeStore: (store: TStore, meta: WriteMeta) => Promise<void>;
+    bootstrapAuthImport: (store: TStore) => Promise<boolean>;
+    authorizeNewAccount: (store: TStore) => Promise<TEntry | undefined>;
+    refreshSnapshots: (store: TStore) => Promise<void>;
+    toMenuInfo: (store: TStore) => Promise<MenuAccountInfo[]>;
+    getCurrentEntry: (store: TStore) => TEntry | undefined;
+    getRefreshConfig: (store: TStore) => {
+        enabled: boolean;
+        minutes: number;
+    };
+    getAccountByName: (store: TStore, name: string) => {
+        name: string;
+        entry: TEntry;
+    } | undefined;
+    addAccount?: (store: TStore, entry: TEntry) => Promise<SharedActionResult> | SharedActionResult;
+    removeAccount?: (store: TStore, name: string) => Promise<SharedActionResult> | SharedActionResult;
+    removeAllAccounts?: (store: TStore) => Promise<SharedActionResult> | SharedActionResult;
+    switchAccount: (store: TStore, name: string, entry: TEntry) => Promise<{
+        persistHandled?: boolean;
+    } | void>;
+    applyAction?: (store: TStore, action: Extract<MenuAction, {
+        type: "provider";
+    }>) => Promise<ProviderActionResult>;
+};
+export declare function runProviderMenu<TStore, TEntry>(input: {
+    adapter: ProviderMenuAdapter<TStore, TEntry>;
+    showMenu: (accounts: MenuAccountInfo[], store: TStore) => Promise<MenuAction>;
+    onProviderActionResult?: (output: ProviderActionOutput) => Promise<void> | void;
+    now?: () => number;
+}): Promise<TEntry | undefined>;
+export {};

package/dist/menu-runtime.js

@@ -0,0 +1,141 @@
+function parseSharedActionResult(result) {
+    if (typeof result === "object" && result) {
+        return {
+            changed: result.changed === true,
+            persistHandled: result.persistHandled === true,
+        };
+    }
+    return {
+        changed: result === true,
+        persistHandled: false,
+    };
+}
+function providerActionReason(name) {
+    return `provider-action:${name}`;
+}
+function isNonPersistentProviderAction(name) {
+    void name;
+    return false;
+}
+export async function runProviderMenu(input) {
+    const now = input.now ?? Date.now;
+    const store = await input.adapter.loadStore();
+    if (await input.adapter.bootstrapAuthImport(store)) {
+        await input.adapter.writeStore(store, {
+            reason: "bootstrap-auth-import",
+            source: "menu-runtime",
+            actionType: "bootstrap-auth-import",
+        });
+    }
+    let nextRefreshAt = 0;
+    while (true) {
+        const refresh = input.adapter.getRefreshConfig(store);
+        if (refresh.enabled && now() >= nextRefreshAt) {
+            await input.adapter.refreshSnapshots(store);
+            await input.adapter.writeStore(store, {
+                reason: "auto-refresh",
+                source: "menu-runtime",
+                actionType: "auto-refresh",
+            });
+            nextRefreshAt = now() + refresh.minutes * 60_000;
+        }
+        const accounts = await input.adapter.toMenuInfo(store);
+        const action = await input.showMenu(accounts, store);
+        if (action.type === "cancel")
+            return input.adapter.getCurrentEntry(store);
+        if (action.type === "add") {
+            const entry = await input.adapter.authorizeNewAccount(store);
+            const result = !entry ? undefined : await input.adapter.addAccount?.(store, entry);
+            const parsed = parseSharedActionResult(result);
+            if (!entry || !parsed.changed)
+                continue;
+            if (!parsed.persistHandled) {
+                await input.adapter.writeStore(store, {
+                    reason: "add-account",
+                    source: "menu-runtime",
+                    actionType: "add",
+                });
+            }
+            continue;
+        }
+        if (action.type === "remove-all") {
+            const result = await input.adapter.removeAllAccounts?.(store);
+            const parsed = parseSharedActionResult(result);
+            if (!parsed.changed)
+                continue;
+            if (!parsed.persistHandled) {
+                await input.adapter.writeStore(store, {
+                    reason: "remove-all",
+                    source: "menu-runtime",
+                    actionType: "remove-all",
+                });
+            }
+            continue;
+        }
+        if (action.type === "remove") {
+            const accountName = action.account.id ?? action.account.name;
+            const result = await input.adapter.removeAccount?.(store, accountName);
+            const parsed = parseSharedActionResult(result);
+            if (!parsed.changed)
+                continue;
+            if (!parsed.persistHandled) {
+                await input.adapter.writeStore(store, {
+                    reason: "remove-account",
+                    source: "menu-runtime",
+                    actionType: "remove",
+                });
+            }
+            continue;
+        }
+        if (action.type === "switch") {
+            const accountName = action.account.id ?? action.account.name;
+            const selected = input.adapter.getAccountByName(store, accountName);
+            if (!selected)
+                continue;
+            const switchResult = await input.adapter.switchAccount(store, selected.name, selected.entry);
+            if (!switchResult?.persistHandled) {
+                await input.adapter.writeStore(store, {
+                    reason: "persist-account-switch",
+                    source: "menu-runtime",
+                    actionType: "switch",
+                });
+            }
+            continue;
+        }
+        if (!input.adapter.applyAction)
+            continue;
+        const providerActionResult = parseProviderActionResult(await input.adapter.applyAction(store, action));
+        if (!providerActionResult.handled)
+            continue;
+        if (providerActionResult.result !== undefined) {
+            await input.onProviderActionResult?.({
+                name: action.name,
+                payload: action.payload,
+                result: providerActionResult.result,
+            });
+        }
+        if (isNonPersistentProviderAction(action.name))
+            continue;
+        if (providerActionResult.persistHandled)
+            continue;
+        await input.adapter.writeStore(store, {
+            reason: providerActionReason(action.name),
+            source: "menu-runtime",
+            actionType: action.name,
+        });
+    }
+}
+function parseProviderActionResult(result) {
+    if (typeof result === "object" && result) {
+        return {
+            handled: result.handled === true,
+            persistHandled: result.persistHandled === true,
+            result: result.result,
+        };
+    }
+    return {
+        handled: result === true,
+        persistHandled: false,
+        result: undefined,
+    };
+}

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

@@ -0,0 +1,33 @@
+export type NetworkRetryRequest = {
+    url: string;
+    method?: string;
+    body?: string;
+    headers?: Record<string, string>;
+};
+export type NetworkRetryClassification = {
+    retryable: boolean;
+    category: string;
+};
+export type NetworkRetryPolicy = {
+    matchesRequest: (request: Request | URL | string) => boolean;
+    classifyFailure: (input: {
+        error: unknown;
+        request: NetworkRetryRequest;
+    }) => Promise<NetworkRetryClassification>;
+    handleResponse?: (input: {
+        response: Response;
+        request: NetworkRetryRequest;
+    }) => Promise<Response>;
+    normalizeFailure?: (input: {
+        error: unknown;
+        classification: NetworkRetryClassification;
+        request: NetworkRetryRequest;
+    }) => unknown;
+    buildRepairPlan: (input: {
+        request: NetworkRetryRequest;
+        classification: NetworkRetryClassification;
+    }) => Promise<unknown>;
+};
+export declare function createNetworkRetryEngine(input: {
+    policy: NetworkRetryPolicy;
+}): (baseFetch: (request: Request | URL | string, init?: RequestInit) => Promise<Response>) => (request: Request | URL | string, init?: RequestInit) => Promise<Response>;

package/dist/network-retry-engine.js

@@ -0,0 +1,62 @@
+function toHeaderRecord(headers) {
+    if (!headers)
+        return undefined;
+    return Object.fromEntries(new Headers(headers).entries());
+}
+async function tryGetRequestBodyString(request, init) {
+    if (typeof init?.body === "string")
+        return init.body;
+    if (!(request instanceof Request))
+        return undefined;
+    try {
+        return await request.clone().text();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function toNetworkRetryRequest(request, init) {
+    const url = request instanceof Request ? request.url : request instanceof URL ? request.href : String(request);
+    const method = init?.method ?? (request instanceof Request ? request.method : undefined);
+    const headers = toHeaderRecord(init?.headers) ?? (request instanceof Request ? toHeaderRecord(request.headers) : undefined);
+    const body = await tryGetRequestBodyString(request, init);
+    return { url, method, headers, body };
+}
+export function createNetworkRetryEngine(input) {
+    return function wrapNetworkFetch(baseFetch) {
+        return async function retryingNetworkFetch(request, init) {
+            if (!input.policy.matchesRequest(request)) {
+                return baseFetch(request, init);
+            }
+            const normalizedRequest = await toNetworkRetryRequest(request, init);
+            try {
+                const response = await baseFetch(request, init);
+                if (!input.policy.handleResponse)
+                    return response;
+                return input.policy.handleResponse({
+                    response,
+                    request: normalizedRequest,
+                });
+            }
+            catch (error) {
+                const classification = await input.policy.classifyFailure({
+                    error,
+                    request: normalizedRequest,
+                });
+                if (!classification.retryable)
+                    throw error;
+                await input.policy.buildRepairPlan({
+                    request: normalizedRequest,
+                    classification,
+                });
+                if (!input.policy.normalizeFailure)
+                    throw error;
+                throw input.policy.normalizeFailure({
+                    error,
+                    classification,
+                    request: normalizedRequest,
+                });
+            }
+        };
+    };
+}

package/dist/plugin-hooks.d.ts

@@ -0,0 +1,49 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import { type FetchLike } from "./codex-network-retry.js";
+import { handleCodexStatusCommand } from "./codex-status-command.js";
+import { type CommonSettingsStore } from "./common-settings-store.js";
+import { type CodexAuthState, type CodexProviderConfig, type OfficialCodexChatHeadersHook, type OfficialCodexConfig } from "./upstream/codex-loader-adapter.js";
+type PluginHooks = Hooks;
+type AuthHook = NonNullable<PluginHooks["auth"]>;
+type CodexStatusCommandHandler = typeof handleCodexStatusCommand;
+type CodexClient = {
+    auth?: {
+        set?: (value: unknown) => Promise<unknown>;
+    };
+};
+type LoadOfficialConfig = (input: {
+    getAuth: () => Promise<CodexAuthState | undefined>;
+    provider?: CodexProviderConfig;
+    baseFetch?: typeof fetch;
+    version?: string;
+    client?: CodexClient;
+}) => Promise<OfficialCodexConfig | undefined>;
+type LoadOfficialChatHeaders = (input: {
+    client?: object;
+    directory?: string;
+    baseFetch?: typeof fetch;
+    version?: string;
+}) => Promise<OfficialCodexChatHeadersHook>;
+type CreateRetryFetch = (fetch: FetchLike) => FetchLike;
+type HookStore = CommonSettingsStore & {
+    accounts?: Record<string, unknown>;
+};
+export type BuildPluginHooksInput = {
+    auth: AuthHook;
+    loadStore?: () => Promise<HookStore | undefined>;
+    loadStoreSync?: () => HookStore | undefined;
+    loadCommonSettings?: () => Promise<CommonSettingsStore | undefined>;
+    loadCommonSettingsSync?: () => CommonSettingsStore | undefined;
+    loadOfficialConfig?: LoadOfficialConfig;
+    loadOfficialChatHeaders?: LoadOfficialChatHeaders;
+    createRetryFetch?: CreateRetryFetch;
+    client?: object;
+    directory?: string;
+    baseFetch?: typeof fetch;
+    version?: string;
+    handleCodexStatusCommandImpl?: CodexStatusCommandHandler;
+    authLoaderMode?: "codex" | "none";
+    enableModelRouting?: boolean;
+};
+export declare function buildPluginHooks(input: BuildPluginHooksInput): PluginHooks;
+export {};

package/dist/plugin-hooks.js

@@ -0,0 +1,123 @@
+import { createCodexRetryingFetch } from "./codex-network-retry.js";
+import { handleCodexStatusCommand } from "./codex-status-command.js";
+import { readCommonSettingsStore, readCommonSettingsStoreSync, } from "./common-settings-store.js";
+import { loadOfficialCodexChatHeaders, loadOfficialCodexConfig, } from "./upstream/codex-loader-adapter.js";
+function areExperimentalSlashCommandsEnabled(store) {
+    if (store?.experimentalSlashCommandsEnabled === false)
+        return false;
+    if (store?.experimentalStatusSlashCommandEnabled === false)
+        return false;
+    return true;
+}
+function isNetworkRetryEnabled(store) {
+    return store?.networkRetryEnabled === true;
+}
+function mergeStoreWithCommonSettings(store, common) {
+    if (!store && !common)
+        return undefined;
+    return {
+        ...(store ?? {}),
+        ...(common?.networkRetryEnabled === true || common?.networkRetryEnabled === false
+            ? { networkRetryEnabled: common.networkRetryEnabled }
+            : {}),
+        ...(common?.experimentalSlashCommandsEnabled === true || common?.experimentalSlashCommandsEnabled === false
+            ? { experimentalSlashCommandsEnabled: common.experimentalSlashCommandsEnabled }
+            : {}),
+        ...(common?.experimentalStatusSlashCommandEnabled === true || common?.experimentalStatusSlashCommandEnabled === false
+            ? { experimentalStatusSlashCommandEnabled: common.experimentalStatusSlashCommandEnabled }
+            : {}),
+    };
+}
+function ensureCommandConfig(config) {
+    if (!config.command)
+        config.command = {};
+    return config.command;
+}
+export function buildPluginHooks(input) {
+    const authProvider = input.auth.provider ?? "openai";
+    const authLoaderMode = input.authLoaderMode ?? "codex";
+    const loadStore = input.loadStore;
+    const loadStoreSync = input.loadStoreSync;
+    const loadCommonSettings = input.loadCommonSettings ?? (loadStore ? undefined : readCommonSettingsStore);
+    const loadCommonSettingsSync = input.loadCommonSettingsSync ?? (loadStoreSync ? undefined : readCommonSettingsStoreSync);
+    const loadOfficialConfig = input.loadOfficialConfig ?? loadOfficialCodexConfig;
+    const loadOfficialChatHeaders = input.loadOfficialChatHeaders ?? loadOfficialCodexChatHeaders;
+    const createRetryFetch = input.createRetryFetch ?? createCodexRetryingFetch;
+    const handleCodexStatusCommandImpl = input.handleCodexStatusCommandImpl ?? handleCodexStatusCommand;
+    const client = input.client;
+    const loadMergedStore = async () => {
+        const [store, common] = await Promise.all([
+            loadStore?.().catch(() => undefined) ?? Promise.resolve(undefined),
+            loadCommonSettings?.().catch(() => undefined) ?? Promise.resolve(undefined),
+        ]);
+        return mergeStoreWithCommonSettings(store, common);
+    };
+    const loadMergedStoreSync = () => {
+        const store = loadStoreSync?.();
+        const common = loadCommonSettingsSync?.();
+        return mergeStoreWithCommonSettings(store, common);
+    };
+    const authLoader = authLoaderMode === "codex"
+        ? async (getAuth, provider) => {
+            const config = await loadOfficialConfig({
+                getAuth: getAuth,
+                provider: provider,
+                baseFetch: input.baseFetch,
+                version: input.version,
+                client,
+            }).catch(() => undefined);
+            if (!config || typeof config.fetch !== "function")
+                return {};
+            const store = await loadMergedStore();
+            if (isNetworkRetryEnabled(store)) {
+                return {
+                    ...config,
+                    fetch: createRetryFetch(config.fetch),
+                };
+            }
+            return config;
+        }
+        : undefined;
+    const officialChatHeaders = authLoaderMode === "codex"
+        ? loadOfficialChatHeaders({
+            client: input.client,
+            directory: input.directory,
+            baseFetch: input.baseFetch,
+            version: input.version,
+        })
+        : Promise.resolve(async () => { });
+    const chatHeaders = async (hookInput, output) => {
+        if (hookInput.model.providerID !== authProvider)
+            return;
+        await (await officialChatHeaders)(hookInput, output);
+    };
+    const configHook = async (config) => {
+        const commands = ensureCommandConfig(config);
+        const store = loadMergedStoreSync();
+        if (!areExperimentalSlashCommandsEnabled(store))
+            return;
+        commands["codex-status"] = {
+            template: "Show the current Codex status and usage snapshot via the experimental status path.",
+            description: "Experimental Codex status command",
+        };
+    };
+    const commandBefore = async (hookInput) => {
+        if (hookInput.command !== "codex-status")
+            return;
+        const store = await loadMergedStore();
+        if (!areExperimentalSlashCommandsEnabled(store))
+            return;
+        await handleCodexStatusCommandImpl({ client });
+    };
+    return {
+        auth: {
+            ...input.auth,
+            provider: authProvider,
+            methods: input.auth.methods,
+            loader: authLoader,
+        },
+        config: configHook,
+        "command.execute.before": commandBefore,
+        "chat.headers": chatHeaders,
+    };
+}

package/dist/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const OpenAICodexAccountSwitcher: Plugin;