claude-accounts-usage 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vince.dai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# claude-accounts-usage
+
+一个 OpenCode **TUI 插件**,用来查看多个 Claude(Pro/Max)账号的订阅用量,并在账号之间切换。
+
+它**不接管** `anthropic` auth provider,因此可以和 [`@ex-machina/opencode-anthropic-auth`](https://github.com/ex-machina-co/opencode-anthropic-auth) **共存** —— ex-machina 继续负责 OAuth 登录与请求注入,本插件只在工具层做"账号档案 + 切换 + 用量展示"。
+
+## 功能
+
+| 命令 | 作用 |
+|------|------|
+| `/usage` | 弹框显示所有账号的用量(5h / 7d / 7d-Sonnet 三个窗口,带进度条与重置倒计时) |
+| `/switch` | 弹框选择账号并切换为当前账号(立即生效) |
+
+账号会在**插件加载时**以及每次 `/usage`、`/switch` 时**自动收录**当前 ex-machina 登录的账号,无需手动添加。
+
+## 限流自动切号(自动重试)
+
+当**当前账号撞到订阅额度上限**(5h 窗口或周/全模型窗口的 429)时,插件会**自动切到下一个可用账号并重发刚才失败的那条消息**,无需手动干预。该能力**始终开启**。
+
+工作方式:
+
+- **检测**:监听 OpenCode 的 `session.next.retried` / `session.error` 事件,只在 429 且命中 Anthropic 订阅额度签名(`anthropic-ratelimit-unified-*: rejected`,或响应体 `rate_limit_error` + 额度文案)时触发;瞬时限流、529 过载、401 鉴权错误都会被排除,避免误切号。
+- **选号**:优先按用量挑剩余额度最多的账号(用 `/usage` 时缓存的数据,TTL 10 分钟),无缓存则轮询下一个;跳过正在冷却(已知额度未恢复)的账号。
+- **重发**:切号后将会话回退到失败的那条用户消息并用新账号重发(`revert` + `promptAsync`)。注意:若该轮中途已产生文件改动,回退会一并撤销并整轮重做。
+- **冷却**:撞限的账号按响应头给出的 reset 时间(缺省 60 分钟)进入冷却,持久化在 `tui.json` 的 KV 中;账号下次成功使用后自动解除冷却。
+- **耗尽**:当所有账号都在冷却时停止切换,并弹出最近恢复时间的倒计时提示。
+
+> 调试:设环境变量 `CLAUDE_AUTOSWITCH_DEBUG=1` 可把未命中谓词的 429 样本追加到 `~/.config/opencode/claude-autoswitch.log`,便于校准检测规则。
+
+## 前置条件
+
+- 已安装并使用 `@ex-machina/opencode-anthropic-auth` 登录 Claude Pro/Max。
+- **无需移除 ex-machina**,两者共存。
+
+## 安装
+
+TUI 插件只在 `~/.config/opencode/tui.json` 配置,**不要**放进 `opencode.json`。
+
+### 方式一:npm(推荐)
+
+```json
+{
+  "$schema": "https://opencode.ai/tui.json",
+  "plugin": ["claude-accounts-usage"]
+}
+```
+
+OpenCode 会自动解析并安装该包,无需手动 `npm install`。
+
+### 方式二:本地 clone(开发/离线)
+
+```bash
+git clone https://github.com/Daiwenxi798673133/claude-accounts-usage.git
+cd claude-accounts-usage && bun install
+```
+
+然后让 `tui.json` 指向克隆下来的 `tui.tsx` 绝对路径:
+
+```json
+{
+  "$schema": "https://opencode.ai/tui.json",
+  "plugin": ["/绝对路径/claude-accounts-usage/tui.tsx"]
+}
+```
+
+修改配置后**完全退出并重新打开** OpenCode。
+
+## 账号管理流程
+
+1. 用 ex-machina 登录账号 A:`opencode auth login` → Claude Pro/Max。
+2. 打开 OpenCode,插件自动收录账号 A(标签为其邮箱)。
+3. 想加更多账号:用 ex-machina 登录账号 B,然后重新打开 OpenCode 或运行一次 `/usage` / `/switch`,插件自动收录 B。
+4. 之后用 `/switch` 在账号间切换,用 `/usage` 查看全部用量。
+
+> 标签默认是账号邮箱。想改名?直接编辑 `~/.config/opencode/claude-accounts.json` 里对应账号的 `label`(自动收录不会覆盖你改过的标签)。
+
+## 工作原理
+
+- 账号档案保存在 `~/.config/opencode/claude-accounts.json`(权限 `0600`),每个账号含 OAuth `refresh` / `access` / `expires`、邮箱 `label`,以及来自 Anthropic profile 的账号 `uuid`。
+- **自动收录**:读 `auth.json` 当前账号 → 调 `oauth/profile` 拿到稳定的账号 `uuid` 和邮箱 → 按 `uuid` upsert。`uuid` 跨 token 刷新保持不变,因此同一账号只会被更新(不重复),换成新账号则自动新增。
+- **切换**:把目标账号的 token 写入 `auth.json` 的 `anthropic` 条目。ex-machina 每次请求都会重新读取 `auth.json`,所以切换立即生效(下一条消息就用新账号),无需重启。
+- **查看用量**:对每个账号调用 Anthropic 的 `oauth/usage` 接口;若 access token 过期,会用 refresh token 刷新并回写档案。
+- 始终只读 / 谨慎写 `auth.json` 的 `anthropic` 一项,保留其他 provider 条目不动。
+
+## 已知限制
+
+- ex-machina 同一时刻只持有一个账号,所以一个新账号必须先用 ex-machina 登录过一次,插件才能在下次加载/操作时收录它。
+- 自动切号依赖 OpenCode 的 `session.error` / `session.next.retried` 事件,因此只对经由 OpenCode(及 ex-machina)发出的 Anthropic 请求生效;额度恢复后的解除冷却需要该账号成功跑过一次对话。
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "claude-accounts-usage",
+  "version": "0.1.0",
+  "description": "OpenCode TUI plugin to view multi-account Claude usage and switch the active account. Coexists with @ex-machina/opencode-anthropic-auth.",
+  "type": "module",
+  "license": "MIT",
+  "author": "vince.dai",
+  "homepage": "https://github.com/Daiwenxi798673133/claude-accounts-usage#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Daiwenxi798673133/claude-accounts-usage.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Daiwenxi798673133/claude-accounts-usage/issues"
+  },
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "claude",
+    "anthropic",
+    "usage",
+    "quota",
+    "multi-account",
+    "tui"
+  ],
+  "exports": {
+    ".": {
+      "import": "./tui.tsx"
+    },
+    "./tui": {
+      "import": "./tui.tsx"
+    }
+  },
+  "files": [
+    "tui.tsx",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "opencode": ">=1.3.13",
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.17.4",
+    "@opentui/solid": "^0.4.1",
+    "solid-js": "^1.9.13"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.3",
+    "typescript": "^5.9.3"
+  }
+}

