@cortexkit/opencode-openai-auth 0.3.4 → 0.4.1

package/src/sidebar-state.ts

@@ -2,11 +2,79 @@ export interface QuotaWindow {
   usedPercent: number
   remainingPercent: number
   resetsAt?: string
+  windowMinutes?: number
 }
 
 export interface AccountQuota {
   primary?: QuotaWindow
   secondary?: QuotaWindow
+  resetCreditsAvailable?: number
+}
+
+export type QuotaWindowKey = 'primary' | 'secondary'
+
+const QUOTA_WINDOW_KEYS: readonly QuotaWindowKey[] = ['primary', 'secondary']
+const LEGACY_WINDOW_MINUTES: Record<QuotaWindowKey, number> = {
+  primary: 300,
+  secondary: 10_080,
+}
+
+function compactUnit(value: number): string {
+  return Number.isInteger(value)
+    ? String(value)
+    : String(Math.round(value * 10) / 10)
+}
+
+// Derives a short human label ("5h", "1d", "7d") from a window length in
+// minutes. Snapshots written before dynamic windows carry no length, so retain
+// their historical primary=5h and secondary=7d meanings.
+export function formatWindowLabel(
+  windowMinutes: number | undefined,
+  fallbackKey: QuotaWindowKey,
+): string {
+  const minutes =
+    windowMinutes !== undefined &&
+    Number.isFinite(windowMinutes) &&
+    windowMinutes > 0
+      ? windowMinutes
+      : LEGACY_WINDOW_MINUTES[fallbackKey]
+  if (minutes < 60) return `${compactUnit(minutes)}m`
+  if (minutes < 1_440) return `${compactUnit(minutes / 60)}h`
+  return `${compactUnit(minutes / 1_440)}d`
+}
+
+export interface PresentQuotaWindow {
+  key: QuotaWindowKey
+  label: string
+  window: QuotaWindow
+  windowMs: number | null
+}
+
+// Present windows only — an absent slot means "not applicable", not
+// "unknown", so it must never synthesize a placeholder row here.
+export function getPresentQuotaWindows(
+  quota: AccountQuota | null,
+): PresentQuotaWindow[] {
+  if (!quota) return []
+  const rows: PresentQuotaWindow[] = []
+  for (const key of QUOTA_WINDOW_KEYS) {
+    const window = quota[key]
+    if (!window) continue
+    const configuredMinutes = window.windowMinutes
+    const windowMinutes =
+      configuredMinutes !== undefined &&
+      Number.isFinite(configuredMinutes) &&
+      configuredMinutes > 0
+        ? configuredMinutes
+        : LEGACY_WINDOW_MINUTES[key]
+    rows.push({
+      key,
+      label: formatWindowLabel(windowMinutes, key),
+      window,
+      windowMs: windowMinutes * 60_000,
+    })
+  }
+  return rows
 }
 
 export interface SidebarAccountState {
@@ -15,8 +83,17 @@ export interface SidebarAccountState {
   quota: AccountQuota | null
   killed: boolean
   enabled: boolean
+  resetCredits?: number
 }
 
+export interface ActiveRoutingEntry {
+  activeId: string
+  route: string
+  updatedAt: number
+}
+
+export type ActiveRoutingMap = Record<string, ActiveRoutingEntry>
+
 export interface SidebarState {
   main: {
     quota: AccountQuota | null
@@ -25,10 +102,14 @@ export interface SidebarState {
     quotaBackoffUntil?: number
     refreshBackedOff?: boolean
     refreshBackoffUntil?: number
+    resetCredits?: number
   }
   fallbacks: SidebarAccountState[]
+  /** @deprecated Compatibility field for readers that do not consume activeRouting. */
   activeId: string | undefined
+  /** Machine-global routing mode and compatibility value for older readers. */
   route: string
+  activeRouting?: ActiveRoutingMap
   planType?: string
   credits?: number
   lastUpdated: number
@@ -38,6 +119,7 @@ import { randomUUID } from 'node:crypto'
 import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
+import { acquireRefreshFileLock } from './core/refresh-file-lock'
 import { createLogger } from './logger'
 
 const logSb = createLogger('sidebar')
@@ -46,6 +128,50 @@ const STATE_FILE_ENV = 'OPENCODE_OPENAI_AUTH_SIDEBAR_STATE_FILE'
 const DEFAULT_STATE_DIR = join(tmpdir(), 'opencode-openai-auth')
 const DEFAULT_STATE_FILE = join(DEFAULT_STATE_DIR, 'sidebar-state.json')
 
+function normalizeResetCredits(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0
+    ? value
+    : undefined
+}
+
+function resetCreditsField(value: unknown): { resetCredits?: number } {
+  const credits = normalizeResetCredits(value)
+  return credits !== undefined ? { resetCredits: credits } : {}
+}
+
+function normalizeActiveRouting(value: unknown): ActiveRoutingMap | undefined {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined
+  }
+
+  const normalized: ActiveRoutingMap = {}
+  for (const [sessionId, rawEntry] of Object.entries(value)) {
+    if (
+      rawEntry === null ||
+      typeof rawEntry !== 'object' ||
+      Array.isArray(rawEntry)
+    ) {
+      continue
+    }
+    const entry = rawEntry as Record<string, unknown>
+    if (
+      typeof entry.activeId !== 'string' ||
+      typeof entry.route !== 'string' ||
+      typeof entry.updatedAt !== 'number' ||
+      !Number.isFinite(entry.updatedAt)
+    ) {
+      continue
+    }
+    normalized[sessionId] = {
+      activeId: entry.activeId,
+      route: entry.route,
+      updatedAt: entry.updatedAt,
+    }
+  }
+
+  return Object.keys(normalized).length > 0 ? normalized : undefined
+}
+
 export function getSidebarStateFile(): string {
   return process.env[STATE_FILE_ENV] || DEFAULT_STATE_FILE
 }
@@ -99,6 +225,7 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
       ...(typeof m.refreshBackoffUntil === 'number'
         ? { refreshBackoffUntil: m.refreshBackoffUntil }
         : {}),
+      ...resetCreditsField(m.resetCredits),
     }
   } else {
     main = { quota: null, killed: false }
@@ -123,6 +250,7 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
           quota: ('quota' in e ? e.quota : null) as AccountQuota | null,
           killed: typeof e.killed === 'boolean' ? e.killed : false,
           enabled: typeof e.enabled === 'boolean' ? e.enabled : true,
+          ...resetCreditsField(e.resetCredits),
         }))
     : []
 
