@cortexkit/opencode-anthropic-auth 2.2.7 → 2.3.0

package/src/tui/menu-status.tsx

@@ -0,0 +1,300 @@
+/** @jsxImportSource @opentui/solid */
+
+// The status view of the OpenCode 2 `/claude` menu. Core writes a section's
+// status as plain lines, some of them Markdown: the quota summary has `##`
+// headings and indented `-` bullets. This view draws headings and bullets as
+// styled text instead of showing their markers. For the Quota section it draws
+// the account blocks of OpenCode 1's quota view, read from the same server
+// state as the sidebar, and falls back to the text when that read fails.
+
+import { TextAttributes } from '@opentui/core'
+import { createSignal, For, type JSX, Show } from 'solid-js'
+import type { SidebarState } from '../sidebar-state.js'
+import {
+  type AnthropicAuthTuiPrefs,
+  readTuiPreferencesFile,
+  resolveAnthropicAuthPrefs,
+} from '../tui-preferences.js'
+import {
+  AccountBlock,
+  type HostTheme,
+  type SidebarTheme,
+  sidebarThemeFromHost,
+} from './claude-sidebar.js'
+
+/** One status line, classified for drawing. */
+export type StatusLine =
+  | { readonly kind: 'heading'; readonly level: number; readonly text: string }
+  | { readonly kind: 'bullet'; readonly indent: number; readonly text: string }
+  | { readonly kind: 'text'; readonly text: string }
+  | { readonly kind: 'blank' }
+
+// The widest indent kept for a bullet; deeper nesting is drawn at this indent.
+const MAX_BULLET_INDENT = 8
+
+// The width of OpenCode 1's quota view (`QuotaDialogContent` in `tui.tsx`).
+const QUOTA_VIEW_WIDTH = 58
+
+/**
+ * Splits a section's status lines (each may hold several lines) and classifies
+ * each one. Only line-leading Markdown is read: `#` headings and `-`, `*` or
+ * `+` bullets. Everything else, including any `*` inside a line, stays as
+ * written. Runs of blank lines collapse to one, and leading or trailing blank
+ * lines are dropped.
+ */
+export function parseStatusLines(lines: readonly string[]): StatusLine[] {
+  const parsed: StatusLine[] = []
+  for (const raw of lines.join('\n').split(/\r?\n/)) {
+    const line = raw.trimEnd()
+    if (line.trim() === '') {
+      if (parsed.length && parsed.at(-1)?.kind !== 'blank')
+        parsed.push({ kind: 'blank' })
+      continue
+    }
+    const heading = /^\s{0,3}(#{1,6})\s+(.+?)(?:\s+#+)?$/.exec(line)
+    if (heading?.[1] && heading[2]) {
+      parsed.push({
+        kind: 'heading',
+        level: heading[1].length,
+        text: heading[2],
+      })
+      continue
+    }
+    const bullet = /^(\s*)[-*+]\s+(.+)$/.exec(line)
+    if (bullet?.[2]) {
+      parsed.push({
+        kind: 'bullet',
+        indent: Math.min(bullet[1]?.length ?? 0, MAX_BULLET_INDENT),
+        text: bullet[2],
+      })
+      continue
+    }
+    parsed.push({ kind: 'text', text: line })
+  }
+  if (parsed.at(-1)?.kind === 'blank') parsed.pop()
+  return parsed
+}
+
+/** Draws one status line; headings and bullets lose their Markdown markers. */
+function StatusRow(props: {
+  readonly line: StatusLine
+  readonly theme: SidebarTheme
+}): JSX.Element {
+  const line = props.line
+  switch (line.kind) {
+    case 'heading':
+      return (
+        <text
+          // Top-level headings take the accent color; lower levels, such as
+          // one account in the quota summary, stay in the text color.
+          fg={line.level <= 2 ? props.theme.accent : props.theme.text}
+          attributes={TextAttributes.BOLD}
+        >
+          {line.text}
+        </text>
+      )
+    case 'bullet':
+      return (
+        // The text sits in its own column, so a long bullet wraps under its
+        // first word instead of under the bullet mark.
+        <box flexDirection='row' paddingLeft={line.indent}>
+          <text fg={props.theme.textMuted} flexShrink={0}>
+            {'• '}
+          </text>
+          <text fg={props.theme.text} flexGrow={1} flexShrink={1}>
+            {line.text}
+          </text>
+        </box>
+      )
+    case 'text':
+      return <text fg={props.theme.text}>{line.text}</text>
+    default:
+      return <box height={1} />
+  }
+}
+
+/** Draws status lines with headings and bullets styled, not as Markdown. */
+export function StatusText(props: {
+  readonly lines: readonly string[]
+  readonly theme: SidebarTheme
+}): JSX.Element {
+  return (
+    <box flexDirection='column' width='100%'>
+      <For each={parseStatusLines(props.lines)}>
+        {(line) => <StatusRow line={line} theme={props.theme} />}
+      </For>
+    </box>
+  )
+}
+
+/**
+ * OpenCode 1's quota view: one account block for main and for each enabled or
+ * vault-held fallback, as the sidebar draws them.
+ */
+export function QuotaStatus(props: {
+  readonly state: SidebarState
+  readonly theme: SidebarTheme
+  readonly prefs: AnthropicAuthTuiPrefs
+  readonly now: number
+}): JSX.Element {
+  const fallbacks = () =>
+    (props.state.fallbacks ?? []).filter(
+      (fallback) =>
+        fallback.enabled ||
+        (fallback.custodyState && fallback.custodyState !== 'off'),
+    )
+  return (
+    // As wide as OpenCode 1's quota view: wider, the reset times drift far
+    // from the bars they belong to.
+    <box flexDirection='column' width='100%' maxWidth={QUOTA_VIEW_WIDTH}>
+      <AccountBlock
+        theme={props.theme}
+        appearance={props.prefs.appearance}
+        name='main'
+        quota={props.state.main?.quota}
+        active={props.state.activeId === 'main'}
+        pacingEnabled={props.prefs.sections.pacing}
+        tierLabel={props.state.main?.tierLabel}
+        stateLine={props.state.main?.stateLine}
+        quotaDated={props.state.main?.quotaDated}
+        now={props.now}
+      />
+      <Show when={props.prefs.sections.fallbackAccounts}>
+        <For each={fallbacks()}>
+          {(fallback) => (
+            <AccountBlock
+              theme={props.theme}
+              appearance={props.prefs.appearance}
+              name={fallback.label ?? fallback.id}
+              quota={fallback.quota}
+              active={props.state.activeId === fallback.id}
+              pacingEnabled={props.prefs.sections.pacing}
+              tierLabel={fallback.tierLabel}
+              needsReauth={fallback.needsReauth}
+              vaultReauth={fallback.vaultReauth}
+              stateLine={fallback.stateLine}
+              quotaDated={fallback.quotaDated}
+              marginTop={1}
+              now={props.now}
+            />
+          )}
+        </For>
+      </Show>
+    </box>
+  )
+}
+
+// --- OpenCode 2 -------------------------------------------------------------
+
+/** One section's status, as the `/claude` menu hands it over. */
+export interface MenuStatusView {
+  readonly title: string
+  readonly lines: readonly string[]
+  /**
+   * Reads the sidebar's quota state; given for the Quota section only, whose
+   * view then draws account blocks instead of the text.
+   */
+  readonly readQuota?: (signal: AbortSignal) => Promise<SidebarState>
+}
+
+/** The OpenCode 2 TUI context members the status dialog uses. */
+export interface MenuStatusHost {
+  readonly theme: HostTheme
+  readonly ui: {
+    readonly dialog: {
+      show(render: () => JSX.Element, onClose?: () => void): void
+      set(options: { readonly size?: 'medium' | 'large' | 'xlarge' }): void
+    }
+  }
+}
+
+type QuotaView =
+  | { readonly kind: 'loading' }
+  | {
+      readonly kind: 'ready'
+      readonly state: SidebarState
+      readonly prefs: AnthropicAuthTuiPrefs
+    }
+  | { readonly kind: 'failed' }
+
+type ReadyQuota = Extract<QuotaView, { readonly kind: 'ready' }>
+
+/**
+ * Shows a section's status in a wide OpenCode 2 dialog. The returned promise
+ * settles when the person closes the dialog, or when `signal` aborts.
+ */
+export function showMenuStatusDialog(
+  host: MenuStatusHost,
+  view: MenuStatusView,
+  signal?: AbortSignal,
+): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) return resolve()
+    // Stops the quota read once the dialog closes or the menu goes away.
+    const reading = new AbortController()
+    const close = () => {
+      reading.abort()
+      resolve()
+    }
+    signal?.addEventListener('abort', close, { once: true })
+    const [quota, setQuota] = createSignal<QuotaView>({ kind: 'loading' })
+    const readQuota = view.readQuota
+    if (readQuota)
+      void Promise.all([
+        readQuota(reading.signal),
+        readTuiPreferencesFile().then(resolveAnthropicAuthPrefs),
+      ]).then(
+        ([state, prefs]) => {
+          if (!reading.signal.aborted) setQuota({ kind: 'ready', state, prefs })
+        },
+        () => {
+          // An older server without the sidebar method, or a failed read:
+          // the status text still says everything the blocks would.
+          if (!reading.signal.aborted) setQuota({ kind: 'failed' })
+        },
+      )
+    const ready = () => {
+      const current = quota()
+      return current.kind === 'ready' ? current : undefined
+    }
+    const theme = () => sidebarThemeFromHost(host.theme)
+    host.ui.dialog.show(
+      () => (
+        <box flexDirection='column' paddingLeft={2} paddingRight={2}>
+          <box paddingBottom={1}>
+            <text fg={theme().text} attributes={TextAttributes.BOLD}>
+              {view.title}
+            </text>
+          </box>
+          <Show
+            when={readQuota && quota().kind !== 'failed'}
+            fallback={<StatusText lines={view.lines} theme={theme()} />}
+          >
+            <Show
+              when={ready()}
+              fallback={
+                <text fg={theme().textMuted}>{'Reading quota\u2026'}</text>
+              }
+            >
+              {(ready: () => ReadyQuota) => (
+                <QuotaStatus
+                  state={ready().state}
+                  prefs={ready().prefs}
+                  theme={theme()}
+                  now={Date.now()}
+                />
+              )}
+            </Show>
+          </Show>
+          <box paddingTop={1}>
+            <text fg={theme().textMuted}>Press Esc to close.</text>
+          </box>
+        </box>
+      ),
+      close,
+    )
+    // The widest dialog gives the account blocks their full width and wraps
+    // status text as little as it can.
+    host.ui.dialog.set({ size: 'xlarge' })
+  })
+}

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

