@cortexkit/opencode-anthropic-auth 1.9.2 → 1.9.4

package/src/tui.tsx

@@ -1,31 +1,47 @@
 /** @jsxImportSource @opentui/solid */
 
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import type {
   TuiPlugin,
   TuiPluginApi,
   TuiPluginModule,
 } from '@opencode-ai/plugin/tui'
-import { readFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { For, type JSX, Show, createSignal, onCleanup } from 'solid-js'
+import {
+  createEffect,
+  createSignal,
+  For,
+  type JSX,
+  onCleanup,
+  Show,
+} from 'solid-js'
 
 import {
   type AccountQuota,
+  computeQuotaPacing,
   DEFAULT_SIDEBAR_STATE,
-  type SidebarState,
+  FIVE_HOUR_MS,
   getCollapsedQuotaSummary,
   getSidebarState,
+  type QuotaPacing,
   resolveActiveAccount,
+  SEVEN_DAY_MS,
+  type SidebarState,
 } from './sidebar-state.js'
-
-const POLL_MS = 1500
-const REFRESH_DEBOUNCE_MS = 200
+import {
+  type AnthropicAuthTuiPrefs,
+  type AppearancePrefs,
+  computeEffectiveOrder,
+  DEFAULT_SLOT_ORDER,
+  PLUGIN_KEY,
+  queueTuiPreferenceUpdate,
+  readTuiPreferencesFile,
+  resolveAnthropicAuthPrefs,
+  watchTuiPreferences,
+} from './tui-preferences.js'
 
 const ID = 'cortexkit.anthropic-auth'
-const BAR_WIDTH = 10
-const BAR_FILLED = '\u2588'
-const BAR_EMPTY = '\u2591'
 
 // Plugin version for the header (mirrors the Magic Context / AFT convention).
 // Read at runtime from package.json relative to this module — NOT a TS JSON
@@ -70,18 +86,61 @@ function toneColor(theme: ThemeCurrent, tone: Tone): ThemeColor {
   }
 }
 