@@ -139,13 +267,14 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
   // Optional top-level fields
   const planType = typeof r.planType === 'string' ? r.planType : undefined
   const credits = typeof r.credits === 'number' ? r.credits : undefined
-
+  const activeRouting = normalizeActiveRouting(r.activeRouting)
   return {
     main,
     fallbacks,
     activeId,
     route,
     lastUpdated,
+    ...(activeRouting !== undefined ? { activeRouting } : {}),
     ...(planType !== undefined ? { planType } : {}),
     ...(credits !== undefined ? { credits } : {}),
   }
@@ -160,9 +289,90 @@ export async function getSidebarState(): Promise<SidebarState> {
   }
 }
 
+export const ACTIVE_ROUTING_MAX_AGE_MS = 60 * 60 * 1000
+export const ACTIVE_ROUTING_MAX_ENTRIES = 128
+
+export type SidebarRoutingAccount = {
+  id: string
+  enabled?: boolean
+}
+
+export function isUsableRoutingEntry(
+  entry: ActiveRoutingEntry,
+  accounts: readonly SidebarRoutingAccount[],
+  now = Date.now(),
+): boolean {
+  const fresh =
+    entry.updatedAt >= now - ACTIVE_ROUTING_MAX_AGE_MS && entry.updatedAt <= now
+  if (!fresh) return false
+  return (
+    entry.activeId === 'main' ||
+    accounts.some(
+      (account) => account.enabled !== false && account.id === entry.activeId,
+    )
+  )
+}
+
+export function resolveSessionSidebarRouting(
+  state: SidebarState,
+  sessionId?: string,
+  now = Date.now(),
+): { activeId: string; route: string } {
+  if (!sessionId) {
+    return { activeId: state.activeId ?? 'main', route: state.route }
+  }
+  const own = sessionId ? state.activeRouting?.[sessionId] : undefined
+  if (own && isUsableRoutingEntry(own, state.fallbacks, now)) {
+    return { activeId: own.activeId, route: own.route }
+  }
+
+  const fallback = state.fallbacks.find(
+    (account) => account.enabled && !account.killed,
+  )
+  return {
+    activeId:
+      state.route === 'fallback-first' && fallback ? fallback.id : 'main',
+    route: state.route,
+  }
+}
+
+export function pruneActiveRouting(
+  activeRouting: ActiveRoutingMap | undefined,
+  accounts: readonly SidebarRoutingAccount[],
+  now = Date.now(),
+  removedSessionId?: string,
+): ActiveRoutingMap | undefined {
+  if (!activeRouting) return undefined
+  const kept = Object.entries(activeRouting).filter(
+    ([sessionId, entry]) =>
+      sessionId !== removedSessionId &&
+      isUsableRoutingEntry(entry, accounts, now),
+  )
+  const bounded =
+    kept.length <= ACTIVE_ROUTING_MAX_ENTRIES
+      ? kept
+      : kept
+          .sort((left, right) => right[1].updatedAt - left[1].updatedAt)
+          .slice(0, ACTIVE_ROUTING_MAX_ENTRIES)
+  return bounded.length > 0 ? Object.fromEntries(bounded) : undefined
+}
+
 // Serialization chain: concurrent calls are queued so a stale background
 // write cannot land after a newer one and corrupt the file.
 let sidebarWriteChain: Promise<void> = Promise.resolve()