@@ -30,7 +30,9 @@ export interface AccountQuota {
 
 export interface SidebarAccountState {
   id: string
-  label: string | undefined
+  // Absent, rather than present and `undefined`, when the account has no
+  // label: the OpenCode 2 RPC boundary refuses a value carrying `undefined`.
+  label?: string
   quota: AccountQuota | null
   enabled: boolean
   stateLine?: string
@@ -91,7 +93,9 @@ export interface SidebarState {
     refreshBackoffUntil?: number
   }
   fallbacks: SidebarAccountState[]
-  activeId: string | undefined
+  // Absent rather than `undefined`: `normalizeSidebarState` never writes the
+  // key, and the OpenCode 2 RPC boundary refuses a value carrying `undefined`.
+  activeId?: string
   route: string
   relay: { enabled: boolean; transport: string } | null
   fastMode: boolean
@@ -146,7 +150,6 @@ export function getSidebarStateFile(): string {
 export const DEFAULT_SIDEBAR_STATE: SidebarState = {
   main: { quota: null },
   fallbacks: [],
-  activeId: undefined,
   route: 'main',
   relay: null,
   fastMode: false,
@@ -350,40 +353,46 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
     }
     if (typeof m.quotaBackedOff === 'boolean')
       main.quotaBackedOff = m.quotaBackedOff
-    if (typeof m.quotaBackoffUntil === 'number')
+    // Only finite numbers are display data: the OpenCode 2 RPC boundary
+    // refuses NaN and Infinity, so they are dropped like any wrong type.
+    if (isFiniteNumber(m.quotaBackoffUntil)) {
       main.quotaBackoffUntil = m.quotaBackoffUntil
+    }
     if (typeof m.refreshBackedOff === 'boolean')
       main.refreshBackedOff = m.refreshBackedOff
-    if (typeof m.refreshBackoffUntil === 'number')
+    if (isFiniteNumber(m.refreshBackoffUntil)) {
       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,
-          ...(typeof entry.stateLine === 'string' && {
-            stateLine: entry.stateLine,
-          }),
-          ...(entry.quotaDated === true && { quotaDated: true }),
-          needsReauth:
-            typeof entry.needsReauth === 'boolean' ? entry.needsReauth : false,
-          ...(entry.vaultReauth === true && { vaultReauth: true }),
-          ...(entry.vaultServed === true && { vaultServed: true }),
-          ...(typeof entry.custodyState === 'string' && {
-            custodyState:
-              entry.custodyState as SidebarAccountState['custodyState'],
+        .map(
+          (entry): SidebarAccountState => ({
+            id: entry.id as string,
+            ...(typeof entry.label === 'string' && { label: entry.label }),
+            quota: normalizeAccountQuota(entry.quota),
+            enabled: typeof entry.enabled === 'boolean' ? entry.enabled : false,
+            ...(typeof entry.stateLine === 'string' && {
+              stateLine: entry.stateLine,
+            }),
+            ...(entry.quotaDated === true && { quotaDated: true }),
+            needsReauth:
+              typeof entry.needsReauth === 'boolean'
+                ? entry.needsReauth
+                : false,
+            ...(entry.vaultReauth === true && { vaultReauth: true }),
+            ...(entry.vaultServed === true && { vaultServed: true }),
+            ...(typeof entry.custodyState === 'string' && {
+              custodyState:
+                entry.custodyState as SidebarAccountState['custodyState'],
+            }),
+            ...(typeof entry.tierLabel === 'string' &&
+              entry.tierLabel.trim() && { tierLabel: entry.tierLabel.trim() }),
           }),
-          tierLabel:
-            typeof entry.tierLabel === 'string' && entry.tierLabel.trim()
-              ? entry.tierLabel.trim()
-              : undefined,
-        }))
+        )
     : []
 
   let relay: SidebarState['relay'] = null
@@ -400,11 +409,10 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
     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,
+        ...(typeof ck.window === 'string' && { window: ck.window }),
+        ...(isFiniteNumber(ck.trackedSessions) && {
+          trackedSessions: ck.trackedSessions,
+        }),
       }
     }
   }
