@cortexkit/opencode-openai-auth 0.7.2 → 0.9.0

package/src/{tui.tsx → tui-compiled/raw/tui.tsx}

@@ -16,10 +16,10 @@ import {
   onCleanup,
   Show,
 } from 'solid-js'
-import { createLogger } from './logger.js'
-import type { ApplyRequest, CommandModalName } from './rpc/protocol.js'
-import { createRpcClient } from './rpc/rpc-client.js'
-import { resolveRpcDir } from './rpc/rpc-dir.js'
+import { createLogger } from './logger.ts'
+import type { ApplyRequest, CommandModalName } from './rpc-protocol.ts'
+import { createRpcClient } from './rpc-rpc-client.ts'
+import { resolveRpcDir } from './rpc-rpc-dir.ts'
 import {
   type AccountQuota,
   computeQuotaPacing,
@@ -33,8 +33,9 @@ import {
   resolveSessionSidebarRouting,
   resolveSessionStickyAccount,
   type SidebarState,
-} from './sidebar-state.js'
-import { openCommandDialog } from './tui/command-dialogs.js'
+  type SpendControlReading,
+} from './sidebar-state.ts'
+import { openCommandDialog } from './tui-command-dialogs.tsx'
 import {
   type AppearancePrefs,
   computeEffectiveOrder,
@@ -45,7 +46,7 @@ import {
   readTuiPreferencesFile,
   resolveOpenaiAuthPrefs,
   watchTuiPreferences,
-} from './tui-preferences.js'
+} from './tui-preferences.ts'
 
 const RPC_POLL_MS = 500
 let rpcPollStarted = false
@@ -61,14 +62,15 @@ export function buildApplyRequest(
   return { command, arguments: arguments_, sessionId }
 }
 