package/src/accounts.ts

@@ -0,0 +1,141 @@
+import { readFile, writeFile, mkdir, rename } from "node:fs/promises"
+import { homedir } from "node:os"
+import { join, dirname } from "node:path"
+
+export type StoredAccount = {
+  id: string
+  label: string
+  refresh: string
+  access?: string
+  expires?: number
+}
+
+export type AccountsFile = {
+  version: number
+  activeId?: string
+  accounts: StoredAccount[]
+}
+
+export type AnthropicOauth = {
+  type: "oauth"
+  access?: string
+  refresh?: string
+  expires?: number
+}
+
+export type AuthToken = {
+  refresh: string
+  access?: string
+  expires?: number
+}
+
+const ACCOUNTS_PATH = join(homedir(), ".config", "opencode", "claude-accounts.json")
+
+function authJsonCandidates(): string[] {
+  const list: string[] = []
+  if (process.env.XDG_DATA_HOME) list.push(join(process.env.XDG_DATA_HOME, "opencode", "auth.json"))
+  list.push(join(homedir(), ".local", "share", "opencode", "auth.json"))
+  list.push(join(homedir(), "Library", "Application Support", "opencode", "auth.json"))
+  return list
+}
+
+async function readJson<T>(path: string): Promise<T | undefined> {
+  try {
+    return JSON.parse(await readFile(path, "utf8")) as T
+  } catch {
+    return undefined
+  }
+}
+
+async function atomicWriteJson(path: string, data: unknown): Promise<void> {
+  await mkdir(dirname(path), { recursive: true })
+  const tmp = `${path}.tmp-${process.pid}-${Date.now()}`
+  await writeFile(tmp, JSON.stringify(data, null, 2), { mode: 0o600 })
+  await rename(tmp, path)
+}
+
+async function resolveAuthJsonPath(): Promise<string> {
+  const candidates = authJsonCandidates()
+  for (const candidate of candidates) {
+    if (await readJson(candidate)) return candidate
+  }
+  return candidates[0]
+}
+
+// Serializes auth.json / claude-accounts.json read-modify-writes. NOT reentrant:
+// never nest withAuthLock inside another withAuthLock or it deadlocks.
+let authLock: Promise<unknown> = Promise.resolve()
+
+export function withAuthLock<T>(fn: () => Promise<T>): Promise<T> {
+  const run = authLock.then(fn, fn)
+  authLock = run.then(
+    () => undefined,
+    () => undefined,
+  )
+  return run
+}
+
+export async function readActiveId(): Promise<string | undefined> {
+  return (await loadAccounts()).activeId
+}
+
+export async function loadAccounts(): Promise<AccountsFile> {
+  const data = await readJson<Partial<AccountsFile>>(ACCOUNTS_PATH)
+  return {
+    version: data?.version ?? 1,
+    activeId: data?.activeId,
+    accounts: Array.isArray(data?.accounts)
+      ? (data!.accounts as StoredAccount[]).filter((account) => typeof account.id === "string" && account.id.length > 0)
+      : [],
+  }
+}
+
+export async function saveAccounts(file: AccountsFile): Promise<void> {
+  await atomicWriteJson(ACCOUNTS_PATH, file)
+}
+
+export async function readAuthAnthropic(): Promise<AnthropicOauth | undefined> {
+  const auth = await readJson<Record<string, unknown>>(await resolveAuthJsonPath())
+  const entry = auth?.["anthropic"]
+  if (entry && typeof entry === "object" && (entry as AnthropicOauth).type === "oauth") {
+    return entry as AnthropicOauth
+  }
+  return undefined
+}
+
+export async function writeAuthAnthropic(token: AuthToken): Promise<void> {
+  const path = await resolveAuthJsonPath()
+  const auth = (await readJson<Record<string, unknown>>(path)) ?? {}
+  auth["anthropic"] = {
+    type: "oauth",
+    access: token.access ?? "",
+    refresh: token.refresh,
+    expires: token.expires ?? 0,
+  }
+  await atomicWriteJson(path, auth)
+}
+
+export async function upsertAccount(id: string, label: string, token: AuthToken): Promise<AccountsFile> {
+  const file = await loadAccounts()
+  const index = file.accounts.findIndex((account) => account.id === id)
+  if (index >= 0) {
+    file.accounts[index] = {
+      ...file.accounts[index],
+      refresh: token.refresh,
+      access: token.access,
+      expires: token.expires,
+    }
+  } else {
+    file.accounts.push({ id, label, refresh: token.refresh, access: token.access, expires: token.expires })
+  }
+  file.activeId = id
+  await saveAccounts(file)
+  return file
+}
+
+export async function setActiveId(id: string): Promise<void> {
+  const file = await loadAccounts()
+  if (!file.accounts.some((account) => account.id === id)) return
+  file.activeId = id
+  await saveAccounts(file)
+}

