oc-chatgpt-multi-auth 5.4.5 → 5.4.6

package/README.md

@@ -32,6 +32,7 @@ What the installer does:
 
 - writes `~/.config/opencode/opencode.json`
 - backs up an existing config before changing it
+- normalizes the plugin entry to `"oc-chatgpt-multi-auth"`
 - clears the cached plugin copy so OpenCode reinstalls the latest package
 
 ## Example Usage
@@ -120,7 +121,7 @@ Start here if the plugin does not load or authenticate correctly:
 
 Common first checks:
 
-- confirm `"plugin": ["oc-chatgpt-multi-auth@latest"]` is present in your OpenCode config
+- confirm `"plugin": ["oc-chatgpt-multi-auth"]` is present in your OpenCode config
 - rerun `opencode auth login`
 - inspect `~/.opencode/logs/codex-plugin/` after running one request with `ENABLE_PLUGIN_REQUEST_LOGGING=1`
 

package/config/README.md

@@ -6,8 +6,8 @@ This directory contains the official OpenCode config templates for the ChatGPT C
 
 | File | OpenCode version | Description |
 |------|------------------|-------------|
-| [`opencode-modern.json`](./opencode-modern.json) | **v1.0.210+** | Variant-based config: 6 base models with 21 total presets |
-| [`opencode-legacy.json`](./opencode-legacy.json) | **v1.0.209 and below** | Legacy explicit entries: 21 individual model definitions |
+| [`opencode-modern.json`](./opencode-modern.json) | **v1.0.210+** | Variant-based config: 7 base models with 26 total presets |
+| [`opencode-legacy.json`](./opencode-legacy.json) | **v1.0.209 and below** | Legacy explicit entries: 26 individual model definitions |
 
 ## Quick pick
 
@@ -34,11 +34,13 @@ opencode --version
 OpenCode v1.0.210+ added model `variants`, so one model entry can expose multiple reasoning levels. That keeps modern config much smaller while preserving the same effective presets.
 
 Both templates include:
-- GPT-5.4, GPT-5 Codex, GPT-5.1, GPT-5.1 Codex, GPT-5.1 Codex Max, GPT-5.1 Codex Mini
+- GPT-5.4, GPT-5.4 Mini, GPT-5 Codex, GPT-5.1, GPT-5.1 Codex, GPT-5.1 Codex Max, GPT-5.1 Codex Mini
 - Reasoning variants per model family
 - `store: false` and `include: ["reasoning.encrypted_content"]`
 - Context metadata (`gpt-5.4*`: 1,000,000 context / 128,000 output; other shipped models: 272,000 / 128,000)
 
+Use `opencode debug config` to verify that these template entries were merged into your effective config. `opencode models openai` currently shows OpenCode's built-in provider catalog and can omit config-defined entries such as `gpt-5.4-mini`.
+
 If your OpenCode runtime supports global compaction tuning, you can also set:
 - `model_context_window = 1000000`
 - `model_auto_compact_token_limit = 900000`

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;AA+J/D;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MA6rL/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;AA4M/D;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,iBAAiB,EAAE,MAsxL/B,CAAC;AAEF,eAAO,MAAM,gBAAgB,QAAoB,CAAC;AAElD,eAAe,iBAAiB,CAAC"}

package/dist/index.js