-function usageTone(usedPct: number): Tone {
-  if (usedPct < 50) return 'ok'
-  if (usedPct < 80) return 'warn'
+function usageTone(usedPct: number, appearance: AppearancePrefs): Tone {
+  if (usedPct < appearance.warnThreshold) return 'ok'
+  if (usedPct < appearance.errorThreshold) return 'warn'
   return 'err'
 }
 
-function quotaBar(usedPct: number, width = BAR_WIDTH): string {
-  const filled = Math.max(
-    0,
-    Math.min(Math.round((usedPct / 100) * width), width),
-  )
-  return BAR_FILLED.repeat(filled) + BAR_EMPTY.repeat(width - filled)
+interface BarSegment {
+  text: string
+  tone: Tone
+}
+
+const PACE_RESERVE_CHAR = '\u2592'
+const PACE_DEFICIT_CHAR = '\u2593'
+
+// Variant C pacing bar: normal fill up to min(used, pace), then a pace
+// segment covering the gap — headroom being banked (reserve, ok tone) or the
+// overshoot itself (deficit, err tone) — then empty cells. Without pacing the
+// bar renders as a single fill+empty pair, identical to the pre-pacing look.
+// Empty text nodes still occupy a phantom cell in the opentui flex row, so
+// zero-length segments are dropped from every return path (plain and pacing).
+function quotaBarSegments(
+  usedPct: number,
+  appearance: AppearancePrefs,
+  pacing: QuotaPacing | null,
+): BarSegment[] {
+  const width = appearance.barWidth
+  const cells = (pct: number) =>
+    Math.max(0, Math.min(Math.round((pct / 100) * width), width))
+  const usedCells = cells(usedPct)
+  const fillTone = usageTone(usedPct, appearance)
+  const plain: BarSegment[] = [
+    { text: appearance.barFilledChar.repeat(usedCells), tone: fillTone },
+    {
+      text: appearance.barEmptyChar.repeat(width - usedCells),
+      tone: fillTone,
+    },
+  ]
+  if (!pacing) return plain.filter((segment) => segment.text.length > 0)
+  const paceCells = cells(pacing.pacePercent)
+  const lo = Math.min(usedCells, paceCells)
+  const hi = Math.max(usedCells, paceCells)
+  if (hi === lo) return plain.filter((segment) => segment.text.length > 0)
+  const overspent = usedCells > paceCells
+  return (
+    [
+      { text: appearance.barFilledChar.repeat(lo), tone: fillTone },
+      {
+        text: (overspent ? PACE_DEFICIT_CHAR : PACE_RESERVE_CHAR).repeat(
+          hi - lo,
+        ),
+        tone: overspent ? 'err' : 'ok',
+      },
+      { text: appearance.barEmptyChar.repeat(width - hi), tone: fillTone },
+    ] as BarSegment[]
+  ).filter((segment) => segment.text.length > 0)
 }
 
 function formatResetIn(resetsAt: string | undefined): string {
@@ -91,8 +150,13 @@ function formatResetIn(resetsAt: string | undefined): string {
   const mins = Math.floor(ms / 60_000)
   if (mins < 60) return `${mins}m`
   const hrs = Math.floor(mins / 60)
-  const rm = mins % 60
-  return rm > 0 ? `${hrs}h${rm}m` : `${hrs}h`
+  if (hrs < 24) {
+    const rm = mins % 60
+    return rm > 0 ? `${hrs}h${rm}m` : `${hrs}h`
+  }
+  const days = Math.floor(hrs / 24)
+  const rh = hrs % 24
+  return rh > 0 ? `${days}d${rh}h` : `${days}d`
 }
 
 function formatUntil(until: number | undefined): string {
@@ -154,14 +218,27 @@ function CollapsedRow(props: {
 }
 
 // Quota window row: muted label left, tone-colored bar + percentage right,
-// with an optional muted reset suffix.
+// with an optional muted reset suffix. When pacing data is present, the bar
+// gains a pace segment and an off-pace window adds a muted subline with the
+// reserve/deficit delta and the projected runout.
 function QuotaRow(props: {
   theme: ThemeCurrent
+  appearance: AppearancePrefs
   label: string
   window: { usedPercent: number; resetsAt?: string } | undefined
+  pacing: QuotaPacing | null
 }) {
   const used = () => props.window?.usedPercent ?? 0
   const reset = () => formatResetIn(props.window?.resetsAt)
+  const paceLine = () => {
+    const pacing = props.pacing
+    if (!pacing || pacing.state === 'on-pace') return null
+    const pct = Math.round(Math.abs(pacing.deltaPercent))
+    if (pacing.state === 'reserve') return `reserve ${pct}% \u00b7 lasts`
+    return pacing.runsOutAt
+      ? `deficit ${pct}% \u00b7 out in ${formatResetIn(pacing.runsOutAt)}`
+      : `deficit ${pct}% \u00b7 lasts`
+  }
   return (
     <Show
       when={props.window}
@@ -178,10 +255,16 @@ function QuotaRow(props: {
       <box width='100%' flexDirection='row' justifyContent='space-between'>
         <box flexDirection='row'>
           <text fg={props.theme.textMuted}>{props.label.padEnd(3)}</text>
-          <text fg={toneColor(props.theme, usageTone(used()))}>
-            {quotaBar(used())}
-          </text>
-          <text fg={toneColor(props.theme, usageTone(used()))}>
+          <For each={quotaBarSegments(used(), props.appearance, props.pacing)}>
+            {(segment) => (
+              <text fg={toneColor(props.theme, segment.tone)}>
+                {segment.text}
+              </text>
+            )}
+          </For>
+          <text
+            fg={toneColor(props.theme, usageTone(used(), props.appearance))}
+          >
             {` ${String(Math.round(used())).padStart(3)}%`}
           </text>
         </box>
@@ -189,20 +272,46 @@ function QuotaRow(props: {
           <text fg={props.theme.textMuted}>{reset()}</text>
         </Show>
       </box>
+      <Show when={paceLine()}>
+        <box width='100%' flexDirection='row'>
+          <text fg={props.theme.textMuted}>{'   '}</text>
+          <text
+            fg={toneColor(
+              props.theme,
+              props.pacing?.state === 'deficit' ? 'warn' : 'muted',
+            )}
+          >
+            {paceLine()}
+          </text>
+        </box>
+      </Show>
     </Show>
   )
 }
 
 // Account block: header row (name + status word) then per-window quota rows.
+// Pacing is computed here — per window, against the wall clock at render time
+// (re-evaluated on every state poll) — and disabled by passing false.
 function AccountBlock(props: {
   theme: ThemeCurrent
+  appearance: AppearancePrefs
   name: string
   quota: AccountQuota | null
   active: boolean
+  pacingEnabled: boolean
   marginTop?: number
 }) {
   const statusWord = () => (props.active ? 'active' : 'idle')
   const statusTone = (): Tone => (props.active ? 'ok' : 'muted')
+  const pacingFor = (
+    window:
+      | { usedPercent: number; remainingPercent: number; resetsAt?: string }
+      | undefined,
+    windowMs: number,
+  ) =>
+    props.pacingEnabled && window
+      ? computeQuotaPacing(window, windowMs, Date.now())
+      : null
   return (
     <box width='100%' flexDirection='column' marginTop={props.marginTop ?? 0}>
       <box width='100%' flexDirection='row' justifyContent='space-between'>
@@ -219,13 +328,17 @@ function AccountBlock(props: {
       >
         <QuotaRow
           theme={props.theme}
+          appearance={props.appearance}
           label='5h'
           window={props.quota?.five_hour}
+          pacing={pacingFor(props.quota?.five_hour, FIVE_HOUR_MS)}
         />
         <QuotaRow
           theme={props.theme}
+          appearance={props.appearance}
           label='7d'
           window={props.quota?.seven_day}
+          pacing={pacingFor(props.quota?.seven_day, SEVEN_DAY_MS)}
         />
       </Show>
     </box>
@@ -238,9 +351,77 @@ async function readStateFromFile(): Promise<SidebarState> {
   return getSidebarState()
 }
 
-function QuotaSidebar(props: { api: TuiPluginApi }) {
+interface SidebarController {
+  prefs: () => AnthropicAuthTuiPrefs
+  collapsed: () => boolean
+  toggleCollapsed: () => void
+}
+
+// The TUI may unmount and remount sidebar_content when the user switches
+// views (e.g. main -> subagent -> main). A remount re-runs the component
+// body, so any signal created inside the component would reset to its
+// seed. The controller lives in the plugin closure (process lifetime)
+// and owns the durable prefs/collapse signals plus the single shared
+// watcher subscription, so collapse and live pref reloads survive the
+// remount. No effects or memos here — those need a Solid owner, so the
+// poll-interval createEffect stays inside the component.
+function createSidebarController(
+  initialPrefs: AnthropicAuthTuiPrefs,
+): SidebarController {
+  const [prefs, setPrefs] = createSignal<AnthropicAuthTuiPrefs>(initialPrefs)
+  const seedCollapsed =
+    initialPrefs.rememberCollapsed && initialPrefs.collapsed != null
+      ? initialPrefs.collapsed
+      : initialPrefs.startCollapsed
+  const [collapsed, setCollapsed] = createSignal(seedCollapsed)
+  let lastPersistedCollapsed: boolean | null = initialPrefs.collapsed
+  let lastApplied = JSON.stringify(initialPrefs)
+
+  // The watcher lives for the plugin/process lifetime — it is intentionally
+  // never disposed. Collapse guard mirrors the race-fix in toggleCollapsed:
+  // lastPersistedCollapsed is advanced only once our own write lands, so
+  // watcher echoes of the previous persisted value are rejected by the
+  // `!==` check and cannot revert a user click.
+  watchTuiPreferences(() => {
+    void (async () => {
+      const next = resolveAnthropicAuthPrefs(await readTuiPreferencesFile())
+      const serialized = JSON.stringify(next)
+      if (serialized === lastApplied) return
+      lastApplied = serialized
+      setPrefs(next)
+      if (
+        next.rememberCollapsed &&
+        next.collapsed != null &&
+        next.collapsed !== lastPersistedCollapsed
+      ) {
+        lastPersistedCollapsed = next.collapsed
+        setCollapsed(next.collapsed)
+      }
+    })()
+  })
+
+  function toggleCollapsed() {
+    const next = !collapsed()
+    setCollapsed(next)
+    if (prefs().rememberCollapsed) {
+      void queueTuiPreferenceUpdate(PLUGIN_KEY, ['collapsed'], next).then(
+        () => {
+          lastPersistedCollapsed = next
+        },
+      )
+    }
+  }
+
+  return { prefs, collapsed, toggleCollapsed }
+}
+
+function QuotaSidebar(props: {
+  api: TuiPluginApi
+  controller: SidebarController
+}) {
+  const prefs = props.controller.prefs
+  const collapsed = props.controller.collapsed
   const [state, setState] = createSignal<SidebarState>(DEFAULT_SIDEBAR_STATE)
-  const [collapsed, setCollapsed] = createSignal(false)
   let lastUpdated = 0
   let debounce: ReturnType<typeof setTimeout> | null = null
 
@@ -257,19 +438,23 @@ function QuotaSidebar(props: { api: TuiPluginApi }) {
     debounce = setTimeout(() => {
       debounce = null
       void refresh()
-    }, REFRESH_DEBOUNCE_MS)
+    }, prefs().refreshDebounceMs)
   }
 
   // Background poller (server and TUI run as separate module instances, so we
   // sync through the state file) plus event-driven refreshes for low latency.
-  const timer = setInterval(refresh, POLL_MS)
+  // The interval rebuilds whenever pollMs changes.
+  createEffect(() => {
+    const timer = setInterval(refresh, prefs().pollMs)
+    onCleanup(() => clearInterval(timer))
+  })
   const unsubs = [
     props.api.event.on('session.updated', scheduleRefresh),
     props.api.event.on('message.updated', scheduleRefresh),
   ]
   setTimeout(refresh, 300)
+
   onCleanup(() => {
-    clearInterval(timer)
     if (debounce) clearTimeout(debounce)
     for (const u of unsubs) u()
   })
@@ -279,18 +464,42 @@ function QuotaSidebar(props: { api: TuiPluginApi }) {
   const hasData = () =>
     state().main.quota != null || enabledFallbacks().length > 0
 
-  const headerLabel = () =>
-    !hasData() ? 'CLAUDE' : collapsed() ? '\u25b6 CLAUDE' : '\u25bc CLAUDE'
+  const headerLabel = () => {
+    const name = prefs().header.label
+    return !hasData() ? name : collapsed() ? `\u25b6 ${name}` : `\u25bc ${name}`
+  }
   const activeAccount = () => resolveActiveAccount(state())
   const activeQuotaSummary = () =>
     getCollapsedQuotaSummary(activeAccount().quota)
+  const activePacingDeficit = () => {
+    if (!prefs().sections.pacing) return false
+    const quota = activeAccount().quota
+    if (!quota) return false
+    const now = Date.now()
+    const windows: Array<[typeof quota.five_hour, number]> = [
+      [quota.five_hour, FIVE_HOUR_MS],
+      [quota.seven_day, SEVEN_DAY_MS],
+    ]
+    return windows.some(
+      ([w, ms]) =>
+        w != null && computeQuotaPacing(w, ms, now)?.state === 'deficit',
+    )
+  }
   const activeQuotaTone = (): Tone => {
     const summary = activeQuotaSummary()
     const values = [
       summary.fiveHourUsedPercent,
       summary.sevenDayUsedPercent,
     ].filter((value): value is number => value != null)
-    return values.length > 0 ? usageTone(Math.max(...values)) : 'muted'
+    // Pacing deficit is an advisory projection, not actual quota exhaustion,
+    // so it can only BUMP the usage tone up to warn at most — never soften a
+    // real warn/err usage reading and never paint a true red.
+    const base: Tone =
+      values.length > 0
+        ? usageTone(Math.max(...values), prefs().appearance)
+        : 'muted'
+    if (!activePacingDeficit()) return base
+    return base === 'ok' || base === 'muted' ? 'warn' : base
   }
 
   const quotaBackedOff = () => state().main.quotaBackedOff === true
@@ -298,7 +507,8 @@ function QuotaSidebar(props: { api: TuiPluginApi }) {
   const degraded = () => quotaBackedOff() || refreshBackedOff()
 
   const cacheKeep = () => state().cacheKeep
-  const showCache = () => cacheKeep() != null && cacheKeep()?.window != null
+  const showCache = () =>
+    prefs().sections.cache && cacheKeep() != null && cacheKeep()?.window != null
   const relayValue = () => {
     const r = state().relay
     if (!r) return '\u2014'
@@ -324,7 +534,7 @@ function QuotaSidebar(props: { api: TuiPluginApi }) {
         justifyContent='space-between'
         alignItems='center'
         onMouseDown={() => {
-          if (hasData()) setCollapsed((value) => !value)
+          if (hasData()) props.controller.toggleCollapsed()
         }}
       >
         <box paddingLeft={1} paddingRight={1} backgroundColor={theme().accent}>
@@ -335,7 +545,7 @@ function QuotaSidebar(props: { api: TuiPluginApi }) {
         <Show
           when={degraded()}
           fallback={
-            <Show when={PLUGIN_VERSION !== ''}>
+            <Show when={prefs().header.showVersion && PLUGIN_VERSION !== ''}>
               <text fg={theme().textMuted}>{`v${PLUGIN_VERSION}`}</text>
             </Show>
           }
@@ -385,46 +595,56 @@ function QuotaSidebar(props: { api: TuiPluginApi }) {
           }
         >
           {/* Quota */}
-          <SectionHeader theme={theme()} title='Quota' />
-          <AccountBlock
-            theme={theme()}
-            name='main'
-            quota={state().main.quota}
-            active={state().activeId === 'main'}
-          />
-          <For each={enabledFallbacks()}>
-            {(fb) => (
-              <AccountBlock
-                theme={theme()}
-                name={fb.label ?? fb.id}
-                quota={fb.quota}
-                active={state().activeId === fb.id}
-                marginTop={1}
-              />
-            )}
-          </For>
+          <Show when={prefs().sections.quota}>
+            <SectionHeader theme={theme()} title='Quota' />
+            <AccountBlock
+              theme={theme()}
+              appearance={prefs().appearance}
+              name='main'
+              quota={state().main.quota}
+              active={state().activeId === 'main'}
+              pacingEnabled={prefs().sections.pacing}
+            />
+            <Show when={prefs().sections.fallbackAccounts}>
+              <For each={enabledFallbacks()}>
+                {(fb) => (
+                  <AccountBlock
+                    theme={theme()}
+                    appearance={prefs().appearance}
+                    name={fb.label ?? fb.id}
+                    quota={fb.quota}
+                    active={state().activeId === fb.id}
+                    pacingEnabled={prefs().sections.pacing}
+                    marginTop={1}
+                  />
+                )}
+              </For>
+            </Show>
+          </Show>
         </Show>
 
         {/* Routing */}
-        <SectionHeader theme={theme()} title='Routing' />
-        <StatRow
-          theme={theme()}
-          label='Route'
-          value={state().route}
-          tone='accent'
-        />
-        <StatRow
-          theme={theme()}
-          label='Mode'
-          value={state().fastMode ? 'fast' : 'std'}
-          tone={state().fastMode ? 'accent' : 'muted'}
-        />
-        <StatRow
-          theme={theme()}
-          label='Relay'
-          value={relayValue()}
-          tone={state().relay?.enabled ? 'ok' : 'muted'}
-        />
+        <Show when={prefs().sections.routing}>
+          <SectionHeader theme={theme()} title='Routing' />
+          <StatRow
+            theme={theme()}
+            label='Route'
+            value={state().route}
+            tone='accent'
+          />
+          <StatRow
+            theme={theme()}
+            label='Mode'
+            value={state().fastMode ? 'fast' : 'std'}
+            tone={state().fastMode ? 'accent' : 'muted'}
+          />
+          <StatRow
+            theme={theme()}
+            label='Relay'
+            value={relayValue()}
+            tone={state().relay?.enabled ? 'ok' : 'muted'}
+          />
+        </Show>
 
         {/* Cache */}
         <Show when={showCache()}>
@@ -446,7 +666,7 @@ function QuotaSidebar(props: { api: TuiPluginApi }) {
         </Show>
 
         {/* Health — only when something is wrong */}
-        <Show when={degraded()}>
+        <Show when={degraded() && prefs().sections.health}>
           <SectionHeader theme={theme()} title='Health' />
           <Show when={quotaBackedOff()}>
             <StatRow
@@ -471,11 +691,13 @@ function QuotaSidebar(props: { api: TuiPluginApi }) {
 }
 
 const tui: TuiPlugin = async (api) => {
+  const root = await readTuiPreferencesFile()
+  const controller = createSidebarController(resolveAnthropicAuthPrefs(root))
   api.slots.register({
-    order: 160,
+    order: computeEffectiveOrder(root, PLUGIN_KEY, DEFAULT_SLOT_ORDER),
     slots: {
       sidebar_content(_ctx: unknown, _props: { session_id: string }) {
-        return <QuotaSidebar api={api} />
+        return <QuotaSidebar api={api} controller={controller} />
       },
     },
   })

package/dist/index-99mvcpj7.js

@@ -1,2 +0,0 @@
-import{mkdir as O,readFile as Q,writeFile as W}from"node:fs/promises";import{tmpdir as X}from"node:os";import{dirname as Y,join as K}from"node:path";var Z="OPENCODE_ANTHROPIC_AUTH_SIDEBAR_STATE_FILE",$=K(X(),"opencode-anthropic-auth"),x=K($,"sidebar-state.json");function M(){return process.env[Z]||x}var B={main:{quota:null},fallbacks:[],activeId:void 0,route:"main",relay:null,fastMode:!1,lastUpdated:0};async function h(){try{let G=await Q(M(),"utf8");return JSON.parse(G)}catch{return B}}async function j(G){try{let z=M();await O(Y(z),{recursive:!0}),await W(z,JSON.stringify(G),"utf8")}catch{}}function w(G){let z=G.activeId;if(z&&z!=="main"){let C=G.fallbacks.find((J)=>J.enabled&&J.id===z);if(C)return{id:C.id,name:C.label??C.id,quota:C.quota}}return{id:"main",name:"main",quota:G.main.quota}}function R(G){let z=G?.five_hour?.usedPercent??null,C=G?.seven_day?.usedPercent??null;if(z==null&&C==null)return{fiveHourUsedPercent:z,sevenDayUsedPercent:C,text:null};return{fiveHourUsedPercent:z,sevenDayUsedPercent:C,text:`5h: ${z==null?"—":`${Math.round(z)}%`} 7d: ${C==null?"—":`${Math.round(C)}%`}`}}
-export{M as Sa,B as Ta,h as Ua,j as Va,w as Wa,R as Xa};