package/src/autoswitch.ts

@@ -0,0 +1,486 @@
+import { appendFile } from "node:fs/promises"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
+import { loadAccounts, readActiveId, type AccountsFile, type StoredAccount } from "./accounts.ts"
+import { collectAllUsage, switchToAccount, type AccountUsage, type UsageResponse } from "./usage.ts"
+
+const ENABLED = true
+const DEFAULT_COOLDOWN_MS = 60 * 60_000
+const USAGE_CACHE_TTL_MS = 10 * 60_000
+const RECENT_SWITCH_GUARD_MS = 4_000
+const IDLE_WAIT_TIMEOUT_MS = 4_000
+const IDLE_POLL_MS = 150
+const COOLDOWN_KV_KEY = "claude-accounts-usage.autoswitch.cooldown"
+
+type StateParts = ReturnType<TuiPluginApi["state"]["part"]>
+type StateMessage = ReturnType<TuiPluginApi["state"]["session"]["messages"]>[number]
+type AssistantMsg = Extract<StateMessage, { role: "assistant" }>
+type PromptParts = NonNullable<Parameters<TuiPluginApi["client"]["session"]["promptAsync"]>[0]["parts"]>
+
+type RetryErrorLike = {
+  statusCode?: number
+  responseHeaders?: Record<string, string>
+  responseBody?: string
+  message?: string
+}
+
+export type AutoSwitchController = {
+  dispose: () => void
+  setUsageCache: (results: AccountUsage[]) => void
+}
+
+function lowerKeys(headers?: Record<string, string>): Record<string, string> {
+  const out: Record<string, string> = {}
+  if (headers) for (const [key, value] of Object.entries(headers)) out[key.toLowerCase()] = value
+  return out
+}
+
+function safeJson(body?: string): { error?: { type?: unknown; message?: unknown } } | undefined {
+  if (!body) return undefined
+  try {
+    const value = JSON.parse(body)
+    return typeof value === "object" && value !== null ? (value as { error?: { type?: unknown; message?: unknown } }) : undefined
+  } catch {
+    return undefined
+  }
+}
+
+// Detects a Claude Pro/Max rate-limit / quota rejection so we can switch accounts.
+// 529 overloads are excluded (switching won't help). Anthropic surfaces this through
+// several shapes depending on path (unified headers, JSON body type, or just a message
+// string like "This request would exceed your account's rate limit"), so we match on
+// ANY of: 429 status, rate_limit_error type, or rate-limit message text — the message
+// regex is the one maintenance point as Anthropic's wording may drift.
+function isUsageLimit(error?: RetryErrorLike): boolean {
+  if (!error) return false
+  const body = error.responseBody ?? ""
+  if (/overloaded_error/i.test(body)) return false
+  const headers = lowerKeys(error.responseHeaders)
+  const unifiedRejected = Object.entries(headers).some(
+    ([key, value]) =>
+      key.startsWith("anthropic-ratelimit-unified") && key.endsWith("status") && String(value).toLowerCase().includes("rejected"),
+  )
+  if (unifiedRejected) return true
+  const parsed = safeJson(body)?.error
+  const type = typeof parsed?.type === "string" ? parsed.type : ""
+  const text = `${typeof parsed?.message === "string" ? parsed.message : ""} ${error.message ?? ""}`.toLowerCase()
+  const rateLimitText = /rate limit|usage limit|limit reached|too many requests|out of (?:usage|quota)|5[- ]?hour|weekly limit|exceed/.test(text)
+  return error.statusCode === 429 || type === "rate_limit_error" || rateLimitText
+}
+
+function parseResetMs(error: RetryErrorLike): number | undefined {
+  const headers = lowerKeys(error.responseHeaders)
+  const reset = Number(headers["anthropic-ratelimit-unified-reset"])
+  if (Number.isFinite(reset) && reset > 0) return reset * 1000
+  const retryAfter = Number(headers["retry-after"])
+  if (Number.isFinite(retryAfter) && retryAfter > 0) return Date.now() + retryAfter * 1000
+  return undefined
+}
+
+function toErrorData(error: unknown): RetryErrorLike | undefined {
+  if (typeof error !== "object" || error === null) return undefined
+  const candidate = error as { name?: unknown; data?: RetryErrorLike }
+  if (candidate.name === "APIError" && candidate.data && typeof candidate.data === "object") return candidate.data
+  return undefined
+}
+
+function score(usage?: UsageResponse): number {
+  if (!usage) return Number.POSITIVE_INFINITY
+  return Math.max(
+    usage.five_hour?.utilization ?? 0,
+    usage.seven_day?.utilization ?? 0,
+    usage.seven_day_sonnet?.utilization ?? 0,
+    usage.seven_day_opus?.utilization ?? 0,
+  )
+}
+
+function fmtDuration(ms: number): string {
+  const minutes = Math.max(1, Math.round(ms / 60_000))
+  if (minutes < 60) return `${minutes} 分钟`
+  const hours = Math.floor(minutes / 60)
+  const rest = minutes % 60
+  return rest > 0 ? `${hours} 小时 ${rest} 分钟` : `${hours} 小时`
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function debugLog(tag: string, payload: unknown): void {
+  if (!process.env.CLAUDE_AUTOSWITCH_DEBUG) return
+  let serialized: string
+  try {
+    serialized = JSON.stringify(payload)
+  } catch {
+    serialized = String(payload)
+  }
+  const line = `${new Date().toISOString()} [${tag}] ${serialized}\n`
+  void appendFile(join(homedir(), ".config", "opencode", "claude-autoswitch.log"), line).catch(() => undefined)
+}
+
+export function installAutoSwitch(api: TuiPluginApi): AutoSwitchController {
+  const cooldown = new Map<string, number>()
+  const attempted = new Map<string, Set<string>>()
+  const sessionLocks = new Map<string, Promise<unknown>>()
+  const repromptInFlight = new Set<string>()
+  const lastAction = new Map<string, number>()
+  const seen = new Set<string>()
+  let usageCache: { at: number; byId: Map<string, UsageResponse> } = { at: 0, byId: new Map() }
+  let refreshing = false
+  let lastSwitch: { id?: string; sessionID?: string; at: number } = { at: 0 }
+
+  const stored = api.kv.get<Record<string, number>>(COOLDOWN_KV_KEY, {})
+  if (stored) for (const [id, until] of Object.entries(stored)) cooldown.set(id, until)
+
+  function persistCooldown(): void {
+    const now = Date.now()
+    const snapshot: Record<string, number> = {}
+    for (const [id, until] of cooldown) if (until > now) snapshot[id] = until
+    api.kv.set(COOLDOWN_KV_KEY, snapshot)
+  }
+
+  function markCooldown(id: string, untilMs?: number): void {
+    cooldown.set(id, untilMs ?? Date.now() + DEFAULT_COOLDOWN_MS)
+    persistCooldown()
+  }
+
+  function clearCooldown(id: string): void {
+    if (cooldown.delete(id)) persistCooldown()
+  }
+
+  function isCooled(id: string, now: number): boolean {
+    const until = cooldown.get(id)
+    return typeof until === "number" && until > now
+  }
+
+  function setUsageCache(results: AccountUsage[]): void {
+    const byId = new Map<string, UsageResponse>()
+    for (const result of results) if (result.usage) byId.set(result.id, result.usage)
+    usageCache = { at: Date.now(), byId }
+  }
+
+  async function refreshUsageInBackground(): Promise<void> {
+    if (refreshing) return
+    refreshing = true
+    try {
+      const { results } = await collectAllUsage()
+      setUsageCache(results)
+    } catch {
+      // best-effort cache warming; selection falls back to round-robin
+    } finally {
+      refreshing = false
+    }
+  }
+
+  function dedup(id: string): boolean {
+    if (seen.has(id)) return false
+    seen.add(id)
+    if (seen.size > 1000) {
+      seen.clear()
+      seen.add(id)
+    }
+    return true
+  }
+
+  function runExclusive<T>(key: string, fn: () => Promise<T>): Promise<T> {
+    const prev = sessionLocks.get(key) ?? Promise.resolve()
+    const run = prev.then(fn, fn)
+    sessionLocks.set(
+      key,
+      run.then(
+        () => undefined,
+        () => undefined,
+      ),
+    )
+    return run
+  }
+
+  function labelOf(file: AccountsFile, id?: string): string {
+    return file.accounts.find((account) => account.id === id)?.label ?? "当前账号"
+  }
+
+  function lastAssistant(sessionID: string): AssistantMsg | undefined {
+    const messages = api.state.session.messages(sessionID)
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const message = messages[i]
+      if (message.role === "assistant") return message
+    }
+    return undefined
+  }
+
+  function isAnthropicSession(sessionID: string): boolean {
+    const assistant = lastAssistant(sessionID)
+    return !assistant || assistant.providerID === "anthropic"
+  }
+
+  function pickNext(file: AccountsFile, tried: Set<string>, activeId?: string): StoredAccount | undefined {
+    const now = Date.now()
+    const candidates = file.accounts.filter(
+      (account) => account.id !== activeId && !tried.has(account.id) && !isCooled(account.id, now),
+    )
+    if (candidates.length === 0) return undefined
+
+    const cacheFresh = usageCache.at > 0 && now - usageCache.at <= USAGE_CACHE_TTL_MS
+    if (cacheFresh) {
+      return [...candidates].sort((a, b) => score(usageCache.byId.get(a.id)) - score(usageCache.byId.get(b.id)))[0]
+    }
+
+    const order = file.accounts.map((account) => account.id)
+    const start = activeId ? order.indexOf(activeId) : -1
+    for (let offset = 1; offset <= order.length; offset++) {
+      const id = order[(start + offset + order.length) % order.length]
+      const match = candidates.find((account) => account.id === id)
+      if (match) return match
+    }
+    return candidates[0]
+  }
+
+  function standDown(file: AccountsFile): void {
+    const now = Date.now()
+    const times = file.accounts
+      .map((account) => cooldown.get(account.id))
+      .filter((until): until is number => typeof until === "number" && until > now)
+    const soonest = times.length > 0 ? Math.min(...times) : undefined
+    const message = soonest
+      ? `所有账号都已达额度上限，约 ${fmtDuration(soonest - now)} 后恢复`
+      : "所有账号都已达额度上限"
+    debugLog("standdown", { accounts: file.accounts.length, soonest })
+    api.ui.toast({ variant: "error", message })
+  }
+
+  async function doSwitch(sessionID: string, error: RetryErrorLike, activeId?: string): Promise<boolean> {
+    if (activeId) markCooldown(activeId, parseResetMs(error))
+
+    const file = await loadAccounts()
+    const tried = attempted.get(sessionID) ?? new Set<string>()
+    attempted.set(sessionID, tried)
+    if (file.accounts.length <= 1) {
+      standDown(file)
+      return false
+    }
+
+    for (let i = 0; i < file.accounts.length; i++) {
+      const next = pickNext(file, tried, activeId)
+      if (!next) break
+      try {
+        const account = await switchToAccount(next.id)
+        tried.add(next.id)
+        lastSwitch = { id: account.id, sessionID, at: Date.now() }
+        debugLog("switched", { from: labelOf(file, activeId), to: account.label })
+        api.ui.toast({
+          variant: "warning",
+          message: `「${labelOf(file, activeId)}」额度已满，已切到「${account.label}」并自动重试`,
+        })
+        void refreshUsageInBackground()
+        return true
+      } catch {
+        tried.add(next.id)
+        markCooldown(next.id, undefined)
+      }
+    }
+
+    standDown(file)
+    return false
+  }
+
+  function toInputParts(parts: StateParts): PromptParts {
+    const out: PromptParts = []
+    for (const part of parts) {
+      if (part.type === "text") {
+        if (part.synthetic || part.ignored) continue
+        if (part.text && part.text.trim().length > 0) out.push({ type: "text", text: part.text })
+      } else if (part.type === "file") {
+        out.push({ type: "file", mime: part.mime, filename: part.filename, url: part.url, source: part.source })
+      }
+    }
+    return out
+  }
+
+  function findFailedAssistant(messages: ReturnType<TuiPluginApi["state"]["session"]["messages"]>): AssistantMsg | undefined {
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const message = messages[i]
+      if (message.role === "assistant" && message.error) return message
+    }
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const message = messages[i]
+      if (message.role === "assistant") return message
+    }
+    return undefined
+  }
+
+  function findUserMessage(
+    messages: ReturnType<TuiPluginApi["state"]["session"]["messages"]>,
+    failed?: AssistantMsg,
+  ): StateMessage | undefined {
+    if (failed?.parentID) {
+      const parent = messages.find((message) => message.id === failed.parentID && message.role === "user")
+      if (parent) return parent
+    }
+    const failedIndex = failed ? messages.findIndex((message) => message.id === failed.id) : messages.length
+    const from = (failedIndex < 0 ? messages.length : failedIndex) - 1
+    for (let i = from; i >= 0; i--) {
+      if (messages[i].role === "user") return messages[i]
+    }
+    return undefined
+  }
+
+  async function waitIdle(sessionID: string): Promise<void> {
+    const deadline = Date.now() + IDLE_WAIT_TIMEOUT_MS
+    while (Date.now() < deadline) {
+      const status = api.state.session.status(sessionID)
+      if (!status || status.type === "idle") return
+      await sleep(IDLE_POLL_MS)
+    }
+  }
+
+  async function repromptFailedTurn(sessionID: string, abortFirst: boolean): Promise<void> {
+    if (repromptInFlight.has(sessionID)) return
+    repromptInFlight.add(sessionID)
+    const guidance = () => api.ui.toast({ variant: "info", message: "已切换账号，请手动重新发送上一条消息" })
+    try {
+      if (abortFirst) {
+        try {
+          await api.client.session.abort({ sessionID })
+        } catch {
+          // ignore: stream may already be settling
+        }
+      }
+      await waitIdle(sessionID)
+
+      const messages = api.state.session.messages(sessionID)
+      const failed = findFailedAssistant(messages)
+      const userMessage = findUserMessage(messages, failed)
+      if (!userMessage) return guidance()
+
+      const parts = toInputParts(api.state.part(userMessage.id))
+      if (parts.length === 0) return guidance()
+
+      const reverted = await api.client.session.revert({ sessionID, messageID: userMessage.id })
+      if (reverted.error) return guidance()
+
+      const prompted = await api.client.session.promptAsync({ sessionID, parts })
+      if (prompted.error) guidance()
+    } catch {
+      guidance()
+    } finally {
+      repromptInFlight.delete(sessionID)
+    }
+  }
+
+  async function handleLimit(sessionID: string, error: RetryErrorLike, mode: "retry" | "error"): Promise<void> {
+    await runExclusive(sessionID, async () => {
+      const now = Date.now()
+      // Coalesce the burst of retry/error events a single failed turn emits: once we have
+      // acted for this session, ignore further limit events until that action settles.
+      if (now - (lastAction.get(sessionID) ?? 0) < RECENT_SWITCH_GUARD_MS) return
+
+      const activeId = await readActiveId()
+      // Cross-session race: another session just switched to this fresh account, so the
+      // failure predates the switch. Reuse the fresh account instead of cooling it again.
+      const reuseFresh =
+        !!activeId && lastSwitch.id === activeId && lastSwitch.sessionID !== sessionID && now - lastSwitch.at < RECENT_SWITCH_GUARD_MS
+      const usable = reuseFresh ? true : await doSwitch(sessionID, error, activeId)
+      if (!usable) return
+
+      lastAction.set(sessionID, Date.now())
+      await repromptFailedTurn(sessionID, mode === "retry")
+    })
+  }
+
+  async function onRetried(event: { id: string; properties: { sessionID: string; error: RetryErrorLike } }): Promise<void> {
+    const error = event.properties.error
+    debugLog("retried", {
+      sessionID: event.properties.sessionID,
+      statusCode: error?.statusCode,
+      message: error?.message,
+      headerKeys: Object.keys(error?.responseHeaders ?? {}),
+      body: (error?.responseBody ?? "").slice(0, 300),
+    })
+    if (!ENABLED || !dedup(event.id)) return
+    const matched = isUsageLimit(error)
+    const anthropic = isAnthropicSession(event.properties.sessionID)
+    debugLog("retried-decision", { matched, anthropic })
+    if (!matched || !anthropic) return
+    await handleLimit(event.properties.sessionID, error, "retry")
+  }
+
+  async function onStatus(event: {
+    id: string
+    properties: { sessionID: string; status?: { type: string; message?: string; next?: number } }
+  }): Promise<void> {
+    const status = event.properties.status
+    debugLog("status", {
+      sessionID: event.properties.sessionID,
+      type: status?.type,
+      message: status?.type === "retry" ? status.message : undefined,
+    })
+    if (status?.type !== "retry" || !ENABLED || !dedup(event.id)) return
+    const error: RetryErrorLike = { message: status.message }
+    const matched = isUsageLimit(error)
+    const anthropic = isAnthropicSession(event.properties.sessionID)
+    debugLog("status-decision", { matched, anthropic })
+    if (!matched || !anthropic) return
+    await handleLimit(event.properties.sessionID, error, "retry")
+  }
+
+  async function onError(event: { id: string; properties: { sessionID?: string; error?: unknown } }): Promise<void> {
+    const sessionID = event.properties.sessionID
+    const error = toErrorData(event.properties.error)
+    debugLog("error", {
+      sessionID,
+      raw: event.properties.error,
+      statusCode: error?.statusCode,
+      message: error?.message,
+    })
+    if (!ENABLED || !dedup(event.id) || !sessionID) return
+    const matched = !!error && isUsageLimit(error)
+    const anthropic = isAnthropicSession(sessionID)
+    debugLog("error-decision", { matched, anthropic })
+    if (!matched || !anthropic) return
+    await handleLimit(sessionID, error, "error")
+  }
+
+  async function onIdle(sessionID: string): Promise<void> {
+    const assistant = lastAssistant(sessionID)
+    if (assistant && !assistant.error) {
+      const activeId = await readActiveId()
+      if (activeId) clearCooldown(activeId)
+    }
+  }
+
+  debugLog("installed", { enabled: ENABLED })
+
+  const offs = [
+    api.event.on("session.status", (event) => {
+      void onStatus(event)
+    }),
+    api.event.on("session.next.retried", (event) => {
+      void onRetried(event)
+    }),
+    api.event.on("session.error", (event) => {
+      void onError(event)
+    }),
+    api.event.on("session.next.prompted", (event) => {
+      attempted.delete(event.properties.sessionID)
+      lastAction.delete(event.properties.sessionID)
+    }),
+    api.event.on("session.idle", (event) => {
+      void onIdle(event.properties.sessionID)
+    }),
+  ]
+
+  return {
+    dispose: () => {
+      for (const off of offs) {
+        try {
+          off()
+        } catch {
+          // ignore unsubscribe failures during teardown
+        }
+      }
+      persistCooldown()
+    },
+    setUsageCache,
+  }
+}

