oc-chatgpt-multi-auth 4.11.2 → 4.12.1

package/README.md

@@ -254,12 +254,14 @@ opencode auth login  # Run again to add more accounts
 
 The plugin provides built-in tools for managing your OpenAI accounts. These are available directly in OpenCode — just ask the agent or type the tool name.
 
-### openai-accounts
+> **Note:** Tools were renamed from `openai-accounts-*` to `codex-*` in v4.12.0 for brevity.
+
+### codex-list
 
 List all configured accounts with their status.
 
 ```
-openai-accounts
+codex-list
 ```
 
 **Output:**
@@ -270,17 +272,17 @@ OpenAI Accounts (3 total):
   [2] work@company.com
   [3] backup@email.com
 
-Use openai-accounts-switch to change active account.
+Use codex-switch to change active account.
 ```
 
 ---
 
-### openai-accounts-switch
+### codex-switch
 
 Switch to a different account by index (1-based).
 
 ```
-openai-accounts-switch index=2
+codex-switch index=2
 ```
 
 **Output:**
@@ -290,12 +292,12 @@ Switched to account [2] work@company.com
 
 ---
 
-### openai-accounts-status
+### codex-status
 
 Show detailed status including rate limits and health scores.
 
 ```
-openai-accounts-status
+codex-status
 ```
 
 **Output:**
@@ -317,12 +319,12 @@ OpenAI Account Status:
 
 ---
 
-### openai-accounts-health
+### codex-health
 
 Check if all account tokens are still valid (read-only check).
 
 ```
-openai-accounts-health
+codex-health
 ```
 
 **Output:**
@@ -338,12 +340,12 @@ Summary: 2 healthy, 1 unhealthy
 
 ---
 
-### openai-accounts-refresh
+### codex-refresh
 
 Refresh all OAuth tokens and save them to disk. Use this after long idle periods.
 
 ```
-openai-accounts-refresh
+codex-refresh
 ```
 
 **Output:**
@@ -357,16 +359,16 @@ Refreshing 3 account(s):
 Summary: 2 refreshed, 1 failed
 ```
 
-**Difference from health check:** `openai-accounts-health` only validates tokens. `openai-accounts-refresh` actually refreshes them and saves new tokens to disk.
+**Difference from health check:** `codex-health` only validates tokens. `codex-refresh` actually refreshes them and saves new tokens to disk.
 
 ---
 
-### openai-accounts-remove
+### codex-remove
 
 Remove an account by index. Useful for cleaning up expired accounts.
 
 ```
-openai-accounts-remove index=3
+codex-remove index=3
 ```
 
 **Output:**
@@ -378,16 +380,50 @@ Remaining accounts: 2
 
 ---
 
+### codex-export
+
+Export all accounts to a portable JSON file. Useful for backup or migration.
+
+```
+codex-export path="~/backup/accounts.json"
+```
+
+**Output:**
+```
+Exported 3 account(s) to ~/backup/accounts.json
+```
+
+---
+
+### codex-import
+
+Import accounts from a JSON file (exported via `codex-export`). Merges with existing accounts.
+
+```
+codex-import path="~/backup/accounts.json"
+```
+
+**Output:**
+```
+Imported 2 new account(s) (1 duplicate skipped)
+
+Total accounts: 4
+```
+
+---
+
 ### Quick Reference
 
 | Tool | What It Does | Example |
 |------|--------------|---------|
-| `openai-accounts` | List all accounts | "list my accounts" |
-| `openai-accounts-switch` | Switch active account | "switch to account 2" |
-| `openai-accounts-status` | Show rate limits & health | "show account status" |
-| `openai-accounts-health` | Validate tokens (read-only) | "check account health" |
-| `openai-accounts-refresh` | Refresh & save tokens | "refresh my tokens" |
-| `openai-accounts-remove` | Remove an account | "remove account 3" |
+| `codex-list` | List all accounts | "list my accounts" |
+| `codex-switch` | Switch active account | "switch to account 2" |
+| `codex-status` | Show rate limits & health | "show account status" |
+| `codex-health` | Validate tokens (read-only) | "check account health" |
+| `codex-refresh` | Refresh & save tokens | "refresh my tokens" |
+| `codex-remove` | Remove an account | "remove account 3" |
+| `codex-export` | Export accounts to file | "export my accounts" |
+| `codex-import` | Import accounts from file | "import accounts from backup" |
 
 ---
 

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AA0E/D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAs6C/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;AAGH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AA0E/D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAi/C/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAoB,CAAC;AAElD,eAAe,iBAAiB,CAAC"}