@@ -34,8 +34,8 @@ import { initLogger, logRequest, logDebug, logInfo, logWarn, logError, setCorrel
 import { checkAndNotify } from "./lib/auto-update-checker.js";
 import { handleContextOverflow } from "./lib/context-overflow.js";
 import { AccountManager, getAccountIdCandidates, extractAccountEmail, extractAccountId, formatAccountLabel, formatCooldown, formatWaitTime, sanitizeEmail, selectBestAccountCandidate, shouldUpdateAccountIdFromToken, resolveRequestAccountId, parseRateLimitReason, lookupCodexCliTokensByEmail, } from "./lib/accounts.js";
-import { getStoragePath, loadAccounts, saveAccounts, withAccountStorageTransaction, clearAccounts, setStoragePath, exportAccounts, importAccounts, previewImportAccounts, createTimestampedBackupPath, loadFlaggedAccounts, saveFlaggedAccounts, clearFlaggedAccounts, StorageError, formatStorageErrorHint, } from "./lib/storage.js";
-import { createCodexHeaders, extractRequestUrl, handleErrorResponse, handleSuccessResponse, getUnsupportedCodexModelInfo, resolveUnsupportedCodexFallbackModel, refreshAndUpdateToken, rewriteUrlForCodex, shouldRefreshToken, transformRequestForCodex, } from "./lib/request/fetch-helpers.js";
+import { getStoragePath, loadAccounts, saveAccounts, withAccountStorageTransaction, clearAccounts, setStoragePath, exportAccounts, importAccounts, previewImportAccounts, createTimestampedBackupPath, loadFlaggedAccounts, saveFlaggedAccounts, withFlaggedAccountStorageTransaction, clearFlaggedAccounts, StorageError, formatStorageErrorHint, } from "./lib/storage.js";
+import { createCodexHeaders, extractRequestUrl, handleErrorResponse, handleSuccessResponse, isDeactivatedWorkspaceError, getUnsupportedCodexModelInfo, resolveUnsupportedCodexFallbackModel, refreshAndUpdateToken, rewriteUrlForCodex, shouldRefreshToken, transformRequestForCodex, } from "./lib/request/fetch-helpers.js";
 import { applyFastSessionDefaults } from "./lib/request/request-transformer.js";
 import { getRateLimitBackoff, RATE_LIMIT_SHORT_RETRY_THRESHOLD_MS, resetRateLimitBackoff, } from "./lib/request/rate-limit-backoff.js";
 import { isEmptyResponse } from "./lib/request/response-handler.js";
@@ -48,6 +48,31 @@ import { buildBeginnerChecklist, buildBeginnerDoctorFindings, recommendBeginnerN
 import { getModelFamily, getCodexInstructions, MODEL_FAMILIES, prewarmCodexInstructions, } from "./lib/prompts/codex.js";
 import { prewarmOpenCodeCodexPrompt } from "./lib/prompts/opencode-codex.js";
 import { createSessionRecoveryHook, isRecoverableError, detectErrorType, getRecoveryToastContent, } from "./lib/recovery.js";
+function getWorkspaceIdentityKey(account) {
+    const organizationId = account.organizationId?.trim();
+    const accountId = account.accountId?.trim();
+    const refreshToken = account.refreshToken.trim();
+    if (organizationId) {
+        return accountId
+            ? `organizationId:${organizationId}|accountId:${accountId}`
+            : `organizationId:${organizationId}`;
+    }
+    if (accountId)
+        return `accountId:${accountId}`;
+    return `refreshToken:${refreshToken}`;
+}
+function matchesWorkspaceIdentity(account, identityKey) {
+    return getWorkspaceIdentityKey(account) === identityKey;
+}
+function upsertFlaggedAccountRecord(accounts, record) {
+    const identityKey = getWorkspaceIdentityKey(record);
+    const existingIndex = accounts.findIndex((flagged) => matchesWorkspaceIdentity(flagged, identityKey));
+    if (existingIndex >= 0) {
+        accounts[existingIndex] = record;
+        return;
+    }
+    accounts.push(record);
+}
 /**
  * OpenAI Codex OAuth authentication plugin for opencode
  *
@@ -1737,6 +1762,46 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                                     requestCorrelationId,
                                                     threadId: threadIdCandidate,
                                                 });
+                                                const workspaceDeactivated = isDeactivatedWorkspaceError(errorBody, response.status);
+                                                if (workspaceDeactivated) {
+                                                    const accountLabel = formatAccountLabel(account, account.index);
+                                                    accountManager.refundToken(account, modelFamily, model);
+                                                    accountManager.recordFailure(account, modelFamily, model);
+                                                    account.lastSwitchReason = "rotation";
+                                                    runtimeMetrics.failedRequests++;
+                                                    runtimeMetrics.accountRotations++;
+                                                    runtimeMetrics.lastError = `Deactivated workspace on ${accountLabel}`;
+                                                    runtimeMetrics.lastErrorCategory = "workspace-deactivated";
+                                                    try {
+                                                        const flaggedRecord = {
+                                                            ...account,
+                                                            flaggedAt: Date.now(),
+                                                            flaggedReason: "workspace-deactivated",
+                                                            lastError: "deactivated_workspace",
+                                                        };
+                                                        await withFlaggedAccountStorageTransaction(async (current, persist) => {
+                                                            const nextStorage = {
+                                                                ...current,
+                                                                accounts: current.accounts.map((flagged) => ({ ...flagged })),
+                                                            };
+                                                            upsertFlaggedAccountRecord(nextStorage.accounts, flaggedRecord);
+                                                            await persist(nextStorage);
+                                                        });
+                                                    }
+                                                    catch (flagError) {
+                                                        logWarn(`Failed to persist deactivated workspace flag for ${accountLabel}: ${flagError instanceof Error ? flagError.message : String(flagError)}`);
+                                                    }
+                                                    if (accountManager.removeAccount(account)) {
+                                                        accountManager.saveToDiskDebounced();
+                                                        attempted.clear();
+                                                        accountCount = accountManager.getAccountCount();
+                                                        await showToast(`Workspace deactivated. Removed ${accountLabel} from rotation and switching accounts.`, "warning", { duration: toastDurationMs });
+                                                        break;
+                                                    }
+                                                    accountManager.markAccountCoolingDown(account, ACCOUNT_LIMITS.AUTH_FAILURE_COOLDOWN_MS, "auth-failure");
+                                                    accountManager.saveToDiskDebounced();
+                                                    break;
+                                                }
                                                 const unsupportedModelInfo = getUnsupportedCodexModelInfo(errorBody);
                                                 const hasRemainingAccounts = attempted.size < Math.max(1, accountCount);
                                                 // Entitlements can differ by account/workspace, so try remaining
@@ -2204,12 +2269,18 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                         const message = (typeof errorBody?.error?.message === "string"
                                             ? errorBody.error?.message
                                             : bodyText) || `HTTP ${response.status}`;
+                                        if (isDeactivatedWorkspaceError(errorBody, response.status)) {
+                                            throw new Error("deactivated_workspace");
+                                        }
                                         throw new Error(message);
                                     }
                                     lastError = new Error("Codex response did not include quota headers");
                                 }
                                 catch (error) {
                                     lastError = error instanceof Error ? error : new Error(String(error));
+                                    if (lastError.message === "deactivated_workspace") {
+                                        throw lastError;
+                                    }
                                 }
                             }
                             throw lastError ?? new Error("Failed to fetch quotas");
@@ -2229,9 +2300,9 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                 console.log("\nNo accounts to check.\n");
                                 return;
                             }
-                            const flaggedStorage = await loadFlaggedAccounts();
                             let storageChanged = false;
                             let flaggedChanged = false;
+                            const flaggedUpdates = new Map();
                             const removeFromActive = new Set();
                             const total = workingStorage.accounts.length;
                             let ok = 0;
@@ -2315,20 +2386,14 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                             const message = refreshResult.message ?? refreshResult.reason ?? "refresh failed";
                                             console.log(`[${i + 1}/${total}] ${label}: ERROR (${message})`);
                                             if (deepProbe && isFlaggableFailure(refreshResult)) {
-                                                const existingIndex = flaggedStorage.accounts.findIndex((flagged) => flagged.refreshToken === account.refreshToken);
                                                 const flaggedRecord = {
                                                     ...account,
                                                     flaggedAt: Date.now(),
                                                     flaggedReason: "token-invalid",
                                                     lastError: message,
                                                 };
-                                                if (existingIndex >= 0) {
-                                                    flaggedStorage.accounts[existingIndex] = flaggedRecord;
-                                                }
-                                                else {
-                                                    flaggedStorage.accounts.push(flaggedRecord);
-                                                }
-                                                removeFromActive.add(account.refreshToken);
+                                                flaggedUpdates.set(getWorkspaceIdentityKey(flaggedRecord), flaggedRecord);
+                                                removeFromActive.add(getWorkspaceIdentityKey(account));
                                                 flaggedChanged = true;
                                             }
                                             continue;
@@ -2391,6 +2456,17 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                     catch (error) {
                                         errors += 1;
                                         const message = error instanceof Error ? error.message : String(error);
+                                        if (message === "deactivated_workspace") {
+                                            const flaggedRecord = {
+                                                ...account,
+                                                flaggedAt: Date.now(),
+                                                flaggedReason: "workspace-deactivated",
+                                                lastError: message,
+                                            };
+                                            flaggedUpdates.set(getWorkspaceIdentityKey(flaggedRecord), flaggedRecord);
+                                            removeFromActive.add(getWorkspaceIdentityKey(account));
+                                            flaggedChanged = true;
+                                        }
                                         console.log(`[${i + 1}/${total}] ${label}: ERROR (${message.slice(0, 160)})`);
                                     }
                                 }
@@ -2401,7 +2477,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                 }
                             }
                             if (removeFromActive.size > 0) {
-                                workingStorage.accounts = workingStorage.accounts.filter((account) => !removeFromActive.has(account.refreshToken));
+                                workingStorage.accounts = workingStorage.accounts.filter((account) => !removeFromActive.has(getWorkspaceIdentityKey(account)));
                                 clampActiveIndices(workingStorage);
                                 storageChanged = true;
                             }
@@ -2410,12 +2486,21 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                 invalidateAccountManagerCache();
                             }
                             if (flaggedChanged) {
-                                await saveFlaggedAccounts(flaggedStorage);
+                                await withFlaggedAccountStorageTransaction(async (current, persist) => {
+                                    const nextStorage = {
+                                        ...current,
+                                        accounts: current.accounts.map((flagged) => ({ ...flagged })),
+                                    };
+                                    for (const flaggedRecord of flaggedUpdates.values()) {
+                                        upsertFlaggedAccountRecord(nextStorage.accounts, flaggedRecord);
+                                    }
+                                    await persist(nextStorage);
+                                });
                             }
                             console.log("");
                             console.log(`Results: ${ok} ok, ${errors} error, ${disabled} disabled`);
                             if (removeFromActive.size > 0) {
-                                console.log(`Moved ${removeFromActive.size} account(s) to flagged pool (invalid refresh token).`);
+                                console.log(`Moved ${removeFromActive.size} account(s) to flagged pool.`);
                             }
                             console.log("");
                         };
@@ -2433,6 +2518,11 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                 if (!flagged)
                                     continue;
                                 const label = flagged.email ?? flagged.accountLabel ?? `Flagged ${i + 1}`;
+                                if (flagged.flaggedReason === "workspace-deactivated") {
+                                    console.log(`[${i + 1}/${flaggedStorage.accounts.length}] ${label}: STILL FLAGGED (workspace deactivated)`);
+                                    remaining.push(flagged);
+                                    continue;
+                                }
                                 try {
                                     const cached = await lookupCodexCliTokensByEmail(flagged.email);
                                     const now = Date.now();
@@ -2589,7 +2679,7 @@ export const OpenAIOAuthPlugin = async ({ client }) => {
                                             await saveAccounts(workingStorage);
                                             await saveFlaggedAccounts({
                                                 version: 1,
-                                                accounts: flaggedStorage.accounts.filter((flagged) => flagged.refreshToken !== target.refreshToken),
+                                                accounts: flaggedStorage.accounts.filter((flagged) => !matchesWorkspaceIdentity(flagged, getWorkspaceIdentityKey(target))),
                                             });
                                             invalidateAccountManagerCache();
                                             console.log(`\nDeleted ${target.email ?? `Account ${menuResult.deleteAccountIndex + 1}`}.\n`);