package/src/constants.ts

@@ -0,0 +1,16 @@
+// Shared Anthropic OAuth client_id used by the official Claude Pro/Max flow
+// (same value as @ex-machina/opencode-anthropic-auth), so refresh tokens stored
+// by that plugin are accepted by the refresh endpoint below.
+export const CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e"
+
+export const TOKEN_URL = "https://console.anthropic.com/v1/oauth/token"
+
+export const USAGE_ENDPOINT = "https://api.anthropic.com/api/oauth/usage"
+
+export const PROFILE_ENDPOINT = "https://api.anthropic.com/api/oauth/profile"
+
+export const OAUTH_BETA = "oauth-2025-04-20"
+
+// Refresh slightly before real expiry so neither ex-machina nor the usage call
+// receives an already-stale access token.
+export const TOKEN_EXPIRY_BUFFER_MS = 60_000

package/src/dialogs.tsx

@@ -0,0 +1,138 @@
+/** @jsxImportSource @opentui/solid */
+import { For, Show } from "solid-js"
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
+import type { StoredAccount } from "./accounts.ts"
+import type { AccountUsage, UsageWindow } from "./usage.ts"
+
+export type UsageState = {
+  loading: boolean
+  results: AccountUsage[]
+  updatedAt?: number
+  error?: string
+}
+
+function bar(util: number, width = 18): string {
+  const pct = Math.max(0, Math.min(100, util))
+  const fill = Math.round((pct / 100) * width)
+  return `[${"#".repeat(fill)}${"-".repeat(width - fill)}]`
+}
+
+function percent(util: number): string {
+  return `${Math.round(util)}%`
+}
+
+function tone(api: TuiPluginApi, util: number) {
+  const theme = api.theme.current
+  if (util >= 85) return theme.error
+  if (util >= 60) return theme.warning
+  return theme.success
+}
+
+function resetIn(iso: string): string {
+  const ms = new Date(iso).getTime() - Date.now()
+  if (ms <= 0) return "now"
+  const hours = Math.floor(ms / 3_600_000)
+  const minutes = Math.floor((ms % 3_600_000) / 60_000)
+  if (hours >= 24) return `${Math.floor(hours / 24)}d ${hours % 24}h`
+  if (hours > 0) return `${hours}h ${minutes}m`
+  return `${minutes}m`
+}
+
+function clockTime(ts: number): string {
+  return new Date(ts).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })
+}
+
+function WindowRow(props: { api: TuiPluginApi; name: string; win?: UsageWindow }) {
+  const theme = () => props.api.theme.current
+  return (
+    <Show when={props.win}>
+      {(win) => (
+        <box flexDirection="row" gap={1}>
+          <text fg={theme().textMuted}>{props.name.padEnd(6)}</text>
+          <text fg={tone(props.api, win().utilization)}>
+            {bar(win().utilization)} {percent(win().utilization)}
+          </text>
+          <Show when={win().resets_at}>
+            <text fg={theme().textMuted}>重置 {resetIn(win().resets_at!)}</text>
+          </Show>
+        </box>
+      )}
+    </Show>
+  )
+}
+
+function AccountBlock(props: { api: TuiPluginApi; item: AccountUsage }) {
+  const theme = () => props.api.theme.current
+  return (
+    <box flexDirection="column">
+      <text fg={theme().text}>
+        {props.item.active ? "●" : "○"} {props.item.label}
+        {props.item.active ? " (当前)" : ""}
+      </text>
+      <Show when={props.item.error}>
+        <text fg={theme().error}>  {props.item.error}</text>
+      </Show>
+      <Show when={props.item.usage}>
+        {(usage) => (
+          <box flexDirection="column" paddingLeft={2}>
+            <WindowRow api={props.api} name="5h" win={usage().five_hour} />
+            <WindowRow api={props.api} name="7d" win={usage().seven_day} />
+            <WindowRow api={props.api} name="Sonnet" win={usage().seven_day_sonnet} />
+          </box>
+        )}
+      </Show>
+    </box>
+  )
+}
+
+function UsageDialog(props: { api: TuiPluginApi; state: () => UsageState }) {
+  const api = props.api
+  const theme = () => api.theme.current
+  return (
+    <box paddingTop={1} paddingBottom={1} paddingLeft={2} paddingRight={2} gap={1} flexDirection="column">
+      <box flexDirection="row" justifyContent="space-between">
+        <text fg={theme().text}>
+          <b>Claude 账号用量</b>
+        </text>
+        <text fg={theme().textMuted}>esc 关闭</text>
+      </box>
+      <Show when={props.state().loading && props.state().results.length === 0}>
+        <text fg={theme().textMuted}>加载中…</text>
+      </Show>
+      <Show when={props.state().error}>
+        <text fg={theme().error}>{props.state().error}</text>
+      </Show>
+      <For each={props.state().results}>{(item) => <AccountBlock api={api} item={item} />}</For>
+      <Show when={props.state().updatedAt}>
+        <text fg={theme().textMuted}>更新于 {clockTime(props.state().updatedAt!)}</text>
+      </Show>
+    </box>
+  )
+}
+
+export function openUsageDialog(api: TuiPluginApi, state: () => UsageState): void {
+  api.ui.dialog.setSize("medium")
+  api.ui.dialog.replace(() => <UsageDialog api={api} state={state} />)
+}
+
+export function openSwitchDialog(
+  api: TuiPluginApi,
+  accounts: StoredAccount[],
+  activeId: string | undefined,
+  onSwitch: (id: string) => void | Promise<void>,
+): void {
+  api.ui.dialog.replace(() =>
+    api.ui.DialogSelect<string>({
+      title: "切换 Claude 账号",
+      current: activeId,
+      options: accounts.map((account) => ({
+        title: account.id === activeId ? `${account.label} (当前)` : account.label,
+        value: account.id,
+      })),
+      onSelect: (option) => {
+        api.ui.dialog.clear()
+        void onSwitch(option.value)
+      },
+    }),
+  )
+}