package/dist/index.js

@@ -30,11 +30,11 @@ import { startLocalOAuthServer } from "./lib/auth/server.js";
 import { promptAccountSelection, promptLoginMode } from "./lib/cli.js";
 import { getCodexMode, getRateLimitToastDebounceMs, getRetryAllAccountsMaxRetries, getRetryAllAccountsMaxWaitMs, getRetryAllAccountsRateLimited, getTokenRefreshSkewMs, getSessionRecovery, getAutoResume, getToastDurationMs, getPerProjectAccounts, loadPluginConfig, } from "./lib/config.js";
 import { AUTH_LABELS, CODEX_BASE_URL, DUMMY_API_KEY, LOG_STAGES, PLUGIN_NAME, PROVIDER_ID, ACCOUNT_LIMITS, } from "./lib/constants.js";
-import { initLogger, logRequest, logDebug, logInfo, logWarn } from "./lib/logger.js";
+import { initLogger, logRequest, logDebug, logInfo, logWarn, logError } from "./lib/logger.js";
 import { checkAndNotify } from "./lib/auto-update-checker.js";
 import { handleContextOverflow } from "./lib/context-overflow.js";
 import { AccountManager, getAccountIdCandidates, extractAccountEmail, extractAccountId, formatAccountLabel, formatCooldown, formatWaitTime, sanitizeEmail, shouldUpdateAccountIdFromToken, } from "./lib/accounts.js";
-import { getStoragePath, loadAccounts, saveAccounts, setStoragePath } from "./lib/storage.js";
+import { getStoragePath, loadAccounts, saveAccounts, setStoragePath, exportAccounts, importAccounts, StorageError, formatStorageErrorHint } from "./lib/storage.js";
 import { createCodexHeaders, extractRequestUrl, handleErrorResponse, handleSuccessResponse, refreshAndUpdateToken, rewriteUrlForCodex, shouldRefreshToken, transformRequestForCodex, } from "./lib/request/fetch-helpers.js";
 import { getRateLimitBackoff, RATE_LIMIT_SHORT_RETRY_THRESHOLD_MS, resetRateLimitBackoff, } from "./lib/request/rate-limit-backoff.js";
 import { addJitter } from "./lib/rotation.js";
@@ -573,7 +573,8 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                     continue;
                                 }
                                 const hadAccountId = !!account.accountId;
-                                const accountId = account.accountId ?? extractAccountId(accountAuth.access);
+                                // Prefer fresh token-derived ID over stored ID (fixes Business plan workspace issues)
+                                const accountId = extractAccountId(accountAuth.access) ?? account.accountId;
                                 if (!accountId) {
                                     accountManager.markAccountCoolingDown(account, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
                                     accountManager.saveToDiskDebounced();
@@ -596,14 +597,26 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                     promptCacheKey,
                                 });
                                 while (true) {
-                                    const response = await fetch(url, {
-                                        ...requestInit,
-                                        headers,
-                                    });
+                                    let response;
+                                    const fetchStart = performance.now();
+                                    try {
+                                        response = await fetch(url, {
+                                            ...requestInit,
+                                            headers,
+                                        });
+                                    }
+                                    catch (networkError) {
+                                        const errorMsg = networkError instanceof Error ? networkError.message : String(networkError);
+                                        logWarn(`Network error for account ${account.index + 1}: ${errorMsg}`);
+                                        accountManager.recordFailure(account, modelFamily, model);
+                                        break;
+                                    }
+                                    const fetchLatencyMs = Math.round(performance.now() - fetchStart);
                                     logRequest(LOG_STAGES.RESPONSE, {
                                         status: response.status,
                                         ok: response.ok,
                                         statusText: response.statusText,
+                                        latencyMs: fetchLatencyMs,
                                         headers: Object.fromEntries(response.headers.entries()),
                                     });
                                     if (!response.ok) {
@@ -663,7 +676,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                             }
                             const waitLabel = waitMs > 0 ? formatWaitTime(waitMs) : "a bit";
                             const message = count === 0
-                                ? "No OpenAI accounts configured. Run `opencode auth login`."
+                                ? "No Codex accounts configured. Run `opencode auth login`."
                                 : `All ${count} account(s) are rate-limited. Try again in ${waitLabel} or add another account with \`opencode auth login\`.`;
                             return new Response(JSON.stringify({ error: { message } }), {
                                 status: 429,
@@ -783,9 +796,10 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                 }
                                 catch (err) {
                                     const storagePath = getStoragePath();
-                                    logWarn(`[${PLUGIN_NAME}] Failed to persist account to disk: ${err?.message ?? String(err)}`);
-                                    logWarn(`Storage path: ${storagePath}`);
-                                    await showToast(`Account authenticated but failed to save to disk. Storage path: ${storagePath}`, "warning", { title: "Account Persistence Failed", duration: 10000 });
+                                    const errorCode = err?.code || "UNKNOWN";
+                                    const hint = err instanceof StorageError ? err.hint : formatStorageErrorHint(err, storagePath);
+                                    logError(`[${PLUGIN_NAME}] Failed to persist account: [${errorCode}] ${err?.message ?? String(err)}`);
+                                    await showToast(hint, "error", { title: "Account Persistence Failed", duration: 10000 });
                                 }
                             });
                         }