@@ -432,23 +440,23 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
               mode: recovery.mode,
               remaining: Math.max(0, Math.floor(recovery.remaining)),
               changedAt: recovery.changedAt,
-              requestedModelId:
-                typeof recovery.requestedModelId === 'string'
-                  ? recovery.requestedModelId
-                  : undefined,
-              targetModelId:
-                typeof recovery.targetModelId === 'string'
-                  ? recovery.targetModelId
-                  : undefined,
+              ...(typeof recovery.requestedModelId === 'string' && {
+                requestedModelId: recovery.requestedModelId,
+              }),
+              ...(typeof recovery.targetModelId === 'string' && {
+                targetModelId: recovery.targetModelId,
+              }),
             },
           ]
         })
     : []
 
+  const prime = normalizePrimeSection(raw.prime)
+
   return {
     main,
     fallbacks,
-    activeId: typeof raw.activeId === 'string' ? raw.activeId : undefined,
+    ...(typeof raw.activeId === 'string' && { activeId: raw.activeId }),
     route:
       typeof raw.route === 'string' ? raw.route : DEFAULT_SIDEBAR_STATE.route,
     relay,
@@ -457,9 +465,9 @@ export function normalizeSidebarState(raw: unknown): SidebarState {
         ? raw.fastMode
         : DEFAULT_SIDEBAR_STATE.fastMode,
     cacheKeep,
-    prime: normalizePrimeSection(raw.prime),
-    fableRecoveries: fableRecoveries.length > 0 ? fableRecoveries : undefined,
-    lastUpdated: typeof raw.lastUpdated === 'number' ? raw.lastUpdated : 0,
+    ...(prime && { prime }),
+    ...(fableRecoveries.length > 0 && { fableRecoveries }),
+    lastUpdated: isFiniteNumber(raw.lastUpdated) ? raw.lastUpdated : 0,
   }
 }
 
