oc-codex-multi-auth 6.23.0 → 6.25.0

package/dist/index.d.ts

@@ -41,5 +41,11 @@ import type { Plugin } from "@opencode-ai/plugin";
  */
 export declare const OpenAIOAuthPlugin: Plugin;
 export declare const OpenAIAuthPlugin: Plugin;
-export default OpenAIOAuthPlugin;
+declare const _default: {
+    id: string;
+    server: Plugin;
+    /** V2 loads the same package through setup instead of the V1 server hook. */
+    setup(context: import("@opencode/plugin").Plugin.Context): Promise<() => Promise<void>>;
+};
+export default _default;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAYH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAsV/D;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MA+pJ/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAoB,CAAC;AAElD,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAYH,OAAO,KAAK,EAAE,MAAM,EAAsB,MAAM,qBAAqB,CAAC;AAsVtE;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MAA2E,CAAC;AAupJ5G,eAAO,MAAM,gBAAgB,QAAoB,CAAC;;;;IAKjD,6EAA6E;mBACxD,OAAO,kBAAkB,EAAE,MAAM,CAAC,OAAO;;AAJ/D,wBAQE"}

package/dist/index.js

@@ -179,8 +179,16 @@ function resolveOpenAIBaseURL() {
  * }
  * ```
  */
-export const OpenAIOAuthPlugin = async ({ client }) => {
-    initLogger(client);
+export const OpenAIOAuthPlugin = async ({ client }) => createPluginRuntime({ client });
+/**
+ * Shared request/account runtime; V2 has no V1 client or host auth.json.
+ *
+ * Not exported: V1 hosts call every function this module exports as a plugin,
+ * so an exported factory would boot a second runtime beside the real one. The
+ * V2 entry receives it through `setup` instead.
+ */
+async function createPluginRuntime({ client, directory = process.cwd() }) {
+    initLogger(client ?? {});
     let customBaseURLWarningShown = false;
     let customBaseURLErrorShown = false;
     let cachedAccountManager = null;
@@ -456,7 +464,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
     };
     const showToast = async (message, variant = "success", options) => {
         try {
-            await client.tui.showToast({
+            await client?.tui.showToast({
                 body: {
                     message,
                     variant,
@@ -1478,6 +1486,8 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
             if (event.type === "server.instance.disposed") {
                 quotaMonitor.dispose();
                 disposeAccountsWatcher();
+                await cachedAccountManager?.flushPendingSave();
+                cachedAccountManager?.disposeShutdownHandler();
                 return;
             }
             // Handle TUI account selection events
@@ -1585,8 +1595,9 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
     };
     const startupPluginConfig = loadPluginConfig();
     const startupPerProjectAccounts = getPerProjectAccounts(startupPluginConfig);
-    setStoragePath(startupPerProjectAccounts ? process.cwd() : null);
-    await backfillHostOpenAIAuthFromPool();
+    setStoragePath(startupPerProjectAccounts ? directory : null);
+    if (client)
+        await backfillHostOpenAIAuthFromPool();
     quotaMonitor.start();
     return {
         event: eventHandler,
@@ -1635,7 +1646,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                 let perProjectAccounts = getPerProjectAccounts(pluginConfig);
                 let storageTransition;
                 const activeFetches = new Set();
-                setStoragePath(perProjectAccounts ? process.cwd() : null);
+                setStoragePath(perProjectAccounts ? directory : null);
                 const authFallback = auth.type === "oauth" ? auth : undefined;
                 // Prefer multi-account auth metadata when available, but still handle
                 // plain OAuth credentials (for OpenCode versions that inject internal
@@ -1744,8 +1755,8 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                             prewarmOpenCodeCodexPrompt();
                         }
                     }
-                    const recoveryHook = sessionRecoveryEnabled
-                        ? createSessionRecoveryHook({ client, directory: process.cwd() }, { sessionRecovery: true, autoResume: autoResumeEnabled })
+                    const recoveryHook = sessionRecoveryEnabled && client
+                        ? createSessionRecoveryHook({ client, directory }, { sessionRecovery: true, autoResume: autoResumeEnabled })
                         : null;
                     const pluginOrigin = getPluginOrigin();
                     if (pluginOrigin && !startupOriginRecorded) {
@@ -1800,7 +1811,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                         await Promise.all(activeFetches);
                                         // Drain the old pool's pending write before changing the global path.
                                         await cachedAccountManager?.flushPendingSave();
-                                        setStoragePath(currentPerProjectAccounts ? process.cwd() : null);
+                                        setStoragePath(currentPerProjectAccounts ? directory : null);
                                         invalidateAccountManagerCache();
                                         perProjectAccounts = currentPerProjectAccounts;
                                     })().finally(() => { storageTransition = undefined; });
@@ -2203,7 +2214,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                             accountManager = reloaded;
                                         }
                                     }
-                                    let accountCount = accountManager.getAccountCount();
+                                    const accountCount = accountManager.getAccountCount();
                                     const attempted = new Set();
                                     // Diagnostics for the terminal error message below. The composite key keeps
                                     // legacy Business seats distinct and can also be compared with snapshots
@@ -2303,9 +2314,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                             runtimeMetrics.lastError = err?.message ?? String(err);
                                             runtimeMetrics.lastErrorCategory = "auth-refresh";
                                             // Transient refresh failures (network blip / upstream 5xx) must NOT
-                                            // count toward permanent account removal — the credentials are still
-                                            // valid and a flaky network or outage would otherwise silently delete
-                                            // them. Cool the account down briefly and rotate instead.
+                                            // count toward disabling an account. Cool it down and rotate instead.
                                             const isTransientRefreshFailure = err instanceof CodexAuthError && err.retryable === true;
                                             if (isTransientRefreshFailure) {
                                                 const cooledCount = accountManager.markAccountsWithRefreshTokenCoolingDown(account.refreshToken, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
@@ -2313,7 +2322,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                                     accountManager.markAccountCoolingDown(account, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
                                                 }
                                                 accountManager.saveToDiskDebounced();
-                                                logWarn(`[${PLUGIN_NAME}] Transient auth refresh failure for account ${account.index + 1} (${err.refreshFailureReason ?? "unknown"}${err.statusCode ? ` ${err.statusCode}` : ""}); cooling down without counting toward removal.`);
+                                                logWarn(`[${PLUGIN_NAME}] Transient auth refresh failure for account ${account.index + 1} (${err.refreshFailureReason ?? "unknown"}${err.statusCode ? ` ${err.statusCode}` : ""}); cooling down without disabling.`);
                                                 continue;
                                             }
                                             const failures = await accountManager.incrementAuthFailures(account);
@@ -2322,27 +2331,19 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                                 peerAccounts: accountManager.getAccountsSnapshot(),
                                             });
                                             if (failures >= ACCOUNT_LIMITS.MAX_AUTH_FAILURES_BEFORE_REMOVAL) {
-                                                const removedCount = accountManager.removeAccountsWithSameRefreshToken(account);
-                                                if (removedCount <= 0) {
-                                                    logWarn(`[${PLUGIN_NAME}] Expected grouped account removal after auth failures, but removed ${removedCount}.`);
-                                                    const cooledCount = accountManager.markAccountsWithRefreshTokenCoolingDown(account.refreshToken, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
-                                                    if (cooledCount <= 0) {
-                                                        logWarn(`[${PLUGIN_NAME}] Unable to apply auth-failure cooldown; no live account found for refresh token.`);
-                                                    }
+                                                const disabledCount = accountManager.disableAccountsWithSameRefreshToken(account);
+                                                if (disabledCount > 0) {
                                                     accountManager.saveToDiskDebounced();
+                                                    await showToast(disabledCount > 1
+                                                        ? `Disabled ${disabledCount} accounts after ${failures} auth failures; credentials retained. Run 'opencode auth login' to repair.`
+                                                        : `Disabled ${accountLabel} after ${failures} auth failures; credentials retained. Run 'opencode auth login' to repair.`, "error", { duration: toastDurationMs * 2 });
                                                     continue;
                                                 }
-                                                accountManager.saveToDiskDebounced();
-                                                const removalMessage = removedCount > 1
-                                                    ? `Removed ${removedCount} accounts (same refresh token) after ${failures} consecutive auth failures. Run 'opencode auth login' to re-add.`
-                                                    : `Removed ${accountLabel} after ${failures} consecutive auth failures. Run 'opencode auth login' to re-add.`;
-                                                await showToast(removalMessage, "error", { duration: toastDurationMs * 2 });
-                                                // Restart traversal: clear attempted and refresh accountCount to avoid skipping healthy accounts
-                                                attempted.clear();
-                                                accountCount = accountManager.getAccountCount();
-                                                continue;
                                             }
-                                            accountManager.markAccountCoolingDown(account, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
+                                            const cooledCount = accountManager.markAccountsWithRefreshTokenCoolingDown(account.refreshToken, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
+                                            if (cooledCount <= 0) {
+                                                accountManager.markAccountCoolingDown(account, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
+                                            }
                                             accountManager.saveToDiskDebounced();
                                             continue;
                                         }
@@ -2605,23 +2606,22 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                                     catch (flagError) {
                                                         logWarn(`Failed to persist deactivated workspace flag for ${accountLabel}: ${flagError instanceof Error ? flagError.message : String(flagError)}`);
                                                     }
-                                                    // Remove ONLY the deactivated workspace, scoped by workspace
+                                                    // Disable ONLY the deactivated workspace, scoped by workspace
                                                     // identity (org/account id). A single multi-org OAuth login
                                                     // produces sibling accounts that share one refresh token but are
-                                                    // independently valid; removing all refresh-token siblings here
+                                                    // independently valid; disabling all refresh-token siblings here
                                                     // would silently drop still-valid workspaces from rotation. The
                                                     // refresh token itself is still good, so siblings must survive.
-                                                    const removedCount = accountManager.removeAccountsByWorkspaceIdentity(account);
-                                                    if (removedCount > 0) {
+                                                    const disabledCount = accountManager.disableAccountsByWorkspaceIdentity(account);
+                                                    if (disabledCount > 0) {
                                                         accountManager.saveToDiskDebounced();
                                                         restartAccountTraversalAfterWorkspaceDeactivation = true;
-                                                        const removalMessage = removedCount > 1
-                                                            ? `Workspace deactivated. Removed ${removedCount} related entries from rotation and switching accounts.`
-                                                            : `Workspace deactivated. Removed ${accountLabel} from rotation and switching accounts.`;
+                                                        const removalMessage = disabledCount > 1
+                                                            ? `Workspace deactivated. Disabled ${disabledCount} related entries; credentials retained.`
+                                                            : `Workspace deactivated. Disabled ${accountLabel}; credentials retained.`;
                                                         await showToast(removalMessage, "warning", { duration: toastDurationMs });
                                                         break;
                                                     }
-                                                    logWarn(`[${PLUGIN_NAME}] Expected grouped account removal after workspace deactivation, but removed ${removedCount}.`);
                                                     accountManager.markAccountCoolingDown(account, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
                                                     accountManager.saveToDiskDebounced();
                                                     break;
@@ -2782,7 +2782,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                                 // explicit handler the 401 fell straight through to `return errorResponse`
                                                 // below, so persisted family routing kept pinning every request to the dead
                                                 // account slot instead of failing over (issue #171). Treat it as an
-                                                // account-health failure: cool the refresh-token group down (or remove it
+                                                // account-health failure: cool the refresh-token group down (or disable it
                                                 // past the failure threshold) and rotate to the next healthy account.
                                                 //
                                                 // Note: 401s intentionally do NOT feed the circuit breaker — the breaker
@@ -2802,21 +2802,16 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                                     runtimeMetrics.lastErrorCategory = "auth-invalidated";
                                                     const failures = await accountManager.incrementAuthFailures(account);
                                                     if (failures >= ACCOUNT_LIMITS.MAX_AUTH_FAILURES_BEFORE_REMOVAL) {
-                                                        const removedCount = accountManager.removeAccountsWithSameRefreshToken(account);
-                                                        if (removedCount > 0) {
+                                                        const disabledCount = accountManager.disableAccountsWithSameRefreshToken(account);
+                                                        if (disabledCount > 0) {
                                                             accountManager.saveToDiskDebounced();
-                                                            await showToast(removedCount > 1
-                                                                ? `Removed ${removedCount} accounts (same refresh token) after ${failures} auth-token failures. Run 'opencode auth login' to re-add.`
-                                                                : `Removed ${accountLabel} after ${failures} auth-token failures. Run 'opencode auth login' to re-add.`, "error", { duration: toastDurationMs * 2 });
-                                                            // Indices shift after removal; restart traversal with a fresh
-                                                            // attempted set so no healthy account is skipped.
-                                                            attempted.clear();
-                                                            accountCount = accountManager.getAccountCount();
+                                                            await showToast(disabledCount > 1
+                                                                ? `Disabled ${disabledCount} accounts after ${failures} auth-token failures; credentials retained. Run 'opencode auth login' to repair.`
+                                                                : `Disabled ${accountLabel} after ${failures} auth-token failures; credentials retained. Run 'opencode auth login' to repair.`, "error", { duration: toastDurationMs * 2 });
                                                             break;
                                                         }
-                                                        logWarn(`[${PLUGIN_NAME}] Expected grouped account removal after auth-token invalidation, but removed ${removedCount}.`);
                                                     }
-                                                    // Below the removal threshold (or grouped removal was a no-op): cool the
+                                                    // Below the disable threshold (or the group was already disabled): cool the
                                                     // account's whole refresh-token group down so selection skips it, then
                                                     // rotate to the next healthy account instead of returning the 401.
                                                     const cooledCount = accountManager.markAccountsWithRefreshTokenCoolingDown(account.refreshToken, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
@@ -3127,7 +3122,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                         const authPluginConfig = loadPluginConfig();
                         applyUiRuntimeFromConfig(authPluginConfig);
                         const authPerProjectAccounts = getPerProjectAccounts(authPluginConfig);
-                        setStoragePath(authPerProjectAccounts ? process.cwd() : null);
+                        setStoragePath(authPerProjectAccounts ? directory : null);
                         const accounts = [];
                         // Programmatic input, not a menu choice: a headless caller or
                         // script passes it to say "never launch a browser". Ignoring it
@@ -3886,7 +3881,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                         const manualBrowserPluginConfig = loadPluginConfig();
                         applyUiRuntimeFromConfig(manualBrowserPluginConfig);
                         const manualBrowserPerProjectAccounts = getPerProjectAccounts(manualBrowserPluginConfig);
-                        setStoragePath(manualBrowserPerProjectAccounts ? process.cwd() : null);
+                        setStoragePath(manualBrowserPerProjectAccounts ? directory : null);
                         const session = await startLoopbackFlow({ openBrowser: false });
                         if (session.type === "unavailable") {
                             const message = unavailableMessage(session.lifecycle);
@@ -3934,7 +3929,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                         const devicePluginConfig = loadPluginConfig();
                         applyUiRuntimeFromConfig(devicePluginConfig);
                         const devicePerProjectAccounts = getPerProjectAccounts(devicePluginConfig);
-                        setStoragePath(devicePerProjectAccounts ? process.cwd() : null);
+                        setStoragePath(devicePerProjectAccounts ? directory : null);
                         const started = await createDeviceCodeSession();
                         if (started.type === "failed") {
                             return {
@@ -3972,7 +3967,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                         const manualPluginConfig = loadPluginConfig();
                         applyUiRuntimeFromConfig(manualPluginConfig);
                         const manualPerProjectAccounts = getPerProjectAccounts(manualPluginConfig);
-                        setStoragePath(manualPerProjectAccounts ? process.cwd() : null);
+                        setStoragePath(manualPerProjectAccounts ? directory : null);
                         const { pkce, state, url } = await createAuthorizationFlow();
                         return buildManualOAuthFlow(pkce, url, state, false);
                     },
@@ -3981,7 +3976,16 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
         },
         tool: createToolRegistry(ctx),
     };
-};
+}
+;
 export const OpenAIAuthPlugin = OpenAIOAuthPlugin;
-export default OpenAIOAuthPlugin;
+export default {
+    id: "oc-codex-multi-auth",
+    server: OpenAIOAuthPlugin,
+    /** V2 loads the same package through setup instead of the V1 server hook. */
+    async setup(context) {
+        const { setupV2 } = await import("./lib/opencode-v2.js");
+        return setupV2(context, createPluginRuntime);
+    },
+};
 //# sourceMappingURL=index.js.map