@@ -832,9 +846,10 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                             }
                             catch (err) {
                                 const storagePath = getStoragePath();
-                                logWarn(`[${PLUGIN_NAME}] Failed to persist account to disk: ${err?.message ?? String(err)}`);
-                                logWarn(`Storage path: ${storagePath}`);
-                                await showToast(`Account authenticated but failed to save to disk. Storage path: ${storagePath}`, "warning", { title: "Account Persistence Failed", duration: 10000 });
+                                const errorCode = err?.code || "UNKNOWN";
+                                const hint = err instanceof StorageError ? err.hint : formatStorageErrorHint(err, storagePath);
+                                logError(`[${PLUGIN_NAME}] Failed to persist account: [${errorCode}] ${err?.message ?? String(err)}`);
+                                await showToast(hint, "error", { title: "Account Persistence Failed", duration: 10000 });
                             }
                             if (accounts.length >= ACCOUNT_LIMITS.MAX_ACCOUNTS) {
                                 break;
@@ -880,9 +895,10 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                             }
                             catch (err) {
                                 const storagePath = getStoragePath();
-                                logWarn(`[${PLUGIN_NAME}] Failed to persist account to disk: ${err?.message ?? String(err)}`);
-                                logWarn(`Storage path: ${storagePath}`);
-                                await showToast(`Account authenticated but failed to save to disk. Storage path: ${storagePath}`, "warning", { title: "Account Persistence Failed", duration: 10000 });
+                                const errorCode = err?.code || "UNKNOWN";
+                                const hint = err instanceof StorageError ? err.hint : formatStorageErrorHint(err, storagePath);
+                                logError(`[${PLUGIN_NAME}] Failed to persist account: [${errorCode}] ${err?.message ?? String(err)}`);
+                                await showToast(hint, "error", { title: "Account Persistence Failed", duration: 10000 });
                             }
                         });
                     },