@@ -692,9 +700,10 @@ export interface SidebarStateWriteOptions {
           })
         | undefined
       >
-  onRoutingResolved?: (
-    routing: Pick<SidebarState, 'activeId' | 'route'>,
-  ) => void
+  onRoutingResolved?: (routing: {
+    activeId: string | undefined
+    route: string
+  }) => void
 }
 
 export async function setSidebarState(

package/src/tui-compiled/tui/claude-sidebar.tsx

@@ -698,7 +698,8 @@ export function createSidebarController(initialPrefs) {
     prefs,
     collapsed,
     toggleCollapsed,
-    dispose
+    dispose,
+    retryMaxMs: 30_000
   };
 }
 
@@ -1239,38 +1240,137 @@ export function sidebarThemeFromHost(theme) {
 
 /** Reads one session's sidebar state from the location's server. */
 
-function HostSidebar(props) {
-  const [state, setState] = createSignal(DEFAULT_SIDEBAR_STATE);
+/**
+ * What the sidebar reads and draws with, independent of the host chrome.
+ * The timer functions default to the global ones; a test passes its own so it
+ * can drive the refresh schedule without touching the shared globals.
+ */
+
+/** The refresh loop's own timers, so a test can drive its schedule. */
+
+/**
+ * Delay before the next refresh after `failures` failed reads in a row, each
+ * one longer than the last until the controller's limit. A successful read
+ * resets the count, so a healthy server is polled at the configured rate. A
+ * failed read still costs the server a full runtime read, so retrying at the
+ * poll rate keeps that cost alive for as long as the failure lasts.
+ */
+export function sidebarRetryDelay(pollMs, failures, retryMaxMs) {
+  if (failures <= 0) return pollMs;
+  return Math.min(pollMs * 2 ** failures, retryMaxMs);
+}
+
+/** Starts and stops the refresh schedule the sidebar lives on. */
+
+// One read on start, then a timer that backs off after failures and resets
+// after a success. Lives outside Solid: the component drives it from an
+// effect, and tests drive it with their own timers.
+export function createSidebarSchedule(options) {
+  const {
+    read,
+    sessionId,
+    pollRate,
+    onState,
+    setTimeoutImpl = setTimeout,
+    clearTimeoutImpl = clearTimeout
+  } = options;
   const abort = new AbortController();
+  // The timer waiting to run. Every schedule replaces it, so stopping always
+  // clears the one that is actually queued.
+  let timer;
+  let running = false;
   let inFlight = false;
   let shown = '';
+  let failures = 0;
+  // `undefined` means the previous read was still running, which is not a
+  // failure: counting it as one would back off before the server answered.
   const refresh = async () => {
-    if (inFlight || abort.signal.aborted) return;
+    if (inFlight || abort.signal.aborted) return undefined;
     inFlight = true;
     try {
-      const next = await props.read(props.sessionId, abort.signal);
-      // Every answer is stamped now; redraw only when its content changed.
-      // Countdowns and ages advance on the sidebar's own clock.
+      const next = await read(sessionId, abort.signal);
+      // Every answer is stamped by the server; redraw only when its content
+      // changed. Countdowns and ages advance on the sidebar's own clock.
       const content = JSON.stringify({
         ...next,
         lastUpdated: 0
       });
       if (!abort.signal.aborted && content !== shown) {
         shown = content;
-        setState(next);
+        onState(next);
       }
+      return true;
     } catch {
       // Keep the last state; an older server without `sidebar` keeps waiting.
+      return false;
     } finally {
       inFlight = false;
     }
   };
+  const schedule = () => {
+    if (!running) return;
+    const {
+      pollMs,
+      retryMaxMs
+    } = pollRate();
+    const wait = sidebarRetryDelay(pollMs, failures, retryMaxMs);
+    timer = setTimeoutImpl(async () => {
+      timer = undefined;
+      if (!running) return;
+      const ok = await refresh();
+      if (!running) return;
+      if (ok === true) failures = 0;else if (ok === false) failures += 1;
+      schedule();
+    }, wait);
+  };
+  return {
+    start() {
+      if (running || abort.signal.aborted) return;
+      running = true;
+      // The first read happens here rather than in the timer, so a caller that
+      // starts before any draw still has an answer waiting for it. The loop
+      // then continues on the retry timer below.
+      void refresh().then(ok => {
+        if (running && ok === false) failures += 1;
+      });
+      schedule();
+    },
+    stop() {
+      running = false;
+      if (timer !== undefined) clearTimeoutImpl(timer);
+      timer = undefined;
+      abort.abort();
+    }
+  };
+}
+
+// The OpenCode 2 sidebar's state: its refresh schedule, redrawn through a
+// signal the component renders from.
+export function useHostSidebarState(props) {
+  const [state, setState] = createSignal(DEFAULT_SIDEBAR_STATE);
   createEffect(() => {
-    const timer = setInterval(refresh, props.controller.prefs().pollMs);
-    onCleanup(() => clearInterval(timer));
+    // Reading the poll rate here re-runs this effect when it changes. A
+    // stopped schedule never restarts, so each run builds a fresh one and the
+    // cleanup stops the run it belongs to.
+    const pollMs = props.controller.prefs().pollMs;
+    const schedule = createSidebarSchedule({
+      read: props.read,
+      sessionId: props.sessionId,
+      pollRate: () => ({
+        pollMs,
+        retryMaxMs: props.controller.retryMaxMs
+      }),
+      onState: setState,
+      setTimeoutImpl: props.setTimeoutImpl,
+      clearTimeoutImpl: props.clearTimeoutImpl
+    });
+    schedule.start();
+    onCleanup(() => schedule.stop());
   });
-  void refresh();
-  onCleanup(() => abort.abort());
+  return state;
+}
+function HostSidebar(props) {
+  const state = useHostSidebarState(props);
   return _$createComponent(ClaudeSidebar, {
     state: state,
     theme: () => sidebarThemeFromHost(props.host.theme),