-// Read package metadata from either the raw src/ entry or its generated
-// src/tui-compiled/ counterpart. Avoid a JSON import because package.json sits
-// outside the declaration build's rootDir.
+// Read package metadata from the development source or either generated TUI
+// variant. Avoid a JSON import because package.json sits outside the declaration
+// build's rootDir.
 const PLUGIN_VERSION: string = (() => {
   const here = dirname(fileURLToPath(import.meta.url))
   for (const packageFile of [
     join(here, '..', 'package.json'),
     join(here, '..', '..', 'package.json'),
+    join(here, '..', '..', '..', 'package.json'),
   ]) {
     try {
       const raw = readFileSync(packageFile, 'utf8')
@@ -240,28 +242,97 @@ function CollapsedRow(props: {
 }
 
 export interface QuotaDisplayRow {
-  key: 'primary' | 'secondary'
+  key: 'primary' | 'secondary' | 'spendControl'
   label: string
+  labelWidth: number
   window: QuotaWindow
   pacing: QuotaPacing | null
 }
 
+const SPEND_CONTROL_LABEL = 'credits'
+
+// Labels a quota snapshot contributes to the sidebar, independent of pacing or
+// the wall clock — the label column is sized from these alone.
+function quotaRowLabels(quota: AccountQuota | null): string[] {
+  const labels = getPresentQuotaWindows(quota).map((row) => row.label)
+  if (quota?.spendControl) labels.push(SPEND_CONTROL_LABEL)
+  return labels
+}
+
+// The label column is a property of the whole sidebar, not of one account's row
+// set: every account's bars must start at the same column, so the width is
+// derived once from every account rendered (main plus fallbacks) and threaded
+// into each account's rows. The +1 keeps a separator before the longest label's
+// bar; 3 is the floor the short 5h/7d labels already relied on.
+/**
+ * Every quota the sidebar will draw, in one list.
+ *
+ * The label column is shared by all of them, so the width has to be measured
+ * over this exact set — measuring a subset is what made stacked accounts
+ * disagree about where the bar starts. Named rather than inlined at each call
+ * site because the set is the part that can be got wrong, and a call site
+ * cannot be tested without the host's rendering runtime.
+ */
+export function renderedQuotas(state: {
+  main?: { quota?: AccountQuota | null } | null
+  fallbacks?: ReadonlyArray<{ enabled?: boolean; quota?: AccountQuota | null }>
+}): ReadonlyArray<AccountQuota | null | undefined> {
+  return [
+    state.main?.quota ?? null,
+    ...(state.fallbacks ?? [])
+      .filter((fallback) => fallback.enabled)
+      .map((fallback) => fallback.quota),
+  ]
+}
+
+export function computeQuotaLabelWidth(
+  quotas: ReadonlyArray<AccountQuota | null | undefined>,
+): number {
+  let width = 3
+  for (const quota of quotas) {
+    for (const label of quotaRowLabels(quota ?? null)) {
+      width = Math.max(width, label.length + 1)
+    }
+  }
+  return width
+}
+
 // Maps present quota windows onto display rows and computes pacing against each
 // dynamic duration or the historical 5h/7d duration for legacy snapshots.
+// `labelWidth` comes from computeQuotaLabelWidth for rendered sidebars; callers
+// that only inspect pacing may omit it and get this row set's own width.
 export function buildQuotaRowsForDisplay(
   quota: AccountQuota | null,
   now: number,
   pacingEnabled: boolean,
+  labelWidth?: number,
 ): QuotaDisplayRow[] {
-  return getPresentQuotaWindows(quota).map((row) => ({
-    key: row.key,
-    label: row.label,
-    window: row.window,
-    pacing:
-      pacingEnabled && row.windowMs !== null
-        ? computeQuotaPacing(row.window, row.windowMs, now)
-        : null,
-  }))
+  const rows: Array<Omit<QuotaDisplayRow, 'labelWidth'>> =
+    getPresentQuotaWindows(quota).map((row) => ({
+      key: row.key,
+      label: row.label,
+      window: row.window,
+      pacing:
+        pacingEnabled && row.windowMs !== null
+          ? computeQuotaPacing(row.window, row.windowMs, now)
+          : null,
+    }))
+  const spendControl = quota?.spendControl
+  if (spendControl) {
+    rows.push({
+      key: 'spendControl',
+      label: SPEND_CONTROL_LABEL,
+      window: {
+        usedPercent: spendControl.usedPercent,
+        remainingPercent: spendControl.remainingPercent,
+        resetsAt: spendControl.resetsAt,
+      },
+      pacing: null,
+    })
+  }
+  const width =
+    labelWidth ?? Math.max(3, ...rows.map((row) => row.label.length + 1))
+  return rows.map((row) => ({ ...row, labelWidth: width }))
 }
 
 export function isQuotaLoaded(quota: AccountQuota | null): boolean {
@@ -279,12 +350,39 @@ export function getQuotaMetadataRows(
   return rows
 }
 
+function formatGroupedAmount(value: number): string {
+  return Math.round(value).toLocaleString('en-US')
+}
+
+// The unit names the budget the amounts are counted in, so it agrees with the
+// total rather than staying singular against a plural quantity.
+function pluralizeUnit(unit: string, count: number): string {
+  if (count === 1) return unit
+  return unit.endsWith('s') ? unit : `${unit}s`
+}
+
+export function formatSpendControlAmounts(
+  spendControl: SpendControlReading,
+): string {
+  const unit = pluralizeUnit(spendControl.unit ?? 'unit', spendControl.limit)
+  return `${formatGroupedAmount(spendControl.used)} / ${formatGroupedAmount(spendControl.limit)} ${unit}`
+}
+
 export function getAccountMetadataRows(
   resetCredits: number | undefined,
+  spendControl?: SpendControlReading,
 ): Array<{ label: string; value: string }> {
-  return resetCredits === undefined
-    ? []
-    : [{ label: 'resets', value: String(resetCredits) }]
+  const rows: Array<{ label: string; value: string }> = []
+  if (spendControl) {
+    rows.push({
+      label: 'credits',
+      value: formatSpendControlAmounts(spendControl),
+    })
+  }
+  if (resetCredits !== undefined) {
+    rows.push({ label: 'resets', value: String(resetCredits) })
+  }
+  return rows
 }
 
 // Quota window row: muted label left, tone-colored bar + percentage right,
@@ -295,6 +393,7 @@ function QuotaRow(props: {
   theme: ThemeCurrent
   appearance: AppearancePrefs
   label: string
+  labelWidth: number
   window: { usedPercent: number; resetsAt?: string } | undefined
   pacing: QuotaPacing | null
 }) {
@@ -314,7 +413,9 @@ function QuotaRow(props: {
       when={props.window}
       fallback={
         <box width='100%' flexDirection='row'>
-          <text fg={props.theme.textMuted}>{props.label.padEnd(3)}</text>
+          <text fg={props.theme.textMuted}>
+            {props.label.padEnd(props.labelWidth)}
+          </text>
           <text fg={props.theme.textMuted}>{'\u2014'}</text>
         </box>
       }
@@ -324,7 +425,9 @@ function QuotaRow(props: {
           the right edge so reset times align in their own right column. */}
       <box width='100%' flexDirection='row' justifyContent='space-between'>
         <box flexDirection='row'>
-          <text fg={props.theme.textMuted}>{props.label.padEnd(3)}</text>
+          <text fg={props.theme.textMuted}>
+            {props.label.padEnd(props.labelWidth)}
+          </text>
           <For each={quotaBarSegments(used(), props.appearance, props.pacing)}>
             {(segment) => (
               <text fg={toneColor(props.theme, segment.tone)}>
@@ -344,7 +447,7 @@ function QuotaRow(props: {
       </box>
       <Show when={paceLine()}>
         <box width='100%' flexDirection='row'>
-          <text fg={props.theme.textMuted}>{'   '}</text>
+          <text fg={props.theme.textMuted}>{''.padEnd(props.labelWidth)}</text>
           <text
             fg={toneColor(
               props.theme,
@@ -370,6 +473,7 @@ function AccountBlock(props: {
   killed: boolean
   active: boolean
   pacingEnabled: boolean
+  labelWidth: number
   resetCredits?: number
   marginTop?: number
 }) {
@@ -378,7 +482,12 @@ function AccountBlock(props: {
   const statusTone = (): Tone =>
     props.killed ? 'err' : props.active ? 'ok' : 'muted'
   const rows = () =>
-    buildQuotaRowsForDisplay(props.quota, Date.now(), props.pacingEnabled)
+    buildQuotaRowsForDisplay(
+      props.quota,
+      Date.now(),
+      props.pacingEnabled,
+      props.labelWidth,
+    )
   return (
     <box width='100%' flexDirection='column' marginTop={props.marginTop ?? 0}>
       <box width='100%' flexDirection='row' justifyContent='space-between'>
@@ -403,6 +512,7 @@ function AccountBlock(props: {
                 theme={props.theme}
                 appearance={props.appearance}
                 label={row.label}
+                labelWidth={row.labelWidth}
                 window={row.window}
                 pacing={row.pacing}
               />
@@ -410,7 +520,12 @@ function AccountBlock(props: {
           </For>
         </Show>
       </Show>
-      <For each={getAccountMetadataRows(props.resetCredits)}>
+      <For
+        each={getAccountMetadataRows(
+          props.resetCredits,
+          props.quota?.spendControl,
+        )}
+      >
         {(row) => (
           <StatRow
             theme={props.theme}
@@ -452,6 +567,7 @@ function QuotaDialogContent(props: {
   const enabledFallbacks = () =>
     (state().fallbacks ?? []).filter((f) => f.enabled)
   const activeId = () => resolveQuotaDialogActiveId(state(), props.sessionId)
+  const quotaLabelWidth = () => computeQuotaLabelWidth(renderedQuotas(state()))
   return (
     <box flexDirection='column' padding={2} width='100%' alignItems='center'>
       <box flexDirection='column' width={58}>
@@ -468,6 +584,7 @@ function QuotaDialogContent(props: {
           killed={state().main?.killed ?? false}
           active={activeId() === 'main'}
           pacingEnabled={prefs().sections.pacing}
+          labelWidth={quotaLabelWidth()}
           resetCredits={state().main?.resetCredits}
         />
         <Show when={prefs().sections.fallbackAccounts}>
@@ -481,6 +598,7 @@ function QuotaDialogContent(props: {
                 killed={fb.killed}
                 active={activeId() === fb.id}
                 pacingEnabled={prefs().sections.pacing}
+                labelWidth={quotaLabelWidth()}
                 resetCredits={fb.resetCredits}
                 marginTop={1}
               />
@@ -661,6 +779,7 @@ function QuotaSidebar(props: {
     route: sessionRouting().route,
   })
   const activeAccount = () => resolveActiveAccount(sessionState())
+  const quotaLabelWidth = () => computeQuotaLabelWidth(renderedQuotas(state()))
   const activeQuotaSummary = () =>
     getCollapsedQuotaSummary(activeAccount().quota)
   const activePacingDeficit = () => {
@@ -793,6 +912,7 @@ function QuotaSidebar(props: {
               killed={state().main?.killed ?? false}
               active={sessionRouting().activeId === 'main'}
               pacingEnabled={prefs().sections.pacing}
+              labelWidth={quotaLabelWidth()}
               resetCredits={state().main?.resetCredits}
             />
             <Show when={prefs().sections.fallbackAccounts}>
@@ -806,6 +926,7 @@ function QuotaSidebar(props: {
                     killed={fb.killed}
                     active={sessionRouting().activeId === fb.id}
                     pacingEnabled={prefs().sections.pacing}
+                    labelWidth={quotaLabelWidth()}
                     resetCredits={fb.resetCredits}
                     marginTop={1}
                   />

package/src/{core/account-paths.ts → tui-compiled/runtime/core-account-paths.ts}

@@ -1,23 +1,28 @@
 import { realpathSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { basename, dirname, join, resolve } from 'node:path'
+import {
+  ACCOUNT_FILE_NAME,
+  ACCOUNT_STATE_FILE_NAME,
+  type AccountPaths,
+  deriveStatePath,
+} from '../shared/internal.ts'
 
 /**
- * Where the account store lives.
+ * Where OpenCode's account store lives.
  *
- * This is the ONLY definition. It used to be duplicated verbatim in both
- * `accounts.ts` and `refresh-file-lock.ts`, because `accounts.ts` imports the
- * lock and the reverse import would have been a cycle. Two copies of a path
- * resolver is a bad trade for that: the lock and the write must agree on the
- * exact file, and if the copies ever drifted, a writer would take a lock on one
- * path while writing another — mutual exclusion silently lost on a file holding
- * credentials. Nothing would fail a test, since each copy works on its own.
+ * This is the ONLY definition of this host's resolution rules. The store code
+ * itself takes both paths as arguments and resolves nothing, so the lock and
+ * the write it guards can never disagree about which file they mean — a
+ * disagreement would lose mutual exclusion on a file holding credentials while
+ * every test still passed, since each side works on its own.
  *
- * This module imports nothing from either side, so both can depend on it.
+ * The file names come from the core so the two hosts cannot drift apart on what
+ * the store is called.
  */
 
-export const ACCOUNT_FILE_NAME = 'openai-auth.json'
-export const ACCOUNT_STATE_FILE_NAME = 'openai-auth-state.json'
+export type { AccountPaths }
+export { ACCOUNT_FILE_NAME, ACCOUNT_STATE_FILE_NAME, deriveStatePath }
 
 function getConfigDir() {
   if (process.env.OPENCODE_CONFIG_DIR?.trim()) {
@@ -36,13 +41,6 @@ export function getAccountStoragePath() {
   )
 }
 
-/** Derive the state-file path from the config path without reading env vars. */
-export function deriveStatePath(configPath: string): string {
-  return basename(configPath) === ACCOUNT_FILE_NAME
-    ? join(dirname(configPath), ACCOUNT_STATE_FILE_NAME)
-    : `${configPath}.state.json`
-}
-
 function normalizePathForComparison(path: string, platform: NodeJS.Platform) {
   const resolved = resolve(path)
   return platform === 'win32' || platform === 'darwin'
@@ -101,3 +99,16 @@ export function getAccountStatePath(configPath = getAccountStoragePath()) {
   }
   return deriveStatePath(configPath)
 }
+
+/**
+ * Both file paths a store call needs, resolved the way this host resolves them.
+ *
+ * Every call site that used to pass a single config path and let the store
+ * derive the state path now passes this pair instead, so the state-file
+ * override keeps being honoured in exactly the places it was before.
+ */
+export function getAccountPaths(
+  configPath = getAccountStoragePath(),
+): AccountPaths {
+  return { configPath, statePath: getAccountStatePath(configPath) }
+}

package/src/tui-compiled/runtime/core-custody-state.ts

@@ -0,0 +1,243 @@
+export type CustodyMode = 'local' | 'claustrum'
+
+export type ManifestCustodyState = 'absent' | 'present' | 'unreadable'
+
+export type LocalCustodyState =
+  | 'real'
+  | 'tombstone'
+  | 'empty'
+  | 'gone'
+  | 'slot-absent'
+
+export type VaultCustodyState =
+  | 'serves'
+  | 'cold'
+  | 'needs_reauth'
+  | 'identity_mismatch'
+  | 'no_handle'
+
+export const CUSTODY_INERT_REASONS = [
+  'needs-login',
+  'mode-mismatch',
+  'corrupt-under-binding',
+  'manifest-unreadable',
+  'unbound-under-claustrum',
+  'orphan-tombstone',
+  'vault-cold',
+  'vault-reauth',
+  'identity-mismatch',
+  'no-handle',
+  'takeover-incomplete',
+  'new-local-family-under-claustrum',
+  'takeover-incomplete/vault-unavailable',
+  'takeover-incomplete/slot-absent',
+] as const
+
+export type CustodyInertReason = (typeof CUSTODY_INERT_REASONS)[number]
+
+export type CustodyVerdict =
+  | { kind: 'LOCAL' }
+  | {
+      kind: 'VAULT'
+      canonicalize?: boolean
+      installTombstone?: boolean
+    }
+  | {
+      kind: 'INERT'
+      reason: CustodyInertReason
+      installTombstone?: boolean
+      canonicalize?: boolean
+    }
+  | { kind: 'NEEDS_LOGIN'; reason?: 'corrupt' }
+
+export interface EvaluateCustodyStartupInput {
+  mode: CustodyMode
+  manifest: ManifestCustodyState
+  local: LocalCustodyState
+  vault: () => VaultCustodyState
+  manifestFailureReason?: string
+  fingerprintMatch?: boolean
+  verifiedInProcessLogin: boolean
+  isMain?: boolean
+}
+
+function unreachable(value: never): never {
+  return value
+}
+
+function withCanonicalization<
+  T extends Extract<CustodyVerdict, { kind: 'VAULT' | 'INERT' }>,
+>(local: LocalCustodyState, verdict: T): T | (T & { canonicalize: true }) {
+  return local === 'empty' ? { ...verdict, canonicalize: true } : verdict
+}
+
+function evaluateLocal(local: LocalCustodyState): CustodyVerdict {
+  switch (local) {
+    case 'real':
+      return { kind: 'LOCAL' }
+    case 'tombstone':
+    case 'empty':
+    case 'slot-absent':
+      return { kind: 'NEEDS_LOGIN' }
+    case 'gone':
+      return { kind: 'NEEDS_LOGIN', reason: 'corrupt' }
+  }
+  return unreachable(local)
+}
+
+function evaluateLocalWithBinding(
+  local: LocalCustodyState,
+  verifiedInProcessLogin: boolean,
+): CustodyVerdict {
+  switch (local) {
+    case 'real':
+      return verifiedInProcessLogin
+        ? { kind: 'LOCAL' }
+        : { kind: 'INERT', reason: 'needs-login' }
+    case 'tombstone':
+    case 'empty':
+    case 'slot-absent':
+      return { kind: 'INERT', reason: 'mode-mismatch' }
+    case 'gone':
+      return { kind: 'INERT', reason: 'corrupt-under-binding' }
+  }
+  return unreachable(local)
+}
+
+function evaluateUnboundClaustrum(local: LocalCustodyState): CustodyVerdict {
+  switch (local) {
+    case 'tombstone':
+    case 'empty':
+      return { kind: 'INERT', reason: 'orphan-tombstone' }
+    case 'real':
+    case 'gone':
+    case 'slot-absent':
+      return { kind: 'INERT', reason: 'unbound-under-claustrum' }
+  }
+  return unreachable(local)
+}
+
+function evaluateTombstone(
+  local: Extract<LocalCustodyState, 'tombstone' | 'empty'>,
+  vault: VaultCustodyState,
+): CustodyVerdict {
+  switch (vault) {
+    case 'serves':
+      return withCanonicalization(local, { kind: 'VAULT' })
+    case 'cold':
+      return withCanonicalization(local, {
+        kind: 'INERT',
+        reason: 'vault-cold',
+      })
+    case 'needs_reauth':
+      return withCanonicalization(local, {
+        kind: 'INERT',
+        reason: 'vault-reauth',
+      })
+    case 'identity_mismatch':
+      return withCanonicalization(local, {
+        kind: 'INERT',
+        reason: 'identity-mismatch',
+      })
+    case 'no_handle':
+      return withCanonicalization(local, { kind: 'INERT', reason: 'no-handle' })
+  }
+  return unreachable(vault)
+}
+
+function evaluateReal(
+  vault: VaultCustodyState,
+  fingerprintMatch: boolean | undefined,
+): CustodyVerdict {
+  switch (vault) {
+    case 'serves':
+      return fingerprintMatch === false
+        ? { kind: 'INERT', reason: 'new-local-family-under-claustrum' }
+        : { kind: 'INERT', reason: 'takeover-incomplete' }
+    case 'cold':
+    case 'needs_reauth':
+      return { kind: 'INERT', reason: 'takeover-incomplete/vault-unavailable' }
+    case 'identity_mismatch':
+      return { kind: 'INERT', reason: 'identity-mismatch' }
+    case 'no_handle':
+      return { kind: 'INERT', reason: 'no-handle' }
+  }
+  return unreachable(vault)
+}
+
+function evaluateGone(vault: VaultCustodyState): CustodyVerdict {
+  switch (vault) {
+    case 'serves':
+      return { kind: 'VAULT', installTombstone: true }
+    case 'cold':
+      return { kind: 'INERT', reason: 'vault-cold', installTombstone: true }
+    case 'needs_reauth':
+      return { kind: 'INERT', reason: 'vault-reauth', installTombstone: true }
+    case 'identity_mismatch':
+      return { kind: 'INERT', reason: 'identity-mismatch' }
+    case 'no_handle':
+      return { kind: 'INERT', reason: 'no-handle' }
+  }
+  return unreachable(vault)
+}
+
+function evaluateSlotAbsent(vault: VaultCustodyState): CustodyVerdict {
+  switch (vault) {
+    case 'serves':
+    case 'cold':
+    case 'needs_reauth':
+      return { kind: 'INERT', reason: 'takeover-incomplete/slot-absent' }
+    case 'identity_mismatch':
+      return { kind: 'INERT', reason: 'identity-mismatch' }
+    case 'no_handle':
+      return { kind: 'INERT', reason: 'no-handle' }
+  }
+  return unreachable(vault)
+}
+
+function evaluatePresentClaustrum(
+  local: LocalCustodyState,
+  vault: VaultCustodyState,
+  fingerprintMatch: boolean | undefined,
+): CustodyVerdict {
+  switch (local) {
+    case 'tombstone':
+    case 'empty':
+      return evaluateTombstone(local, vault)
+    case 'real':
+      return evaluateReal(vault, fingerprintMatch)
+    case 'gone':
+      return evaluateGone(vault)
+    case 'slot-absent':
+      return evaluateSlotAbsent(vault)
+  }
+  return unreachable(local)
+}
+
+export function evaluateCustodyStartup(
+  input: EvaluateCustodyStartupInput,
+): CustodyVerdict {
+  if (input.manifest === 'unreadable') {
+    return { kind: 'INERT', reason: 'manifest-unreadable' }
+  }
+
+  switch (input.mode) {
+    case 'local':
+      return input.manifest === 'present'
+        ? evaluateLocalWithBinding(input.local, input.verifiedInProcessLogin)
+        : evaluateLocal(input.local)
+    case 'claustrum':
+      if (input.manifest === 'absent') {
+        return evaluateUnboundClaustrum(input.local)
+      }
+      if (input.manifest === 'present') {
+        return evaluatePresentClaustrum(
+          input.local,
+          input.vault(),
+          input.fingerprintMatch,
+        )
+      }
+      return unreachable(input.manifest)
+  }
+  return unreachable(input.mode)
+}