+const MAX_MERGE_ATTEMPTS = 3
+const SIDEBAR_WRITE_LOCK_TTL_MS = 10_000
+const SIDEBAR_WRITE_LOCK_WAIT_MS = 15_000
+
+interface SidebarMergeHooks {
+  beforeRecheck?: () => void | Promise<void>
+}
+
+function enqueueSidebarWrite(operation: () => Promise<void>): Promise<void> {
+  const result = sidebarWriteChain.then(operation)
+  sidebarWriteChain = result.catch(() => {})
+  return result
+}
 
 /**
  * Write sidebar state to disk, serialized through a promise chain so
@@ -179,10 +389,177 @@ export function setSidebarState(
   state: SidebarState,
   file = getSidebarStateFile(),
 ): Promise<void> {
-  sidebarWriteChain = sidebarWriteChain
-    .then(() => doWriteSidebarState(state, file))
-    .catch(() => {})
-  return sidebarWriteChain
+  return enqueueSidebarWrite(() => doWriteSidebarState(state, file))
+}
+
+async function readSidebarState(file: string): Promise<SidebarState> {
+  try {
+    return parseSidebarState(await readRawSidebar(file))
+  } catch {
+    return DEFAULT_SIDEBAR_STATE
+  }
+}
+
+async function readRawSidebar(file: string): Promise<string> {
+  try {
+    return await readFile(file, 'utf8')
+  } catch (error) {
+    if ((error as { code?: string }).code === 'ENOENT') return ''
+    throw error
+  }
+}
+
+function parseSidebarState(raw: string): SidebarState {
+  if (raw === '') return DEFAULT_SIDEBAR_STATE
+  try {
+    return normalizeSidebarState(JSON.parse(raw))
+  } catch {
+    return DEFAULT_SIDEBAR_STATE
+  }
+}
+
+async function acquireSidebarWriteLock(file: string) {
+  await mkdir(dirname(file), { recursive: true })
+  const deadline = Date.now() + SIDEBAR_WRITE_LOCK_WAIT_MS
+  while (Date.now() <= deadline) {
+    const lock = await acquireRefreshFileLock({
+      name: 'sidebar-write',
+      path: file,
+      ttlMs: SIDEBAR_WRITE_LOCK_TTL_MS,
+      renew: true,
+    })
+    if (lock) return lock
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  throw new Error('Timed out waiting for the sidebar state write lock')
+}
+
+async function writeMergedSidebarState(
+  file: string,
+  merge: (latest: SidebarState) => SidebarState,
+  hooks?: SidebarMergeHooks,
+): Promise<void> {
+  const lock = await acquireSidebarWriteLock(file)
+  try {
+    // The file lock serializes current writers. Rechecking also preserves data
+    // from older plugin processes that do not participate in this lock.
+    for (let attempt = 0; attempt < MAX_MERGE_ATTEMPTS; attempt += 1) {
+      const rawBefore = await readRawSidebar(file)
+      const next = merge(parseSidebarState(rawBefore))
+      if (attempt === 0) await hooks?.beforeRecheck?.()
+      const rawRecheck = await readRawSidebar(file)
+      if (rawRecheck !== rawBefore) continue
+      await doWriteSidebarState(next, file)
+      return
+    }
+
+    const latest = await readSidebarState(file)
+    await doWriteSidebarState(merge(latest), file)
+  } finally {
+    await lock.release()
+  }
+}
+
+export type SidebarMachineState = Pick<
+  SidebarState,
+  'main' | 'fallbacks' | 'planType' | 'credits' | 'lastUpdated'
+> & { route: string }
+
+export function setSidebarMachineState(
+  machineState: SidebarMachineState,
+  file = getSidebarStateFile(),
+  hooks?: SidebarMergeHooks,
+): Promise<void> {
+  return enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(
+      file,
+      (latest) => ({
+        ...latest,
+        ...machineState,
+        activeId: latest.activeId,
+        activeRouting: latest.activeRouting,
+        lastUpdated: Math.max(Date.now(), latest.lastUpdated + 1),
+      }),
+      hooks,
+    )
+  })
+}
+
+export function upsertSidebarActiveRouting(
+  input: { sessionId: string } & ActiveRoutingEntry,
+  accounts: readonly SidebarRoutingAccount[],
+  file = getSidebarStateFile(),
+  hooks?: SidebarMergeHooks,
+): Promise<void> {
+  return enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(
+      file,
+      (latest) => {
+        const activeRouting = pruneActiveRouting(
+          {
+            ...latest.activeRouting,
+            [input.sessionId]: {
+              activeId: input.activeId,
+              route: input.route,
+              updatedAt: input.updatedAt,
+            },
+          },
+          accounts,
+          Date.now(),
+        )
+        return {
+          ...latest,
+          activeId: input.activeId,
+          route: input.route,
+          activeRouting,
+          lastUpdated: Math.max(Date.now(), latest.lastUpdated + 1),
+        }
+      },
+      hooks,
+    )
+  })
+}
+
+export function setSidebarLegacyRouting(
+  input: ActiveRoutingEntry,
+  file = getSidebarStateFile(),
+): Promise<void> {
+  return enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(file, (latest) => ({
+      ...latest,
+      activeId: input.activeId,
+      route: input.route,
+      lastUpdated: Math.max(Date.now(), latest.lastUpdated + 1),
+    }))
+  })
+}
+
+export function removeSidebarActiveRouting(
+  sessionId: string,
+  accounts: readonly SidebarRoutingAccount[],
+  file = getSidebarStateFile(),
+  hooks?: SidebarMergeHooks,
+): Promise<void> {
+  return enqueueSidebarWrite(async () => {
+    await writeMergedSidebarState(
+      file,
+      (latest) => {
+        const now = Date.now()
+        const activeRouting = pruneActiveRouting(
+          latest.activeRouting,
+          accounts,
+          now,
+          sessionId,
+        )
+        return {
+          ...latest,
+          activeRouting,
+          lastUpdated: Math.max(Date.now(), latest.lastUpdated + 1),
+        }
+      },
+      hooks,
+    )
+  })
 }
 
 async function doWriteSidebarState(
@@ -200,6 +577,7 @@ async function doWriteSidebarState(
       pid: process.pid,
       error: e instanceof Error ? e.message : String(e),
     })
+    throw e
   }
 }
 
@@ -250,20 +628,22 @@ export function getCollapsedQuotaSummary(quota: AccountQuota | null): {
 } {
   const primaryUsedPercent = quota?.primary?.usedPercent ?? null
   const secondaryUsedPercent = quota?.secondary?.usedPercent ?? null
-  if (primaryUsedPercent == null && secondaryUsedPercent == null) {
-    return { primaryUsedPercent, secondaryUsedPercent, text: null }
-  }
-
+  const rows = getPresentQuotaWindows(quota)
   return {
     primaryUsedPercent,
     secondaryUsedPercent,
-    text: `5h: ${primaryUsedPercent == null ? '\u2014' : `${Math.round(primaryUsedPercent)}%`} 7d: ${secondaryUsedPercent == null ? '\u2014' : `${Math.round(secondaryUsedPercent)}%`}`,
+    text:
+      rows.length === 0
+        ? null
+        : rows
+            .map(
+              ({ label, window }) =>
+                `${label}: ${Math.round(window.usedPercent)}%`,
+            )
+            .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

package/src/tui/command-dialogs.tsx

@@ -1,7 +1,13 @@
 /** @jsxImportSource @opentui/solid */
 import type { TuiPluginApi } from '@opencode-ai/plugin/tui'
 import type { OpenDialogPayload } from '../rpc/protocol.js'