@@ -890,15 +906,15 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
             ],
         },
         tool: {
-            "openai-accounts": tool({
-                description: "List all OpenAI OAuth accounts and the current active index.",
+            "codex-list": tool({
+                description: "List all Codex OAuth accounts and the current active index.",
                 args: {},
                 async execute() {
                     const storage = await loadAccounts();
                     const storePath = getStoragePath();
                     if (!storage || storage.accounts.length === 0) {
                         return [
-                            "No OpenAI accounts configured.",
+                            "No Codex accounts configured.",
                             "",
                             "Add accounts:",
                             "  opencode auth login",
@@ -909,7 +925,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     const now = Date.now();
                     const activeIndex = resolveActiveIndex(storage, "codex");
                     const lines = [
-                        `OpenAI Accounts (${storage.accounts.length}):`,
+                        `Codex Accounts (${storage.accounts.length}):`,
                         "",
                         " #  Label                                     Status",
                         "----------------------------------------------- ---------------------",
@@ -936,20 +952,20 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     lines.push("");
                     lines.push("Commands:");
                     lines.push("  - Add account: opencode auth login");
-                    lines.push("  - Switch account: openai-accounts-switch");
-                    lines.push("  - Status details: openai-accounts-status");
+                    lines.push("  - Switch account: codex-switch");
+                    lines.push("  - Status details: codex-status");
                     return lines.join("\n");
                 },
             }),
-            "openai-accounts-switch": tool({
-                description: "Switch active OpenAI account by index (1-based).",
+            "codex-switch": tool({
+                description: "Switch active Codex account by index (1-based).",
                 args: {
                     index: tool.schema.number().describe("Account number to switch to (1-based, e.g., 1 for first account)"),
                 },
                 async execute({ index }) {
                     const storage = await loadAccounts();
                     if (!storage || storage.accounts.length === 0) {
-                        return "No OpenAI accounts configured. Run: opencode auth login";
+                        return "No Codex accounts configured. Run: opencode auth login";
                     }
                     const targetIndex = Math.floor((index ?? 0) - 1);
                     if (!Number.isFinite(targetIndex) ||
@@ -968,7 +984,13 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     for (const family of MODEL_FAMILIES) {
                         storage.activeIndexByFamily[family] = targetIndex;
                     }
-                    await saveAccounts(storage);
+                    try {
+                        await saveAccounts(storage);
+                    }
+                    catch (saveError) {
+                        logWarn("Failed to save account switch", { error: String(saveError) });
+                        return `Switched to ${formatAccountLabel(account, targetIndex)} but failed to persist. Changes may be lost on restart.`;
+                    }
                     if (cachedAccountManager) {
                         cachedAccountManager.setActiveIndex(targetIndex);
                         await cachedAccountManager.saveToDisk();
@@ -977,13 +999,13 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     return `Switched to account: ${label}`;
                 },
             }),
-            "openai-accounts-status": tool({
-                description: "Show detailed status of OpenAI accounts and rate limits.",
+            "codex-status": tool({
+                description: "Show detailed status of Codex accounts and rate limits.",
                 args: {},
                 async execute() {
                     const storage = await loadAccounts();
                     if (!storage || storage.accounts.length === 0) {
-                        return "No OpenAI accounts configured. Run: opencode auth login";
+                        return "No Codex accounts configured. Run: opencode auth login";
                     }
                     const now = Date.now();
                     const activeIndex = resolveActiveIndex(storage, "codex");
@@ -1025,13 +1047,13 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     return lines.join("\n");
                 },
             }),
-            "openai-accounts-health": tool({
-                description: "Check health of all OpenAI accounts by validating refresh tokens.",
+            "codex-health": tool({
+                description: "Check health of all Codex accounts by validating refresh tokens.",
                 args: {},
                 async execute() {
                     const storage = await loadAccounts();
                     if (!storage || storage.accounts.length === 0) {
-                        return "No OpenAI accounts configured. Run: opencode auth login";
+                        return "No Codex accounts configured. Run: opencode auth login";
                     }
                     const results = [
                         `Health Check (${storage.accounts.length} accounts):`,
@@ -1057,7 +1079,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                         }
                         catch (error) {
                             const errorMsg = error instanceof Error ? error.message : String(error);
-                            results.push(`  ✗ ${label}: Error - ${errorMsg.slice(0, 50)}`);
+                            results.push(`  ✗ ${label}: Error - ${errorMsg.slice(0, 120)}`);
                             unhealthyCount++;
                         }
                     }
@@ -1066,21 +1088,21 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     return results.join("\n");
                 },
             }),
-            "openai-accounts-remove": tool({
-                description: "Remove an OpenAI account by index (1-based). Use openai-accounts to list accounts first.",
+            "codex-remove": tool({
+                description: "Remove a Codex account by index (1-based). Use codex-list to list accounts first.",
                 args: {
                     index: tool.schema.number().describe("Account number to remove (1-based, e.g., 1 for first account)"),
                 },
                 async execute({ index }) {
                     const storage = await loadAccounts();
                     if (!storage || storage.accounts.length === 0) {
-                        return "No OpenAI accounts configured. Nothing to remove.";
+                        return "No Codex accounts configured. Nothing to remove.";
                     }
                     const targetIndex = Math.floor((index ?? 0) - 1);
                     if (!Number.isFinite(targetIndex) ||
                         targetIndex < 0 ||
                         targetIndex >= storage.accounts.length) {
-                        return `Invalid account number: ${index}\n\nValid range: 1-${storage.accounts.length}\n\nUse openai-accounts to list all accounts.`;
+                        return `Invalid account number: ${index}\n\nValid range: 1-${storage.accounts.length}\n\nUse codex-list to list all accounts.`;
                     }
                     const account = storage.accounts[targetIndex];
                     if (!account) {
@@ -1113,7 +1135,13 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                             }
                         }
                     }
-                    await saveAccounts(storage);
+                    try {
+                        await saveAccounts(storage);
+                    }
+                    catch (saveError) {
+                        logWarn("Failed to save account removal", { error: String(saveError) });
+                        return `Removed ${formatAccountLabel(account, targetIndex)} from memory but failed to persist. Changes may be lost on restart.`;
+                    }
                     if (cachedAccountManager) {
                         const managedAccounts = cachedAccountManager.getAccountsSnapshot();
                         const managedAccount = managedAccounts.find((acc) => acc.refreshToken === account.refreshToken);
@@ -1132,13 +1160,13 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     ].join("\n");
                 },
             }),
-            "openai-accounts-refresh": tool({
+            "codex-refresh": tool({
                 description: "Manually refresh OAuth tokens for all accounts to verify they're still valid.",
                 args: {},
                 async execute() {
                     const storage = await loadAccounts();
                     if (!storage || storage.accounts.length === 0) {
-                        return "No OpenAI accounts configured. Run: opencode auth login";
+                        return "No Codex accounts configured. Run: opencode auth login";
                     }
                     const results = [
                         `Refreshing ${storage.accounts.length} account(s):`,
@@ -1165,7 +1193,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                         }
                         catch (error) {
                             const errorMsg = error instanceof Error ? error.message : String(error);
-                            results.push(`  ✗ ${label}: Error - ${errorMsg.slice(0, 50)}`);
+                            results.push(`  ✗ ${label}: Error - ${errorMsg.slice(0, 120)}`);
                             failedCount++;
                         }
                     }
@@ -1175,6 +1203,50 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                     return results.join("\n");
                 },
             }),
+            "codex-export": tool({
+                description: "Export accounts to a JSON file for backup or migration to another machine.",
+                args: {
+                    path: tool.schema.string().describe("File path to export to (e.g., ~/codex-backup.json)"),
+                    force: tool.schema.boolean().optional().describe("Overwrite existing file (default: true)"),
+                },
+                async execute({ path: filePath, force }) {
+                    try {
+                        await exportAccounts(filePath, force ?? true);
+                        const storage = await loadAccounts();
+                        const count = storage?.accounts.length ?? 0;
+                        return `Exported ${count} account(s) to: ${filePath}`;
+                    }
+                    catch (error) {
+                        const msg = error instanceof Error ? error.message : String(error);
+                        return `Export failed: ${msg}`;
+                    }
+                },
+            }),
+            "codex-import": tool({
+                description: "Import accounts from a JSON file, merging with existing accounts.",
+                args: {
+                    path: tool.schema.string().describe("File path to import from (e.g., ~/codex-backup.json)"),
+                },
+                async execute({ path: filePath }) {
+                    try {
+                        const result = await importAccounts(filePath);
+                        cachedAccountManager = null;
+                        const lines = [`Import complete.`, ``];
+                        if (result.imported > 0) {
+                            lines.push(`New accounts: ${result.imported}`);
+                        }
+                        if (result.skipped > 0) {
+                            lines.push(`Duplicates skipped: ${result.skipped}`);
+                        }
+                        lines.push(`Total accounts: ${result.total}`);
+                        return lines.join("\n");
+                    }
+                    catch (error) {
+                        const msg = error instanceof Error ? error.message : String(error);
+                        return `Import failed: ${msg}`;
+                    }
+                },
+            }),
         },
     };
 };