@cortexkit/opencode-anthropic-auth 1.15.0 → 1.16.0

package/src/tui/command-dialogs.tsx

@@ -65,6 +65,17 @@ export function openCommandDialog(
             value: 'fallback-first',
             description: 'Prefer fallback accounts, preserve main',
           },
+          {
+            title: 'Sticky balanced',
+            value: 'sticky-balanced',
+            description:
+              'Balance new sessions by quota and keep each account sticky',
+          },
+          {
+            title: 'Reset this session',
+            value: 'reset',
+            description: 'Reassign this session on its next request',
+          },
         ]}
         onSelect={(option) => {
           void apply('claude-routing', String(option.value)).then((r) => {
@@ -158,9 +169,9 @@ export function openCommandDialog(
     api.ui.dialog.setSize('xlarge')
     api.ui.dialog.replace(() => (
       <DialogPrompt
-        title='Claude cachekeep window'
+        title='Claude cachekeep schedule'
         description={() => <text>{payload.text}</text>}
-        placeholder="HH-HH (e.g. 08-20) or 'off'"
+        placeholder="'always', HH-HH (e.g. 08-20), or 'off'"
         value={seed}
         onConfirm={(value: string) => {
           void apply('claude-cachekeep', value.trim()).then((r) => {

package/src/tui/entry.mjs

@@ -0,0 +1,37 @@
+// Prefer the host OpenTUI runtime registry when it exists. OpenTUI 0.4.x
+// registers these virtual modules process-wide, allowing the precompiled TUI to
+// share the host's single Solid/OpenTUI runtime when loaded from node_modules.
+const runtimeProbe = `opentui:runtime-module:${encodeURIComponent('@opentui/solid')}`
+
+function isMissingRuntimeRegistry(error) {
+  const message = error instanceof Error ? error.message : String(error)
+  return (
+    /Cannot find|Could not resolve|Module not found|Unable to resolve/.test(
+      message,
+    ) && message.includes('opentui:runtime-module:')
+  )
+}
+
+let mod
+try {
+  await import(runtimeProbe)
+} catch (error) {
+  if (!isMissingRuntimeRegistry(error)) {
+    console.error('Anthropic Auth TUI runtime registry probe failed', error)
+    throw error
+  }
+  // Older hosts and bare Bun do not provide the virtual registry. Their source
+  // loader still applies the Solid transform, so retain the raw TSX fallback.
+  mod = await import('../tui.tsx')
+}
+
+if (!mod) {
+  try {
+    mod = await import('../tui-compiled/tui.tsx')
+  } catch (error) {
+    console.error('Anthropic Auth compiled TUI failed to load', error)
+    throw error
+  }
+}
+
+export default mod.default

package/src/tui-compiled/rpc/port-file.ts

@@ -0,0 +1,70 @@
+import {
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  unlink,
+  writeFile,
+} from 'node:fs/promises'
+import { join } from 'node:path'
+
+export interface PortFileEntry {
+  port: number
+  token: string
+  pid: number
+  startedAt: number
+}
+
+function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'EPERM'
+  }
+}
+
+export async function writePortFile(
+  dir: string,
+  entry: { port: number; token: string; pid: number },
+): Promise<string> {
+  await mkdir(dir, { recursive: true })
+  const full: PortFileEntry = { ...entry, startedAt: Date.now() }
+  const target = join(dir, `port-${entry.pid}.json`)
+  const tmp = `${target}.${process.pid}.tmp`
+  await writeFile(tmp, JSON.stringify(full), { encoding: 'utf8', mode: 0o600 })
+  await rename(tmp, target)
+  return target
+}
+
+export async function discoverPortFile(
+  dir: string,
+  expectedPid?: number,
+): Promise<PortFileEntry | null> {
+  let names: string[]
+  try {
+    names = await readdir(dir)
+  } catch {
+    return null
+  }
+  const live: PortFileEntry[] = []
+  for (const name of names) {
+    if (!name.startsWith('port-') || !name.endsWith('.json')) continue
+    try {
+      const parsed = JSON.parse(
+        await readFile(join(dir, name), 'utf8'),
+      ) as PortFileEntry
+      if (Number.isFinite(parsed.port)) {
+        if (pidAlive(parsed.pid)) live.push(parsed)
+        else unlink(join(dir, name)).catch(() => {})
+      }
+    } catch {}
+  }
+  if (live.length === 0) return null
+  const candidates =
+    expectedPid && expectedPid >= 1
+      ? live.filter((entry) => entry.pid === expectedPid)
+      : []
+  const entries = candidates.length > 0 ? candidates : live
+  return entries.sort((a, b) => b.startedAt - a.startedAt)[0] ?? null
+}

package/src/tui-compiled/rpc/protocol.ts

@@ -0,0 +1,34 @@
+export type CommandModalName =
+  | 'claude-account'
+  | 'claude-cache'
+  | 'claude-cachekeep'
+  | 'claude-quota'
+  | 'claude-dump'
+  | 'claude-fast'
+  | 'claude-routing'
+  | 'claude-killswitch'
+  | 'claude-logging'
+
+export interface OpenDialogPayload {
+  command: CommandModalName
+  text: string
+  knobs: Record<string, unknown>
+}
+
+export interface RpcNotification {
+  id: number
+  type: 'open-dialog'
+  payload: OpenDialogPayload
+  sessionId?: string
+}
+
+export interface ApplyRequest {
+  command: CommandModalName
+  arguments: string
+  sessionId?: string
+}
+
+export interface ApplyResult {
+  text: string
+  knobs: Record<string, unknown>
+}

package/src/tui-compiled/rpc/rpc-client.ts

@@ -0,0 +1,62 @@
+import { discoverPortFile } from './port-file'
+import type { ApplyRequest, ApplyResult, RpcNotification } from './protocol'
+
+export interface RpcClient {
+  pending: (
+    lastReceivedId: number,
+    sessionId?: string,
+  ) => Promise<RpcNotification[]>
+  apply: (request: ApplyRequest) => Promise<ApplyResult>
+}
+
+async function call<T>(
+  dir: string,
+  method: string,
+  params: Record<string, unknown>,
+  expectedPid?: number,
+): Promise<T | null> {
+  const entry = await discoverPortFile(dir, expectedPid)
+  if (!entry) return null
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), 2_000)
+  try {
+    const res = await fetch(`http://127.0.0.1:${entry.port}/rpc/${method}`, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        authorization: `Bearer ${entry.token}`,
+      },
+      body: JSON.stringify(params),
+      signal: controller.signal,
+    })
+    if (!res.ok) return null
+    return (await res.json()) as T
+  } catch {
+    return null
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+export function createRpcClient(dir: string, expectedPid?: number): RpcClient {
+  return {
+    async pending(lastReceivedId, sessionId) {
+      const out = await call<{ messages: RpcNotification[] }>(
+        dir,
+        'pending-notifications',
+        { lastReceivedId, sessionId },
+        expectedPid,
+      )
+      return out?.messages ?? []
+    },
+    async apply(request) {
+      const out = await call<ApplyResult>(
+        dir,
+        'apply',
+        { ...request },
+        expectedPid,
+      )
+      return out ?? { text: 'apply failed', knobs: {} }
+    },
+  }
+}

package/src/tui-compiled/rpc/rpc-dir.ts

@@ -0,0 +1,19 @@
+import { createHash } from 'node:crypto'
+import { homedir, tmpdir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+const RPC_DIR_ENV = 'OPENCODE_ANTHROPIC_AUTH_RPC_DIR'
+
+// Both processes must resolve the SAME dir from the SAME project directory.
+export function getRpcDir(projectDirectory: string): string {
+  const override = process.env[RPC_DIR_ENV]?.trim()
+  if (override) return resolve(projectDirectory, override)
+  const hash = createHash('sha256')
+    .update(projectDirectory)
+    .digest('hex')
+    .slice(0, 16)
+  const base = process.env.XDG_STATE_HOME || join(homedir(), '.local', 'state')
+  return join(base, 'cortexkit', 'anthropic-auth', 'rpc', hash)
+}
+
+export { tmpdir }

package/src/tui-compiled/sidebar-state.ts

@@ -0,0 +1,410 @@
+export interface QuotaWindow {
+  usedPercent: number
+  remainingPercent: number
+  resetsAt?: string
+}
+
+export interface ScopedQuotaWindow extends QuotaWindow {
+  id: string
+  title: string
+  modelId?: string
+  modelName: string
+}
+
+export interface AccountQuota {
+  five_hour?: QuotaWindow
+  seven_day?: QuotaWindow
+  scoped?: ScopedQuotaWindow[]
+}
+
+export interface SidebarAccountState {
+  id: string
+  label: string | undefined
+  quota: AccountQuota | null
+  enabled: boolean
+  // True when the account's refresh token is permanently dead (400
+  // invalid_grant) and it needs a re-login — distinct from a transient backoff.
+  needsReauth: boolean
+}
+
+export interface FableRecoverySidebarState {
+  sessionId: string
+  mode: 'opus' | 'fable'
+  remaining: number
+  changedAt: number
+}
+
+export interface SidebarState {
+  main: {
+    quota: AccountQuota | null
+    quotaBackedOff?: boolean
+    quotaBackoffUntil?: number
+    refreshBackedOff?: boolean
+    refreshBackoffUntil?: number
+  }
+  fallbacks: SidebarAccountState[]
+  activeId: string | undefined
+  route: string
+  relay: { enabled: boolean; transport: string } | null
+  fastMode: boolean
+  cacheKeep?: {
+    enabled: boolean
+    window?: string
+    trackedSessions?: number
+  }
+  fableRecoveries?: FableRecoverySidebarState[]
+  lastUpdated: number
+}
+
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+const STATE_FILE_ENV = 'OPENCODE_ANTHROPIC_AUTH_SIDEBAR_STATE_FILE'
+const DEFAULT_STATE_DIR = join(tmpdir(), 'opencode-anthropic-auth')
+const DEFAULT_STATE_FILE = join(DEFAULT_STATE_DIR, 'sidebar-state.json')
+
+export function getSidebarStateFile(): string {
+  return process.env[STATE_FILE_ENV] || DEFAULT_STATE_FILE
+}
+
+export const DEFAULT_SIDEBAR_STATE: SidebarState = {
+  main: { quota: null },
+  fallbacks: [],
+  activeId: undefined,
+  route: 'main',
+  relay: null,
+  fastMode: false,
+  lastUpdated: 0,
+}
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return v !== null && typeof v === 'object' && !Array.isArray(v)
+}
+
+function normalizeQuotaWindow(value: unknown): QuotaWindow | undefined {
+  if (!isRecord(value)) return undefined
+  const usedPercent = Number(value.usedPercent)
+  const remainingPercent = Number(value.remainingPercent)
+  if (!Number.isFinite(usedPercent) || !Number.isFinite(remainingPercent)) {
+    return undefined
+  }
+  return {
+    usedPercent,
+    remainingPercent,
+    resetsAt: typeof value.resetsAt === 'string' ? value.resetsAt : undefined,
+  }
+}
+
+function normalizeAccountQuota(value: unknown): AccountQuota | null {
+  if (!isRecord(value)) return null
+  const quota: AccountQuota = {}
+  const fiveHour = normalizeQuotaWindow(value.five_hour)
+  const sevenDay = normalizeQuotaWindow(value.seven_day)
+  if (fiveHour) quota.five_hour = fiveHour
+  if (sevenDay) quota.seven_day = sevenDay
+
+  if (Array.isArray(value.scoped)) {
+    const scoped = value.scoped
+      .map((entry): ScopedQuotaWindow | undefined => {
+        if (!isRecord(entry)) return undefined
+        const window = normalizeQuotaWindow(entry)
+        if (!window) return undefined
+        if (typeof entry.id !== 'string' || !entry.id.trim()) return undefined
+        if (typeof entry.title !== 'string' || !entry.title.trim()) {
+          return undefined
+        }
+        if (typeof entry.modelName !== 'string' || !entry.modelName.trim()) {
+          return undefined
+        }
+        const modelId =
+          typeof entry.modelId === 'string' && entry.modelId.trim()
+            ? entry.modelId.trim()
+            : undefined
+        return {
+          ...window,
+          id: entry.id.trim(),
+          title: entry.title.trim(),
+          ...(modelId && { modelId }),
+          modelName: entry.modelName.trim(),
+        }
+      })
+      .filter((entry): entry is ScopedQuotaWindow => entry != null)
+    // Preserve empty `[]` so a sidebar reader can distinguish "scoped owned
+    // by anthropic-auth, none visible" from "no quota data at all". The OUTER
+    // Array.isArray guard means pre-feature inputs without a `scoped` key are
+    // not affected — only inputs that already carried an array reach this line.
+    quota.scoped = scoped
+  }
+
+  return Object.keys(quota).length ? quota : null
+}
+
+export function normalizeSidebarState(raw: unknown): SidebarState {
+  if (!isRecord(raw)) return { ...DEFAULT_SIDEBAR_STATE }
+
+  const main: SidebarState['main'] = { quota: null }
+  if (isRecord(raw.main)) {
+    const m = raw.main
+    main.quota = normalizeAccountQuota(m.quota)
+    if (typeof m.quotaBackedOff === 'boolean')
+      main.quotaBackedOff = m.quotaBackedOff
+    if (typeof m.quotaBackoffUntil === 'number')
+      main.quotaBackoffUntil = m.quotaBackoffUntil
+    if (typeof m.refreshBackedOff === 'boolean')
+      main.refreshBackedOff = m.refreshBackedOff
+    if (typeof m.refreshBackoffUntil === 'number')
+      main.refreshBackoffUntil = m.refreshBackoffUntil
+  }
+
+  const fallbacks: SidebarAccountState[] = Array.isArray(raw.fallbacks)
+    ? raw.fallbacks
+        .filter(isRecord)
+        .filter((entry) => typeof entry.id === 'string')
+        .map((entry) => ({
+          id: entry.id as string,
+          label: typeof entry.label === 'string' ? entry.label : undefined,
+          quota: normalizeAccountQuota(entry.quota),
+          enabled: typeof entry.enabled === 'boolean' ? entry.enabled : false,
+          needsReauth:
+            typeof entry.needsReauth === 'boolean' ? entry.needsReauth : false,
+        }))
+    : []
+
+  let relay: SidebarState['relay'] = null
+  if (isRecord(raw.relay)) {
+    const r = raw.relay
+    if (typeof r.enabled === 'boolean' && typeof r.transport === 'string') {
+      relay = { enabled: r.enabled, transport: r.transport }
+    }
+  }
+
+  let cacheKeep: SidebarState['cacheKeep']
+  if (isRecord(raw.cacheKeep)) {
+    const ck = raw.cacheKeep
+    if (typeof ck.enabled === 'boolean') {
+      cacheKeep = {
+        enabled: ck.enabled,
+        window: typeof ck.window === 'string' ? ck.window : undefined,
+        trackedSessions:
+          typeof ck.trackedSessions === 'number'
+            ? ck.trackedSessions
+            : undefined,
+      }
+    }
+  }
+
+  const fableRecoveries: FableRecoverySidebarState[] = Array.isArray(
+    raw.fableRecoveries,
+  )
+    ? raw.fableRecoveries
+        .filter(isRecord)
+        .flatMap((recovery): FableRecoverySidebarState[] => {
+          if (
+            typeof recovery.sessionId !== 'string' ||
+            (recovery.mode !== 'opus' && recovery.mode !== 'fable') ||
+            typeof recovery.remaining !== 'number' ||
+            !Number.isFinite(recovery.remaining) ||
+            typeof recovery.changedAt !== 'number' ||
+            !Number.isFinite(recovery.changedAt)
+          )
+            return []
+          return [
+            {
+              sessionId: recovery.sessionId,
+              mode: recovery.mode,
+              remaining: Math.max(0, Math.floor(recovery.remaining)),
+              changedAt: recovery.changedAt,
+            },
+          ]
+        })
+    : []
+
+  return {
+    main,
+    fallbacks,
+    activeId: typeof raw.activeId === 'string' ? raw.activeId : undefined,
+    route:
+      typeof raw.route === 'string' ? raw.route : DEFAULT_SIDEBAR_STATE.route,
+    relay,
+    fastMode:
+      typeof raw.fastMode === 'boolean'
+        ? raw.fastMode
+        : DEFAULT_SIDEBAR_STATE.fastMode,
+    cacheKeep,
+    fableRecoveries: fableRecoveries.length > 0 ? fableRecoveries : undefined,
+    lastUpdated: typeof raw.lastUpdated === 'number' ? raw.lastUpdated : 0,
+  }
+}
+
+let writeChain: Promise<void> = Promise.resolve()
+
+export async function getSidebarState(): Promise<SidebarState> {
+  try {
+    const raw = await readFile(getSidebarStateFile(), 'utf8')
+    return normalizeSidebarState(JSON.parse(raw))
+  } catch {
+    return DEFAULT_SIDEBAR_STATE
+  }
+}
+
+export async function setSidebarState(
+  state: SidebarState,
+  stateFile = getSidebarStateFile(),
+): Promise<void> {
+  writeChain = writeChain
+    .then(async () => {
+      await mkdir(dirname(stateFile), { recursive: true })
+      await writeFile(stateFile, JSON.stringify(state), 'utf8')
+    })
+    .catch(() => {
+      // Best-effort — sidebar is non-critical
+    })
+
+  return writeChain
+}
+
+export async function drainSidebarWrites(): Promise<void> {
+  return writeChain
+}
+
+// Resolve the currently-active account from activeId for the collapsed sidebar
+// view. activeId === 'main' (or undefined/unmatched/disabled) → the main
+// account; otherwise the enabled fallback whose id matches.
+export function resolveActiveAccount(state: SidebarState): {
+  id: string
+  name: string
+  quota: AccountQuota | null
+} {
+  const activeId = state.activeId
+  if (activeId && activeId !== 'main') {
+    // `account.enabled` is defensive: writeSidebarState already filters disabled
+    // accounts out of state.fallbacks, so in normal operation every entry is
+    // enabled. Kept so this pure helper stays correct for any caller and is
+    // exercised directly by the unit tests.
+    const fallback = state.fallbacks?.find(
+      (account) => account.enabled && account.id === activeId,
+    )
+    if (fallback) {
+      return {
+        id: fallback.id,
+        name: fallback.label ?? fallback.id,
+        quota: fallback.quota,
+      }
+    }
+  }
+  return { id: 'main', name: 'main', quota: state.main?.quota ?? null }
+}
+
+export function formatScopedQuotaLabel(title: string) {
+  const label = title.replace(/\s+only$/i, '').trim()
+  return /^fable$/i.test(label) ? 'Fa' : label
+}
+
+export function getFableRecoverySummary(
+  state: SidebarState,
+  sessionId: string,
+): string | undefined {
+  const recovery = state.fableRecoveries?.find(
+    (candidate) => candidate.sessionId === sessionId,
+  )
+  if (!recovery) return undefined
+  if (recovery.mode === 'fable') return 'Fable 5 · restored'
+  return `Opus 4.8 · ${recovery.remaining} left`
+}
+
+export function getCollapsedQuotaSummary(quota: AccountQuota | null): {
+  fiveHourUsedPercent: number | null
+  sevenDayUsedPercent: number | null
+  scopedUsedPercents: number[]
+  text: string | null
+} {
+  const fiveHourUsedPercent = quota?.five_hour?.usedPercent ?? null
+  const sevenDayUsedPercent = quota?.seven_day?.usedPercent ?? null
+  const scoped = quota?.scoped ?? []
+  const scopedUsedPercents = scoped.map((window) => window.usedPercent)
+  if (
+    fiveHourUsedPercent == null &&
+    sevenDayUsedPercent == null &&
+    scoped.length === 0
+  ) {
+    return {
+      fiveHourUsedPercent,
+      sevenDayUsedPercent,
+      scopedUsedPercents,
+      text: null,
+    }
+  }
+
+  const scopedSegments = scoped.map(
+    (window) =>
+      `${formatScopedQuotaLabel(window.title)}: ${Math.round(window.usedPercent)}%`,
+  )
+  const primarySegments =
+    fiveHourUsedPercent == null && sevenDayUsedPercent == null
+      ? []
+      : [
+          `5h: ${fiveHourUsedPercent == null ? '—' : `${Math.round(fiveHourUsedPercent)}%`}`,
+          `7d: ${sevenDayUsedPercent == null ? '—' : `${Math.round(sevenDayUsedPercent)}%`}`,
+        ]
+
+  return {
+    fiveHourUsedPercent,
+    sevenDayUsedPercent,
+    scopedUsedPercents,
+    text: [...primarySegments, ...scopedSegments].join(' '),
+  }
+}
+
+export const FIVE_HOUR_MS = 5 * 60 * 60 * 1000
+export const SEVEN_DAY_MS = 7 * 24 * 60 * 60 * 1000
+
+const PACING_MIN_ELAPSED_MS = 5 * 60 * 1000
+const PACING_MIN_ELAPSED_FRACTION = 0.01
+const ON_PACE_DELTA = 1
+
+export interface QuotaPacing {
+  pacePercent: number
+  deltaPercent: number
+  state: 'deficit' | 'reserve' | 'on-pace'
+  runsOutAt: string | null
+}
+
+// Even-burn pacing for a quota window. The window start is inferred from the
+// reset timestamp minus the window length. Two metrics: deltaPercent compares
+// usage against a uniform burn-down (positive = deficit), and runsOutAt
+// projects the current average burn rate forward — null means the window
+// lasts until reset at that rate. Returns null when there is no reset
+// timestamp or the elapsed time is too small to give a meaningful rate.
+export function computeQuotaPacing(
+  window: QuotaWindow,
+  windowMs: number,
+  now: number,
+): QuotaPacing | null {
+  if (!window.resetsAt) return null
+  const resetsAt = new Date(window.resetsAt).getTime()
+  if (!Number.isFinite(resetsAt)) return null
+  const start = resetsAt - windowMs
+  const elapsed = now - start
+  if (elapsed < PACING_MIN_ELAPSED_MS) return null
+  if (elapsed < windowMs * PACING_MIN_ELAPSED_FRACTION) return null
+  if (elapsed >= windowMs) return null
+
+  const used = window.usedPercent
+  const pacePercent = Math.min(Math.max((elapsed / windowMs) * 100, 0), 100)
+  const deltaPercent = used - pacePercent
+  const state =
+    Math.abs(deltaPercent) < ON_PACE_DELTA
+      ? 'on-pace'
+      : deltaPercent > 0
+        ? 'deficit'
+        : 'reserve'
+
+  let runsOutAt: string | null = null
+  if (used > 0) {
+    const msToFull = (elapsed * 100) / used
+    const runOut = start + msToFull
+    if (runOut < resetsAt) runsOutAt = new Date(runOut).toISOString()
+  }
+
+  return { pacePercent, deltaPercent, state, runsOutAt }
+}