-import { getSidebarState } from '../sidebar-state.js'
+import {
+  type AccountQuota,
+  getCollapsedQuotaSummary,
+  getSidebarState,
+  resolveSessionSidebarRouting,
+  type SidebarState,
+} from '../sidebar-state.js'
 import { openUrl } from '../util/open-url'
 
 type ApplyFn = (
@@ -139,6 +145,7 @@ export function openCommandDialog(
   api: TuiPluginApi,
   payload: OpenDialogPayload,
   apply: ApplyFn,
+  sessionId?: string,
 ) {
   if (payload.command === 'openai-routing') {
     const current = (payload.knobs.mode as string) ?? 'main-first'
@@ -248,7 +255,7 @@ export function openCommandDialog(
           {
             title: 'Edit thresholds\u2026',
             value: 'edit',
-            description: 'Set per-account 5h,1w cutoffs',
+            description: 'Set per-account primary,secondary cutoffs',
           },
         ]}
         onSelect={(option) => {
@@ -345,7 +352,7 @@ export function openCommandDialog(
   }
 
   if (payload.command === 'openai-account') {
-    openAccountDialog(api, apply)
+    openAccountDialog(api, apply, sessionId)
     return
   }
 
@@ -355,18 +362,15 @@ export function openCommandDialog(
 
 // -- Accounts dialog ---------------------------------------------------------
 
-function formatQuota5h7d(
-  quota:
-    | { primary?: { usedPercent: number }; secondary?: { usedPercent: number } }
-    | null
-    | undefined,
+export function formatQuotaWindows(
+  quota: AccountQuota | null | undefined,
 ): string {
-  if (!quota) return 'no quota data'
-  const parts: string[] = []
-  if (quota.primary) parts.push(`5h: ${Math.round(quota.primary.usedPercent)}%`)
-  if (quota.secondary)
-    parts.push(`7d: ${Math.round(quota.secondary.usedPercent)}%`)
-  return parts.length > 0 ? parts.join(' ') : 'no quota data'
+  const windowSummary = getCollapsedQuotaSummary(quota ?? null).text
+  if (windowSummary) return windowSummary
+  if (quota?.resetCreditsAvailable !== undefined) {
+    return `resets: ${quota.resetCreditsAvailable}`
+  }
+  return 'no quota data'
 }
 
 function osc52Copy(api: TuiPluginApi, text: string): boolean {
@@ -386,7 +390,30 @@ function osc52Copy(api: TuiPluginApi, text: string): boolean {
   return false
 }
 
-function openAccountDialog(api: TuiPluginApi, apply: ApplyFn) {
+export function buildAccountDialogRows(
+  state: SidebarState,
+  sessionId?: string,
+) {
+  const activeId = resolveSessionSidebarRouting(state, sessionId).activeId
+  return [
+    {
+      title: `main${activeId === 'main' ? ' \u2022 active' : ''}`,
+      value: 'main',
+      description: formatQuotaWindows(state.main.quota),
+    },
+    ...state.fallbacks.map((fb) => ({
+      title: `${fb.label ?? fb.id}${activeId === fb.id ? ' \u2022 active' : ''}${!fb.enabled ? ' (disabled)' : ''}`,
+      value: fb.id,
+      description: formatQuotaWindows(fb.quota),
+    })),
+  ]
+}
+
+function openAccountDialog(
+  api: TuiPluginApi,
+  apply: ApplyFn,
+  sessionId?: string,
+) {
   const DialogConfirm = api.ui.DialogConfirm
 
   function showL1() {
@@ -397,16 +424,7 @@ function openAccountDialog(api: TuiPluginApi, apply: ApplyFn) {
         <DialogSelectInner
           title='OpenAI Accounts'
           options={[
-            {
-              title: `main${state.activeId === 'main' || !state.activeId ? ' \u2022 active' : ''}`,
-              value: 'main',
-              description: formatQuota5h7d(state.main.quota),
-            },
-            ...state.fallbacks.map((fb) => ({
-              title: `${fb.label ?? fb.id}${state.activeId === fb.id ? ' \u2022 active' : ''}${!fb.enabled ? ' (disabled)' : ''}`,
-              value: fb.id,
-              description: formatQuota5h7d(fb.quota),
-            })),
+            ...buildAccountDialogRows(state, sessionId),
             {
               title: 'Add account\u2026',
               value: '__add__',