opencode-openai-multi-auth 5.0.0 → 5.0.2

package/README.md

@@ -1,70 +1,155 @@
 ![Image 1: opencode-openai-multi-auth](assets/readme-hero.svg)
 
-**Maintained by [ZenysTX](https://x.com/zenysTX)**
-**Most of the work and original implementation by [Numman Ali](https://x.com/nummanali)**
-**Inspired by [opencode-google-antigravity-auth](https://github.com/shekohex/opencode-google-antigravity-auth)**
-[![Twitter Follow](https://img.shields.io/twitter/follow/zenysTX?style=social)](https://x.com/zenysTX)
+[![npm version](https://img.shields.io/npm/v/opencode-openai-multi-auth.svg)](https://www.npmjs.com/package/opencode-openai-multi-auth)
+[![Tests](https://github.com/dkraemerwork/opencode-openai-multi-auth/actions/workflows/ci.yml/badge.svg)](https://github.com/dkraemerwork/opencode-openai-multi-auth/actions)
+[![npm downloads](https://img.shields.io/npm/dm/opencode-openai-multi-auth.svg)](https://www.npmjs.com/package/opencode-openai-multi-auth)
 
+# Multi-Account ChatGPT OAuth for OpenCode
 
+**Use multiple ChatGPT Plus/Pro personal or organization accounts with OpenCode. Never hit rate limits again.**
 
+```
+┌────────────────────────────────────────────────────────────────┐
+│                                                                │
+│   Account 1 (rate limited) ──┐                                 │
+│   Account 2 (rate limited) ──┼──► Auto-rotate ──► Keep coding  │
+│   Account 3 (available) ─────┘                                 │
+│                                                                │
+└────────────────────────────────────────────────────────────────┘
+```
 
+## Why Multi-Account?
 
-[![Twitter Follow](https://img.shields.io/twitter/follow/nummanali?style=social)](https://x.com/nummanali)
-[![npm version](https://img.shields.io/npm/v/opencode-openai-multi-auth.svg)](https://www.npmjs.com/package/opencode-openai-multi-auth)
-[![Tests](https://github.com/dkraemerwork/opencode-openai-multi-auth/actions/workflows/ci.yml/badge.svg)](https://github.com/dkraemerwork/opencode-openai-multi-auth/actions)
-[![npm downloads](https://img.shields.io/npm/dm/opencode-openai-multi-auth.svg)](https://www.npmjs.com/package/opencode-openai-multi-auth)
-**One install. Every Codex model. Multi-account ready.**
-[Install](#-quick-start) · [Models](#-models) · [Configuration](#-configuration) · [Docs](#-docs)
+| Problem | Solution |
+|---------|----------|
+| Hit ChatGPT rate limits while coding | Add multiple accounts, auto-rotate when limited |
+| Team members share one subscription | Each person adds their own account |
+| Different orgs have separate subscriptions | Use accounts from multiple organizations |
+| One account gets throttled | Seamlessly switch to next available account |
 
 ---
 
-## 💡 Philosophy
+## Quick Start
 
-> **"One config. Every model."**
-> OpenCode should feel effortless. This plugin keeps the setup minimal while giving you full GPT‑5.x + Codex access via ChatGPT OAuth across multiple accounts
-> from different organizations.
+```bash
+# Install
+npx -y opencode-openai-multi-auth@latest
 
-```
-┌─────────────────────────────────────────────────────────┐
-│                                                         │
-│  ChatGPT OAuth → Codex backend → OpenCode               │
-│  One command install, full model presets, done.         │
-│                                                         │
-└─────────────────────────────────────────────────────────┘
+# Add your first account
+opencode auth login
+# Select "ChatGPT Plus/Pro (Codex Subscription)"
+
+# Add more accounts (optional but recommended)
+opencode auth login
+# Select "Add Another OpenAI Account"
+
+# Start coding - accounts rotate automatically on rate limits
+opencode run "write hello world to test.txt" --model=openai/gpt-5.2 --variant=medium
 ```
 
 ---
 
-## 🚀 Quick Start
+## How Multi-Account Works
+
+### Adding Accounts
 
 ```bash
-npx -y opencode-openai-multi-auth@latest
+# First account
+opencode auth login
+# → Select "ChatGPT Plus/Pro (Codex Subscription)"
+# → Browser opens, login with ChatGPT
+# → Account saved
+
+# Second account (different email/org)
+opencode auth login
+# → Select "Add Another OpenAI Account"
+# → Login with different ChatGPT account
+# → Account added to rotation pool
+
+# Repeat for as many accounts as you have
 ```
 
-Then:
+### Automatic Rotation
+
+When you hit a rate limit:
+
+1. Plugin detects 429 (rate limited) response
+2. Marks current account as limited for that model
+3. Switches to next available account
+4. Retries your request automatically
+5. Shows toast notification: `Switched to account2@example.com`
 
+### Account Selection Strategies
+
+| Strategy | Behavior | Best For |
+|----------|----------|----------|
+| `sticky` (default) | Stay with one account until rate limited | Single user, predictable usage |
+| `round-robin` | Rotate through accounts on each request | Distribute load evenly |
+| `hybrid` | Sticky within session, rotate across sessions | Multiple terminal sessions |
+
+Set via environment variable:
 ```bash
-opencode auth login
-opencode run "write hello world to test.txt" --model=openai/gpt-5.2 --variant=medium
+OPENCODE_OPENAI_STRATEGY=round-robin opencode run "task"
 ```
 
-Legacy OpenCode (v1.0.209 and below):
+### Team Usage
+
+Each team member can add their own ChatGPT account:
 
 ```bash
-npx -y opencode-openai-multi-auth@latest --legacy
-opencode run "write hello world to test.txt" --model=openai/gpt-5.2-medium
+# Developer 1 adds their account
+opencode auth login  # logs in as dev1@company.com
+
+# Developer 2 adds their account  
+opencode auth login  # → "Add Another OpenAI Account" → dev2@company.com
+
+# Developer 3 adds their account
+opencode auth login  # → "Add Another OpenAI Account" → dev3@company.com
+```
+
+All accounts are pooled - when one person's account is rate limited, the plugin uses the next available.
+
+---
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `OPENCODE_OPENAI_QUIET=1` | Disable toast notifications | Off |
+| `OPENCODE_OPENAI_DEBUG=1` | Enable debug logging | Off |
+| `OPENCODE_OPENAI_STRATEGY` | Account selection strategy | `sticky` |
+| `OPENCODE_OPENAI_PID_OFFSET=1` | Offset account selection by PID | Off |
+
+---
+
+## Account Management
+
+### View Accounts
+```bash
+cat ~/.config/opencode/openai-accounts.json | jq '.accounts[] | {email, planType}'
 ```
 
-Uninstall:
+### Remove All Accounts
+```bash
+rm ~/.config/opencode/openai-accounts.json
+```
 
+### Check Rate Limit Status
 ```bash
-npx -y opencode-openai-multi-auth@latest --uninstall
-npx -y opencode-openai-multi-auth@latest --uninstall --all
+cat ~/.config/opencode/openai-accounts.json | jq '.accounts[] | {email, rateLimitResets}'
+```
+
+### Slash Commands (TUI)
+```text
+/codex-status
 ```
+Shows usage status for all configured accounts.
 
 ---
 
-## 📦 Models
+## Models
+
+All GPT-5.2 and GPT-5.1 models with reasoning variants:
 
 - **gpt-5.2** (none/low/medium/high/xhigh)
 - **gpt-5.2-codex** (low/medium/high/xhigh)
@@ -73,73 +158,60 @@ npx -y opencode-openai-multi-auth@latest --uninstall --all
 - **gpt-5.1-codex-mini** (medium/high)
 - **gpt-5.1** (none/low/medium/high)
 
+Note: The model selector reflects what the ChatGPT OAuth backend advertises. API-only models (like gpt-5-mini/nano) may not appear until the backend exposes them.
+
 ---
 
-## 🧩 Configuration
+## Configuration
 
-- Modern (OpenCode v1.0.210+): `config/opencode-modern.json`
-- Legacy (OpenCode v1.0.209 and below): `config/opencode-legacy.json`
+- **Modern** (OpenCode v1.0.210+): `config/opencode-modern.json`
+- **Legacy** (v1.0.209 and below): `config/opencode-legacy.json`
 
-Minimal configs are not supported for GPT‑5.x; use the full configs above.
----
+```bash
+# Modern install
+npx -y opencode-openai-multi-auth@latest
 
-## ✅ Features
+# Legacy install
+npx -y opencode-openai-multi-auth@latest --legacy
 
-- **Multi-account support** with automatic rotation on rate limits
-- ChatGPT Plus/Pro OAuth authentication (official flow)
-- 22 model presets across GPT‑5.2 / GPT‑5.2 Codex / GPT‑5.1 families
-- Variant system support (v1.0.210+) + legacy presets
-- Multimodal input enabled for all models
-- Toast notifications for account switches and rate limits
-- Usage‑aware errors + automatic token refresh
+# Uninstall
+npx -y opencode-openai-multi-auth@latest --uninstall
+```
 
 ---
 
-## 🔄 Multi-Account Support
+## Features
 
-Add multiple ChatGPT accounts and automatically rotate between them when rate limited:
-
-```bash
-# Add first account
-opencode auth login
-# Select "ChatGPT Plus/Pro (Codex Subscription)"
+- **Multi-account rotation** - Add unlimited ChatGPT accounts, auto-rotate on rate limits
+- **Per-model rate tracking** - Each model's limits tracked separately per account
+- **Toast notifications** - Visual feedback when accounts switch
+- **OAuth authentication** - Same secure flow as official Codex CLI
+- **22 model presets** - All GPT-5.2/5.1 variants pre-configured
+- **Automatic token refresh** - Never manually re-authenticate
+- **Multimodal support** - Image input enabled for all models
 
-# Add additional accounts
-opencode auth login
-# Select "Add Another OpenAI Account"
-```
-
-**Features:**
-- Automatic rotation when an account hits rate limits
-- Per-model rate limit tracking
-- Toast notifications showing active account
-- Seamless failover between accounts
-- Imports existing tokens from OpenCode auth
+---
 
-**Environment Variables:**
-| Variable | Description |
-|----------|-------------|
-| `OPENCODE_OPENAI_QUIET=1` | Disable toast notifications |
-| `OPENCODE_OPENAI_DEBUG=1` | Enable debug logging |
-| `OPENCODE_OPENAI_STRATEGY` | Account selection: `sticky` (default), `round-robin`, `hybrid` |
+## Documentation
 
-**Accounts storage:** `~/.config/opencode/openai-accounts.json`
+- [Getting Started](docs/getting-started.md)
+- [Configuration Guide](docs/configuration.md)
+- [Troubleshooting](docs/troubleshooting.md)
+- [Architecture](docs/development/ARCHITECTURE.md)
 
 ---
 
-## 📚 Docs
+## Credits
 
-- Getting Started: `docs/getting-started.md`
-- Configuration: `docs/configuration.md`
-- Troubleshooting: `docs/troubleshooting.md`
-- Architecture: `docs/development/ARCHITECTURE.md`
+**Maintained by [ZenysTX](https://x.com/zenysTX)**
+**Original implementation by [Numman Ali](https://x.com/nummanali)**
+**Inspired by [opencode-google-antigravity-auth](https://github.com/shekohex/opencode-google-antigravity-auth)**
+
+[![Twitter Follow](https://img.shields.io/twitter/follow/zenysTX?style=social)](https://x.com/zenysTX)
+[![Twitter Follow](https://img.shields.io/twitter/follow/nummanali?style=social)](https://x.com/nummanali)
 
 ---
 
-## ⚠️ Usage Notice
+## Usage Notice
 
 This plugin is for **personal development use** with your own ChatGPT Plus/Pro subscriptions.
-
-**Built for developers who value simplicity.**
-
-## Force Build 1

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import { type Plugin } from "@opencode-ai/plugin";
 export declare const OpenAIAuthPlugin: Plugin;
 export default OpenAIAuthPlugin;
 //# 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,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,qBAAqB,CAAC;AAiD/D,eAAO,MAAM,gBAAgB,EAAE,MAua9B,CAAC;AAEF,eAAe,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,MAAM,EAAoB,MAAM,qBAAqB,CAAC;AAuD1E,eAAO,MAAM,gBAAgB,EAAE,MAonB9B,CAAC;AAEF,eAAe,gBAAgB,CAAC"}

package/dist/index.js

@@ -1,11 +1,14 @@
+import { tool } from "@opencode-ai/plugin";
 import { createAuthorizationFlow, decodeJWT, exchangeAuthorizationCode, parseAuthorizationInput, REDIRECT_URI, } from "./lib/auth/auth.js";
 import { openBrowserUrl } from "./lib/auth/browser.js";
 import { startLocalOAuthServer } from "./lib/auth/server.js";
 import { getCodexMode, loadPluginConfig } from "./lib/config.js";
-import { AUTH_LABELS, CODEX_BASE_URL, DUMMY_API_KEY, ERROR_MESSAGES, JWT_CLAIM_PATH, LOG_STAGES, PROVIDER_ID, HTTP_STATUS, } from "./lib/constants.js";
+import { AUTH_LABELS, CODEX_BASE_URL, DUMMY_API_KEY, ERROR_MESSAGES, JWT_CLAIM_PATH, LOG_STAGES, PROVIDER_ID, HTTP_STATUS, MODEL_FALLBACKS, } from "./lib/constants.js";
 import { logRequest, logDebug } from "./lib/logger.js";
 import { createCodexHeaders, extractRequestUrl, handleErrorResponse, handleSuccessResponse, rewriteUrlForCodex, transformRequestForCodex, } from "./lib/request/fetch-helpers.js";
 import { AccountManager } from "./lib/accounts/index.js";
+import { codexStatus } from "./lib/codex-status.js";
+import { prefetchModels } from "./lib/models.js";
 function extractModelFromBody(body) {
     if (!body)
         return undefined;
@@ -20,6 +23,8 @@ function extractModelFromBody(body) {
 let lastToastAccountIndex = null;
 let lastToastTime = 0;
 const TOAST_DEBOUNCE_MS = 5000;
+/** Track which models we've already shown fallback notifications for */
+const notifiedFallbacks = new Set();
 export const OpenAIAuthPlugin = async ({ client }) => {
     const quietMode = process.env.OPENCODE_OPENAI_QUIET === "1";
     const debugMode = process.env.OPENCODE_OPENAI_DEBUG === "1";
@@ -81,6 +86,40 @@ export const OpenAIAuthPlugin = async ({ client }) => {
         }
         catch { }
     };
+    const showModelRetryToast = async (model, failedAccount, nextAccount, triedCount, totalAccounts) => {
+        if (quietMode)
+            return;
+        const failedLabel = failedAccount.email || `Account ${failedAccount.index + 1}`;
+        const nextLabel = nextAccount.email || `Account ${nextAccount.index + 1}`;
+        const nextPlan = nextAccount.planType ? ` [${nextAccount.planType}]` : "";
+        try {
+            await client.tui.showToast({
+                body: {
+                    message: `${model} not on ${failedLabel}, trying ${nextLabel}${nextPlan} (${triedCount}/${totalAccounts})`,
+                    variant: "info",
+                },
+            });
+        }
+        catch { }
+    };
+    const showModelFallbackToast = async (originalModel, fallbackModel) => {
+        if (quietMode)
+            return;
+        // Only show once per model to avoid spam
+        const key = `${originalModel}->${fallbackModel}`;
+        if (notifiedFallbacks.has(key))
+            return;
+        notifiedFallbacks.add(key);
+        try {
+            await client.tui.showToast({
+                body: {
+                    message: `${originalModel} not available yet. Using ${fallbackModel} instead.`,
+                    variant: "warning",
+                },
+            });
+        }
+        catch { }
+    };
     const accountManager = new AccountManager({
         accountSelectionStrategy: process.env.OPENCODE_OPENAI_STRATEGY || "sticky",
         debug: process.env.OPENCODE_OPENAI_DEBUG === "1",
@@ -149,13 +188,15 @@ export const OpenAIAuthPlugin = async ({ client }) => {
                 };
                 const pluginConfig = loadPluginConfig();
                 const codexMode = getCodexMode(pluginConfig);
-                const executeRequest = async (account, input, init, retryCount = 0) => {
+                const executeRequest = async (account, input, init, retryCount = 0, triedAccountIndices = new Set()) => {
+                    // Track this account as tried
+                    triedAccountIndices.add(account.index);
                     const isTokenValid = await accountManager.ensureValidToken(account);
                     if (!isTokenValid) {
-                        const nextAccount = await accountManager.getNextAvailableAccount();
+                        const nextAccount = await accountManager.getNextAvailableAccountExcluding(triedAccountIndices);
                         if (nextAccount && nextAccount.index !== account.index) {
                             await showAccountSwitchToast(account, nextAccount);
-                            return executeRequest(nextAccount, input, init, retryCount);
+                            return executeRequest(nextAccount, input, init, retryCount, triedAccountIndices);
                         }
                         return new Response(JSON.stringify({ error: "All accounts failed token refresh" }), {
                             status: HTTP_STATUS.UNAUTHORIZED,
@@ -183,6 +224,14 @@ export const OpenAIAuthPlugin = async ({ client }) => {
                             headers: { "Content-Type": "application/json" },
                         });
                     }
+                    // Pre-fetch models to "register" client with backend
+                    // This may help unlock access to newer models like gpt-5.3-codex
+                    try {
+                        await prefetchModels(account.access || "", accountId);
+                    }
+                    catch {
+                        // Ignore errors - this is a best-effort optimization
+                    }
                     const headers = createCodexHeaders(requestInit, accountId, account.access || "", {
                         model: transformation?.body.model,
                         promptCacheKey: transformation?.body?.prompt_cache_key,
@@ -191,6 +240,18 @@ export const OpenAIAuthPlugin = async ({ client }) => {
                         ...requestInit,
                         headers,
                     });
+                    try {
+                        const headersObj = {};
+                        response.headers.forEach((value, key) => {
+                            headersObj[key] = value;
+                        });
+                        await codexStatus.updateFromHeaders(account, headersObj);
+                    }
+                    catch (error) {
+                        if (debugMode) {
+                            console.log("[openai-multi-auth] codex-status update failed", error);
+                        }
+                    }
                     logRequest(LOG_STAGES.RESPONSE, {
                         status: response.status,
                         ok: response.ok,
@@ -235,19 +296,88 @@ export const OpenAIAuthPlugin = async ({ client }) => {
                             catch { }
                         }
                         if (retryCount < accountManager.getAccountCount() - 1) {
-                            const nextAccount = await accountManager.getNextAvailableAccount(model);
+                            const nextAccount = await accountManager.getNextAvailableAccountExcluding(triedAccountIndices, model);
                             if (nextAccount && nextAccount.index !== account.index) {
                                 await showAccountSwitchToast(account, nextAccount);
-                                return executeRequest(nextAccount, input, init, retryCount + 1);
+                                return executeRequest(nextAccount, input, init, retryCount + 1, triedAccountIndices);
                             }
                         }
                     }
                     if (response.status === HTTP_STATUS.UNAUTHORIZED && retryCount < 1) {
                         accountManager.markRefreshFailed(account, "401 Unauthorized");
-                        const nextAccount = await accountManager.getNextAvailableAccount(model);
+                        const nextAccount = await accountManager.getNextAvailableAccountExcluding(triedAccountIndices, model);
                         if (nextAccount && nextAccount.index !== account.index) {
                             await showAccountSwitchToast(account, nextAccount);
-                            return executeRequest(nextAccount, input, init, retryCount + 1);
+                            return executeRequest(nextAccount, input, init, retryCount + 1, triedAccountIndices);
+                        }
+                    }
+                    // Handle model not supported errors (400 Bad Request with specific message)
+                    if (response.status === 400) {
+                        try {
+                            const cloned = response.clone();
+                            const errorBody = await cloned.json();
+                            const detail = errorBody?.detail || errorBody?.error?.message || "";
+                            // Always log 400 errors to file for debugging
+                            const fs = await import("node:fs");
+                            const path = await import("node:path");
+                            const os = await import("node:os");
+                            const logDir = path.join(os.homedir(), ".opencode", "logs", "codex-plugin");
+                            fs.mkdirSync(logDir, { recursive: true });
+                            fs.writeFileSync(path.join(logDir, "last-400-error.json"), JSON.stringify({
+                                timestamp: new Date().toISOString(),
+                                model: transformation?.body.model,
+                                status: response.status,
+                                errorBody,
+                                detail,
+                                accountIndex: account.index,
+                                accountEmail: account.email,
+                                accountPlanType: account.planType,
+                                triedAccounts: Array.from(triedAccountIndices),
+                                totalAccounts: accountManager.getAccountCount(),
+                            }, null, 2));
+                            // Log the error for debugging
+                            if (debugMode) {
+                                console.log(`[openai-multi-auth] 400 error for model ${transformation?.body.model} on account ${account.email || account.index} [${account.planType}]: ${JSON.stringify(errorBody)}`);
+                            }
+                            // Check if it's a "model not supported" error
+                            if (detail.includes("model is not supported") || detail.includes("not supported when using Codex")) {
+                                const requestedModel = transformation?.body.model || model;
+                                // STEP 1: Try other accounts first (they might be Plus/Pro/Team and support the model)
+                                const nextAccount = await accountManager.getNextAvailableAccountExcluding(triedAccountIndices, requestedModel);
+                                if (nextAccount) {
+                                    if (debugMode) {
+                                        console.log(`[openai-multi-auth] Model ${requestedModel} not supported on ${account.email || account.index} [${account.planType}], trying ${nextAccount.email || nextAccount.index} [${nextAccount.planType}]`);
+                                    }
+                                    await showModelRetryToast(requestedModel, account, nextAccount, triedAccountIndices.size, accountManager.getAccountCount());
+                                    return executeRequest(nextAccount, input, init, retryCount, triedAccountIndices);
+                                }
+                                // STEP 2: All accounts tried - fall back to older model
+                                const fallbackModel = MODEL_FALLBACKS[requestedModel];
+                                if (fallbackModel) {
+                                    if (debugMode) {
+                                        console.log(`[openai-multi-auth] All ${triedAccountIndices.size} accounts tried for ${requestedModel}, falling back to ${fallbackModel}`);
+                                    }
+                                    await showModelFallbackToast(requestedModel, fallbackModel);
+                                    // Retry with fallback model using first available account (reset tried accounts for new model)
+                                    const modifiedBody = JSON.parse(init?.body || "{}");
+                                    modifiedBody.model = fallbackModel;
+                                    const modifiedInit = {
+                                        ...init,
+                                        body: JSON.stringify(modifiedBody),
+                                    };
+                                    // Get first available account for the fallback model
+                                    const fallbackAccount = await accountManager.getNextAvailableAccount(fallbackModel);
+                                    if (fallbackAccount) {
+                                        // Reset tried accounts for the new model
+                                        return executeRequest(fallbackAccount, input, modifiedInit, 0, new Set());
+                                    }
+                                    // If no account available, use current account
+                                    return executeRequest(account, input, modifiedInit, retryCount + 1, new Set());
+                                }
+                            }
+                        }
+                        catch {
+                            // If parsing fails, continue with normal error handling
                         }
                     }
                     if (!response.ok) {
@@ -315,6 +445,58 @@ export const OpenAIAuthPlugin = async ({ client }) => {
                 },
             ],
         },
+        config: async (cfg) => {
+            cfg.command = cfg.command || {};
+            cfg.command["codex-status"] = {
+                template: "Run the codex-status tool and output the result EXACTLY as returned by the tool, without any additional text or commentary.",
+                description: "List all configured OpenAI accounts and their current usage status.",
+            };
+            cfg.experimental = cfg.experimental || {};
+            cfg.experimental.primary_tools = cfg.experimental.primary_tools || [];
+            if (!cfg.experimental.primary_tools.includes("codex-status")) {
+                cfg.experimental.primary_tools.push("codex-status");
+            }
+        },
+        tool: {
+            "codex-status": tool({
+                description: "List all configured OpenAI accounts and their current usage status.",
+                args: {},
+                async execute() {
+                    const accounts = accountManager.getAllAccounts();
+                    if (accounts.length === 0) {
+                        return [
+                            "OpenAI Codex Status",
+                            "",
+                            "  Accounts: 0",
+                            "",
+                            "Add accounts:",
+                            "  opencode auth login",
+                        ].join("\n");
+                    }
+                    const now = Date.now();
+                    await Promise.all(accounts.map(async (acc) => {
+                        if (acc.access && acc.expires && acc.expires > now) {
+                            await codexStatus.fetchFromBackend(acc, acc.access);
+                        }
+                    }));
+                    const active = accountManager.getActiveAccount();
+                    const activeIndex = active?.index ?? 0;
+                    const lines = ["OpenAI Codex Status", ""];
+                    for (const account of accounts) {
+                        const status = account.index === activeIndex ? "ACTIVE" : "READY";
+                        const email = account.email || `Account ${account.index + 1}`;
+                        const plan = account.planType || "Unknown";
+                        lines.push(`${account.index + 1}. ${status} ${email} [${plan}]`);
+                        const statusLines = await codexStatus.renderStatus(account);
+                        for (const line of statusLines) {
+                            lines.push(line);
+                        }
+                        lines.push("");
+                    }
+                    return lines.join("\n");
+                },
+            }),
+        },
     };
 };
 export default OpenAIAuthPlugin;