package/src/profile.ts

@@ -0,0 +1,26 @@
+import { OAUTH_BETA, PROFILE_ENDPOINT } from "./constants.ts"
+
+export type Profile = {
+  uuid: string
+  email: string
+  displayName: string
+}
+
+export async function fetchProfile(access: string): Promise<Profile> {
+  const res = await fetch(PROFILE_ENDPOINT, {
+    headers: { Authorization: `Bearer ${access}`, "anthropic-beta": OAUTH_BETA },
+  })
+  if (!res.ok) throw new Error(`profile request failed (${res.status})`)
+
+  const json = (await res.json()) as {
+    account?: { uuid?: string; email?: string; display_name?: string; full_name?: string }
+  }
+  const account = json.account
+  if (!account?.uuid) throw new Error("profile response missing account uuid")
+
+  return {
+    uuid: account.uuid,
+    email: account.email ?? account.uuid,
+    displayName: account.display_name ?? account.full_name ?? account.email ?? account.uuid,
+  }
+}

package/src/usage.ts

@@ -0,0 +1,128 @@
+import type { AuthToken, StoredAccount } from "./accounts.ts"
+import { loadAccounts, readAuthAnthropic, saveAccounts, upsertAccount, withAuthLock, writeAuthAnthropic } from "./accounts.ts"
+import { CLIENT_ID, OAUTH_BETA, TOKEN_EXPIRY_BUFFER_MS, TOKEN_URL, USAGE_ENDPOINT } from "./constants.ts"
+import { fetchProfile } from "./profile.ts"
+
+export type UsageWindow = { utilization: number; resets_at?: string }
+
+export type UsageResponse = {
+  five_hour?: UsageWindow
+  seven_day?: UsageWindow
+  seven_day_sonnet?: UsageWindow
+  seven_day_opus?: UsageWindow
+}
+
+export type AccountUsage = {
+  id: string
+  label: string
+  active: boolean
+  usage?: UsageResponse
+  error?: string
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function isStale(token: { access?: string; expires?: number }): boolean {
+  return !token.access || !token.expires || token.expires < Date.now() + TOKEN_EXPIRY_BUFFER_MS
+}
+
+export async function refreshToken(refresh: string): Promise<{ access: string; refresh: string; expires: number }> {
+  const res = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ grant_type: "refresh_token", refresh_token: refresh, client_id: CLIENT_ID }),
+  })
+  if (!res.ok) throw new Error(`token refresh failed (${res.status})`)
+  const json = (await res.json()) as { access_token: string; refresh_token: string; expires_in: number }
+  return {
+    access: json.access_token,
+    refresh: json.refresh_token,
+    expires: Date.now() + json.expires_in * 1000,
+  }
+}
+
+export async function fetchUsage(access: string): Promise<UsageResponse> {
+  const res = await fetch(USAGE_ENDPOINT, {
+    headers: { Authorization: `Bearer ${access}`, "anthropic-beta": OAUTH_BETA },
+  })
+  if (!res.ok) throw new Error(`usage request failed (${res.status})`)
+  return (await res.json()) as UsageResponse
+}
+
+// Identify whatever account ex-machina currently holds in auth.json by its profile
+// uuid (stable across token rotation) and upsert it: the same account is updated in
+// place, a genuinely new login is added — so no manual /account-add is needed.
+export async function autoCapture(): Promise<void> {
+  await withAuthLock(async () => {
+    const auth = await readAuthAnthropic()
+    if (!auth?.refresh) return
+
+    let token: AuthToken = { refresh: auth.refresh, access: auth.access, expires: auth.expires }
+    if (isStale(token)) {
+      token = await refreshToken(token.refresh)
+      await writeAuthAnthropic(token)
+    }
+
+    const profile = await fetchProfile(token.access!)
+    await upsertAccount(profile.uuid, profile.email, token)
+  })
+}
+
+async function ensureFresh(account: StoredAccount): Promise<{ access?: string; updated?: StoredAccount }> {
+  if (!isStale(account)) return { access: account.access }
+  const fresh = await refreshToken(account.refresh)
+  return { access: fresh.access, updated: { ...account, ...fresh } }
+}
+
+export async function collectAllUsage(): Promise<{ activeId?: string; results: AccountUsage[] }> {
+  const file = await loadAccounts()
+
+  const settled = await Promise.all(
+    file.accounts.map(async (account): Promise<{ result: AccountUsage; updated?: StoredAccount }> => {
+      const base = { id: account.id, label: account.label, active: account.id === file.activeId }
+      try {
+        const { access, updated } = await ensureFresh(account)
+        if (!access) return { result: { ...base, error: "missing access token" }, updated }
+        return { result: { ...base, usage: await fetchUsage(access) }, updated }
+      } catch (error) {
+        return { result: { ...base, error: errorMessage(error) } }
+      }
+    }),
+  )
+
+  const updated = settled.flatMap((entry) => (entry.updated ? [entry.updated] : []))
+  if (updated.length > 0) {
+    await withAuthLock(async () => {
+      const current = await loadAccounts()
+      for (const account of updated) {
+        const index = current.accounts.findIndex((existing) => existing.id === account.id)
+        if (index >= 0) current.accounts[index] = { ...current.accounts[index], ...account }
+      }
+      await saveAccounts(current)
+    })
+  }
+
+  return { activeId: file.activeId, results: settled.map((entry) => entry.result) }
+}
+
+export async function switchToAccount(id: string): Promise<StoredAccount> {
+  return withAuthLock(async () => {
+    const file = await loadAccounts()
+    const index = file.accounts.findIndex((account) => account.id === id)
+    if (index < 0) throw new Error("account not found")
+
+    let account = file.accounts[index]
+    if (isStale(account)) {
+      const fresh = await refreshToken(account.refresh)
+      account = { ...account, ...fresh }
+      file.accounts[index] = account
+    }
+
+    file.activeId = id
+    await saveAccounts(file)
+    await writeAuthAnthropic({ refresh: account.refresh, access: account.access, expires: account.expires })
+    return account
+  })
+}

