@cortexkit/opencode-anthropic-auth 2.2.8 → 2.3.0

package/src/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/claude-sidebar.tsx

@@ -601,6 +601,12 @@ export interface SidebarController {
   toggleCollapsed: () => void
   /** Stops the preference watcher; OpenCode 1 keeps it for the process. */
   dispose: () => void
+  /**
+   * However many refreshes in a row have failed, a retry never waits longer
+   * than this. Every attempt costs the server a full runtime read, so a
+   * failing sidebar must not keep trying at the poll rate forever.
+   */
+  retryMaxMs: number
 }
 
 // The TUI may unmount and remount sidebar_content when the user switches
@@ -658,7 +664,7 @@ export function createSidebarController(
     }
   }
 
-  return { prefs, collapsed, toggleCollapsed, dispose }
+  return { prefs, collapsed, toggleCollapsed, dispose, retryMaxMs: 30_000 }
 }
 
 /** The sidebar panel for one session; the host owns polling and the theme. */
@@ -1070,40 +1076,174 @@ export type ReadSidebarState = (
   signal: AbortSignal,
 ) => Promise<SidebarState>
 
-function HostSidebar(props: {
-  host: ClaudeSidebarHost
+/**
+ * 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.
+ */
+export interface HostSidebarPropsState {
   read: ReadSidebarState
   controller: SidebarController
   sessionId: string
-}) {
-  const [state, setState] = createSignal<SidebarState>(DEFAULT_SIDEBAR_STATE)
+  setTimeoutImpl?: typeof globalThis.setTimeout
+  /** Clears a handle `setTimeoutImpl` returned, whatever type that was. */
+  clearTimeoutImpl?: (handle: unknown) => void
+}
+
+interface HostSidebarProps extends HostSidebarPropsState {
+  host: ClaudeSidebarHost
+}
+
+/** The refresh loop's own timers, so a test can drive its schedule. */
+export interface SidebarScheduleTimers {
+  setTimeoutImpl?: typeof globalThis.setTimeout
+  clearTimeoutImpl?: (handle: unknown) => void
+}
+
+/**
+ * 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: number,
+  failures: number,
+  retryMaxMs: number,
+): number {
+  if (failures <= 0) return pollMs
+  return Math.min(pollMs * 2 ** failures, retryMaxMs)
+}
+
+/** Starts and stops the refresh schedule the sidebar lives on. */
+export interface SidebarSchedule {
+  /**
+   * Reads once and then keeps the retry timer running. Safe to call more than
+   * once: a running schedule is left alone.
+   */
+  start: () => void
+  /**
+   * Stops the schedule for good: clears the waiting timer and aborts a read
+   * still in flight, so it cannot queue another one. The item that unmounts a
+   * sidebar calls this; without it, a failing refresh would keep polling the
+   * server from a sidebar nobody is looking at.
+   */
+  stop: () => void
+}
+
+// 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: {
+    read: ReadSidebarState
+    sessionId: string
+    pollRate: () => { pollMs: number; retryMaxMs: number }
+    /** Receives each answer that differs from the one before it. */
+    onState: (state: SidebarState) => void
+  } & SidebarScheduleTimers,
+): SidebarSchedule {
+  const {
+    read,
+    sessionId,
+    pollRate,
+    onState,
+    setTimeoutImpl = setTimeout,
+    clearTimeoutImpl = clearTimeout as (handle: unknown) => void,
+  } = 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: unknown
+  let running = false
   let inFlight = false
   let shown = ''
-  const refresh = async () => {
-    if (inFlight || abort.signal.aborted) return
+  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 (): Promise<boolean | undefined> => {
+    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: HostSidebarPropsState,
+): () => SidebarState {
+  const [state, setState] = createSignal<SidebarState>(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: HostSidebarProps) {
+  const state = useHostSidebarState(props)
   return (
     <ClaudeSidebar
       state={state}

package/src/tui/entry.mjs

@@ -59,6 +59,17 @@ async function loadSignInLink() {
   return import('../tui-compiled/tui/sign-in-link.tsx')
 }
 
+// The /claude menu's status view, loaded the same way as the sidebar.
+async function loadMenuStatus() {
+  try {
+    await import(runtimeProbe)
+  } catch (error) {
+    if (!isMissingRuntimeRegistry(error)) throw error
+    return import('./menu-status.tsx')
+  }
+  return import('../tui-compiled/tui/menu-status.tsx')
+}
+
 let legacyModule
 
 // OpenCode 1 reads id and tui from the default definition; OpenCode 2 reads
@@ -84,6 +95,8 @@ export const setup = async (context) => {
       (await loadSidebar()).mountClaudeSidebar(ctx, read),
     showSignInLink: async (ctx, url, signal) =>
       (await loadSignInLink()).showSignInLinkDialog(ctx, url, signal),
+    showStatus: async (ctx, view, signal) =>
+      (await loadMenuStatus()).showMenuStatusDialog(ctx, view, signal),
   })
 }