package/tui.tsx

@@ -0,0 +1,78 @@
+import { createSignal } from "solid-js"
+import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui"
+import { loadAccounts } from "./src/accounts.ts"
+import { autoCapture, collectAllUsage, switchToAccount } from "./src/usage.ts"
+import { installAutoSwitch } from "./src/autoswitch.ts"
+import { openSwitchDialog, openUsageDialog, type UsageState } from "./src/dialogs.tsx"
+
+const ID = "claude-accounts-usage"
+
+function message(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+const tui: TuiPlugin = async (api) => {
+  const [state, setState] = createSignal<UsageState>({ loading: false, results: [] })
+
+  const autoSwitch = installAutoSwitch(api)
+  api.lifecycle.onDispose(autoSwitch.dispose)
+
+  const refreshUsage = async () => {
+    try {
+      await autoCapture()
+      const { results } = await collectAllUsage()
+      autoSwitch.setUsageCache(results)
+      setState({ loading: false, results, updatedAt: Date.now() })
+    } catch (error) {
+      setState((prev) => ({ loading: false, results: prev.results, error: message(error) }))
+    }
+  }
+
+  void autoCapture().catch(() => undefined)
+
+  const command = api.command
+  if (!command) {
+    api.ui.toast({ variant: "error", message: "当前 OpenCode 不支持命令注册 API,请更新 OpenCode" })
+    return
+  }
+
+  command.register(() => [
+    {
+      title: "Claude: 查看账号用量",
+      value: `${ID}.usage`,
+      category: "Claude",
+      slash: { name: "usage" },
+      onSelect: () => {
+        setState((prev) => ({ ...prev, loading: true, error: undefined }))
+        openUsageDialog(api, state)
+        void refreshUsage()
+      },
+    },
+    {
+      title: "Claude: 切换账号",
+      value: `${ID}.switch`,
+      category: "Claude",
+      slash: { name: "switch" },
+      onSelect: async () => {
+        await autoCapture().catch(() => undefined)
+        const file = await loadAccounts()
+        if (file.accounts.length === 0) {
+          api.ui.toast({ variant: "warning", message: "没有账号。请先用 ex-machina 登录 Claude" })
+          return
+        }
+        openSwitchDialog(api, file.accounts, file.activeId, async (id) => {
+          try {
+            const account = await switchToAccount(id)
+            api.ui.toast({ variant: "success", message: `已切换到 ${account.label},下次对话生效` })
+          } catch (error) {
+            api.ui.toast({ variant: "error", message: `切换失败: ${message(error)}` })
+          }
+        })
+      },
+    },
+  ])
+}
+
+const plugin: TuiPluginModule & { id: string } = { id: ID, tui }
+
+export default plugin