@cortexkit/opencode-openai-auth 1.3.0 → 1.5.0

package/src/tui-compiled/raw/tui.tsx

@@ -16,6 +16,7 @@ import type {
 } from "@opencode-ai/plugin/tui"
 import {
   createEffect,
+  createMemo,
   createSignal,
   For,
   Index,
@@ -28,6 +29,8 @@ import { createRpcClient } from "./rpc/rpc-client.js"
 import { resolveRpcDir } from "./rpc/rpc-dir.js"
 import {
   type AccountQuota,
+  accountCreditsText,
+  accountServesOnCredits,
   type CollapsedAccountLine,
   computeQuotaPacing,
   DEFAULT_SIDEBAR_STATE,
@@ -254,6 +257,45 @@ function StatRow(props: {
   )
 }
 
+// One of an account's own rows under its quota bars (budget amounts, prepaid
+// credits, reset credits): muted label left, value right. Like the quota rows
+// it stays on one line: it measures its own width and, when both do not fit,
+// cuts only the label (with …), keeping one blank cell before the value.
+function AccountMetaRow(props: {
+  theme: ThemeCurrent
+  label: string
+  value: string
+}) {
+  const [width, setWidth] = createSignal(0)
+  let row: { width: number } | undefined
+  const label = () => {
+    const columns = width()
+    if (columns <= 0) return props.label
+    return fitCollapsedLabel(
+      props.label,
+      columns - displayWidth(props.value) - 1,
+    )
+  }
+  return (
+    <box
+      ref={(element: { width: number }) => {
+        row = element
+      }}
+      onSizeChange={() => setWidth(row?.width ?? 0)}
+      width='100%'
+      flexDirection='row'
+      justifyContent='space-between'
+    >
+      <text fg={props.theme.textMuted} wrapMode='none' flexShrink={1}>
+        {label()}
+      </text>
+      <text fg={props.theme.text} wrapMode='none' flexShrink={0}>
+        <b>{props.value}</b>
+      </text>
+    </box>
+  )
+}
+
 // One account in the collapsed view: label left; narrow quota text and the
 // status dot right (red ⊘ when killed). The session's account keeps the
 // usage tone; other accounts, and any account whose reading is stale, are
@@ -475,9 +517,6 @@ export function getQuotaMetadataRows(
 ): Array<{ label: string; value: string }> {
   const rows: Array<{ label: string; value: string }> = []
   if (state.planType) rows.push({ label: 'Plan', value: state.planType })
-  if (state.credits !== undefined) {
-    rows.push({ label: 'Credits', value: String(state.credits) })
-  }
   return rows
 }
 
@@ -499,9 +538,18 @@ export function formatSpendControlAmounts(
   return `${formatGroupedAmount(spendControl.used)} / ${formatGroupedAmount(spendControl.limit)} ${unit}`
 }
 
+/**
+ * The account's own rows under its quota bars: the workspace budget's amounts
+ * (`credits`), the prepaid credits (`prepaid`, worded by `accountCreditsText`)
+ * and the reset-credit count (`resets`), each only when known. While the
+ * account is serving the session on its prepaid credits (its free quota is
+ * used up), the prepaid row says so in place of its `prepaid` label.
+ */
 export function getAccountMetadataRows(
   resetCredits: number | undefined,
   spendControl?: SpendControlReading,
+  prepaidCredits?: string,
+  servingOnCredits = false,
 ): Array<{ label: string; value: string }> {
   const rows: Array<{ label: string; value: string }> = []
   if (spendControl) {
@@ -510,16 +558,64 @@ export function getAccountMetadataRows(
       value: formatSpendControlAmounts(spendControl),
     })
   }
+  if (prepaidCredits !== undefined) {
+    rows.push({
+      label: servingOnCredits ? 'serving on credits' : 'prepaid',
+      value: prepaidCredits,
+    })
+  }
   if (resetCredits !== undefined) {
     rows.push({ label: 'resets', value: String(resetCredits) })
   }
   return rows
 }
 
+/** The fewest cells a shortened quota bar keeps; below this it is dropped. */
+const MIN_QUOTA_BAR_CELLS = 3
+
+export interface QuotaRowFit {
+  /** Cells of usage bar to draw; 0 draws no bar. */
+  barCells: number
+  showReset: boolean
+}
+
+/**
+ * How an expanded quota row fits on one line `columns` cells wide. The row is
+ * the padded label, the bar, the " N% left" figure and, at the right edge, the
+ * reset time. When it does not fit, the reset time goes first, then the bar
+ * shrinks (to no fewer than MIN_QUOTA_BAR_CELLS cells, else it is dropped).
+ * The label and the figure are never cut. `columns` of 0 means the row has not
+ * been measured yet, and everything is drawn.
+ */
+export function fitQuotaRow(input: {
+  columns: number
+  label: string
+  barWidth: number
+  figure: string
+  resetText?: string
+}): QuotaRowFit {
+  const { columns, barWidth } = input
+  const reset = input.resetText ? displayWidth(input.resetText) : 0
+  if (columns <= 0) return { barCells: barWidth, showReset: reset > 0 }
+  const fixed = displayWidth(input.label) + displayWidth(input.figure)
+  // The reset sits at the right edge with at least one blank cell before it,
+  // so it never runs into the figure.
+  if (reset > 0 && fixed + barWidth + 1 + reset <= columns)
+    return { barCells: barWidth, showReset: true }
+  const room = columns - fixed
+  if (room >= barWidth) return { barCells: barWidth, showReset: false }
+  return {
+    barCells: room >= MIN_QUOTA_BAR_CELLS ? room : 0,
+    showReset: false,
+  }
+}
+
 // Quota window row: muted label left, tone-colored usage bar and shared quota text.
 // 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.
+// The row measures its own width and never wraps: fitQuotaRow decides what is
+// left out when it is too narrow, and the pacing subline is cut with ….
 function QuotaRow(props: {
   theme: ThemeCurrent
   appearance: AppearancePrefs
@@ -531,6 +627,29 @@ function QuotaRow(props: {
   pacing: QuotaPacing | null
 }) {
   const used = () => props.window?.usedPercent ?? 0
+  const [columns, setColumns] = createSignal(0)
+  let row: { width: number } | undefined
+  const label = () => props.label.padEnd(props.labelWidth)
+  const figure = () => ` ${props.text.slice(props.label.length + 1)}`
+  const fit = () =>
+    fitQuotaRow({
+      columns: columns(),
+      label: label(),
+      barWidth: props.appearance.barWidth,
+      figure: figure(),
+      resetText: props.resetText,
+    })
+  // Memos, so a new measured width that leaves the fit unchanged (as the
+  // first measurement usually does) does not rebuild the bar's text nodes:
+  // rebuilt nodes are blank until the next frame is drawn.
+  const barCells = createMemo(() => fit().barCells)
+  const showReset = createMemo(() => fit().showReset)
+  const fittedPaceLine = () => {
+    const line = paceLine()
+    if (line === null || columns() <= 0) return line
+    // The subline is indented by the label column; cut it to the rest.
+    return fitCollapsedLabel(line, columns() - props.labelWidth)
+  }
   const paceLine = () => {
     const pacing = props.pacing
     if (!pacing || pacing.state === 'on-pace') return null
@@ -553,40 +672,64 @@ function QuotaRow(props: {
       }
     >
       {/* Bars show usage; the adjacent figure shows quota left, as in the dialog. */}
-      <box width='100%' flexDirection='row' justifyContent='space-between'>
-        <box flexDirection='row'>
-          <text fg={props.theme.textMuted}>
-            {props.label.padEnd(props.labelWidth)}
+      <box
+        ref={(element: { width: number }) => {
+          row = element
+        }}
+        onSizeChange={() => setColumns(row?.width ?? 0)}
+        width='100%'
+        flexDirection='row'
+        justifyContent='space-between'
+      >
+        <box flexDirection='row' flexShrink={0}>
+          <text fg={props.theme.textMuted} wrapMode='none'>
+            {label()}
           </text>
-          <For each={quotaBarSegments(used(), props.appearance, props.pacing)}>
+          <For
+            each={quotaBarSegments(
+              used(),
+              { ...props.appearance, barWidth: barCells() },
+              props.pacing,
+            )}
+          >
             {(segment) => (
-              <text fg={toneColor(props.theme, segment.tone)}>
+              <text fg={toneColor(props.theme, segment.tone)} wrapMode='none'>
                 {segment.text}
               </text>
             )}
           </For>
           <text
             fg={toneColor(props.theme, usageTone(used(), props.appearance))}
+            wrapMode='none'
           >
-            {` ${props.text.slice(props.label.length + 1)}`}
+            {figure()}
           </text>
         </box>
-        <Show when={props.resetText}>
-          <text fg={props.theme.textMuted}>{props.resetText}</text>
+        <Show when={showReset()}>
+          <text fg={props.theme.textMuted} wrapMode='none' flexShrink={0}>
+            {props.resetText}
+          </text>
         </Show>
       </box>
-      <Show when={paceLine()}>
-        <box width='100%' flexDirection='row'>
-          <text fg={props.theme.textMuted}>{''.padEnd(props.labelWidth)}</text>
-          <text
-            fg={toneColor(
-              props.theme,
-              props.pacing?.state === 'deficit' ? 'warn' : 'muted',
-            )}
-          >
-            {paceLine()}
-          </text>
-        </box>
+      {/* Keyed, so a cut to a new width draws a new text node: on Bun 1.3
+          an existing node kept drawing the text it was created with. */}
+      <Show when={fittedPaceLine()} keyed>
+        {(line) => (
+          <box width='100%' flexDirection='row'>
+            <text fg={props.theme.textMuted}>
+              {''.padEnd(props.labelWidth)}
+            </text>
+            <text
+              fg={toneColor(
+                props.theme,
+                props.pacing?.state === 'deficit' ? 'warn' : 'muted',
+              )}
+              wrapMode='none'
+            >
+              {line}
+            </text>
+          </box>
+        )}
       </Show>
     </Show>
   )
@@ -672,14 +815,15 @@ function AccountBlock(props: {
         each={getAccountMetadataRows(
           props.resetCredits,
           props.quota?.spendControl,
+          accountCreditsText(props.quota),
+          props.active && accountServesOnCredits(props.quota, Date.now()),
         )}
       >
         {(row) => (
-          <StatRow
+          <AccountMetaRow
             theme={props.theme}
             label={row.label}
             value={row.value}
-            tone='text'
           />
         )}
       </For>

package/src/tui-compiled/runtime/shared/0332701351b3eeec-format.js

@@ -106,6 +106,25 @@ export function quotaWindowParts(quota, options) {
     const parts = windows.map(({ part }) => part);
     return age === undefined ? { windows: parts } : { windows: parts, age };
 }
+/**
+ * The narrow label of each scoped window part, as `narrowTextParts` names
+ * them: model short names are worked out over every model-scoped window in
+ * the reading, so two models never share a short name.
+ */
+function withShortNames(windows) {
+    const abbreviations = scopeAbbreviations(windows
+        .filter(({ part, scope }) => part.kind === 'window' && scope !== ALL_SCOPE)
+        .map(({ scope }) => scope));
+    for (const window of windows) {
+        window.part.short =
+            window.part.kind === 'budget'
+                ? 'cr'
+                : window.scope === ALL_SCOPE
+                    ? window.part.name
+                    : (abbreviations.get(window.scope) ?? window.scope);
+    }
+    return windows;
+}
 /**
  * `quotaWindowParts` with each window's scope kept beside it. The narrow form
  * needs the scope to name and pick model-scoped windows; the public parts do
@@ -128,6 +147,7 @@ function scopedWindowParts(quota, options) {
             part: {
                 kind: 'window',
                 name: quotaWindowName(limit),
+                short: '',
                 figure: percentLeft(limit.remainingPercent ?? 0),
                 remainingPercent,
                 checkedAt: limit.checkedAt,
@@ -149,6 +169,7 @@ function scopedWindowParts(quota, options) {
             part: {
                 kind: 'budget',
                 name: 'credits',
+                short: '',
                 figure,
                 ...(remainingPercent === undefined
                     ? {}
@@ -158,6 +179,7 @@ function scopedWindowParts(quota, options) {
             },
         });
     }
+    withShortNames(windows);
     if (windows.length > 0) {
         const age = now - Math.min(...windows.map(({ part }) => part.checkedAt));
         if (age > (options.staleAfterMs ?? QUOTA_STALE_AFTER_MS)) {
@@ -298,20 +320,21 @@ function narrowTextParts(quota, options) {
         return grouped;
     const general = windows.filter(({ part, scope }) => part.kind === 'window' && scope === ALL_SCOPE);
     const scoped = windows.filter(({ part, scope }) => part.kind === 'window' && scope !== ALL_SCOPE);
-    const abbreviations = scopeAbbreviations(scoped.map(({ scope }) => scope));
     // The items competing for the one slot after the account-wide windows, in
     // tie-break order: scoped windows in display order, then the budget. A
     // spent budget counts as 0% left; one without a percentage cannot compete.
+    // Their labels are the parts' short names, so the narrow line and a layout
+    // reading `short` always agree.
     const budget = windows.find(({ part }) => part.kind === 'budget');
     const budgetLeft = budget?.spent ? 0 : budget?.part.remainingPercent;
     const extras = [
-        ...scoped.map(({ scope, part }) => ({
-            label: abbreviations.get(scope) ?? scope,
+        ...scoped.map(({ part }) => ({
+            label: part.short,
             remaining: part.remainingPercent ?? 0,
         })),
-        ...(budgetLeft === undefined
+        ...(budgetLeft === undefined || budget === undefined
             ? []
-            : [{ label: 'cr', remaining: budgetLeft }]),
+            : [{ label: budget.part.short, remaining: budgetLeft }]),
     ];
     // Strictly lower wins, so on a tie the earlier item keeps the slot.
     const tightest = extras.reduce((best, item) => best === undefined || item.remaining < best.remaining ? item : best, undefined);
@@ -357,3 +380,25 @@ export function formatQuota(quota, options) {
         ? NO_LIMITS_REPORTED
         : NO_QUOTA_READING;
 }
+/**
+ * Prepaid credits as one short value, worded as the official Codex client's
+ * status view words them: `Unlimited` for unlimited credits, `<n> credits`
+ * for a finite positive balance (rounded to a whole number), `Available` when
+ * the account has credits but no usable balance was reported, and undefined
+ * when the account has no credits (or `credits` is undefined), so a caller
+ * shows no credits row at all. Unlimited wins even when `hasCredits` is false.
+ * No other formatter adds this text; a caller that wants a credits row asks
+ * for it.
+ */
+export function quotaCreditsText(credits) {
+    if (credits === undefined)
+        return undefined;
+    if (credits.unlimited)
+        return 'Unlimited';
+    if (!credits.hasCredits)
+        return undefined;
+    const { balance } = credits;
+    return typeof balance === 'number' && Number.isFinite(balance) && balance > 0
+        ? `${Math.round(balance)} credits`
+        : 'Available';
+}

package/src/tui-compiled/runtime/shared/0f77ebc3c914c9c6-custody.js

@@ -4,6 +4,7 @@ import { ClaustrumUnreachableError, classifyVaultFailure, } from "./94f53cfd572b
 import { readClaustrumEnrollmentToken } from "./b9588ad4725c1d10-enrollment.js";
 import { ClaustrumConsumerError } from "./ca0fccaba1d87af4-errors.js";
 import { CUSTODY_PLACEHOLDER_PREFIX } from "./d9d2892a4c371301-host-slot.js";
+import { ScopedRosterWatch, } from "./dc9290c2a7552ba6-watch.js";
 /** Only a new version of the same account may replace an in-flight 401. */
 export function isScopedCredentialRotation(served, current) {
     return (current !== undefined &&
@@ -132,6 +133,9 @@ export class ClaustrumScopedCustody {
     #lastProbeAt = -Infinity;
     #probeDelay = 2_000;
     #closed = false;
+    /** The view of the last successful `discover()`, for `watchRoster`. */
+    #discoveredView;
+    #watches = new Set();
     constructor(options) {
         const tokenPath = options.tokenPath;
         if (options.readToken) {
@@ -197,7 +201,9 @@ export class ClaustrumScopedCustody {
         this.#probing = true;
         // Both triggers share list_scoped discovery, including its receipt-drop rules.
         // Sends never await discovery or let idle backoff delay the next send probe.
-        void this.discover()
+        // A probe commits no roster, so it is not the host's discovery and does
+        // not move the view a roster watch compares notices against.
+        void this.#list()
             .catch(() => {
             if (idle && this.#outage)
                 this.#probeDelay = Math.min(this.#probeDelay * 2, 30_000);
@@ -271,6 +277,11 @@ export class ClaustrumScopedCustody {
      * skipped records: they simply are not this consumer's.
      */
     async discover(signal) {
+        const inventory = await this.#list(signal);
+        this.#discoveredView = inventory.view;
+        return inventory;
+    }
+    async #list(signal) {
         let inventory;
         let token;
         try {
@@ -567,6 +578,61 @@ export class ClaustrumScopedCustody {
             throw error;
         }
     }
+    /**
+     * Watch this consumer's visible vault accounts instead of listing them on a
+     * short timer. Opens one `watchScoped` on this custody's client and calls
+     * `onView` when the host must run its discovery (see
+     * `ClaustrumRosterWatchOptions`). A claustrum-client without `watchScoped`
+     * (before 0.12.0) or a vault that answers `unknown_method` reports
+     * `fallback` and opens nothing. A watch that closes before any notice was
+     * never accepted: the client reads once to learn why, and the watch reports
+     * `fallback` and tries one new watch after `WATCH_RETRY_MS`, never in a
+     * loop. A watch that closes after notices is re-opened after
+     * `RESUBSCRIBE_BACKOFF_MS`, doubling per close in a row. A lost transport
+     * starts this custody's outage, exactly as an unreachable call does, and
+     * the first notice of a watch ends it. Timers are unreferenced; `close()`
+     * on the returned watch or on this custody stops it.
+     *
+     * The watch keeps no history, so the host still lists on a slow timer while
+     * the mode is `watching`: every `SAFETY_POLL_MS` (five minutes). In any
+     * other mode the host keeps its usual list timer.
+     */
+    watchRoster(options) {
+        this.#check();
+        const watch = new ScopedRosterWatch({
+            client: this.#client,
+            enrollmentToken: () => this.#token(),
+            view: options.view ?? (() => this.#discoveredView),
+            discover: async (view) => {
+                await options.onView(view);
+            },
+            onRefused: (error) => {
+                // Apply a refused watch as discover() applies a refused account
+                // listing: every kept receipt is dropped.
+                this.listFailed(error);
+                options.onRefused?.(error);
+            },
+            onTransportLost: () => this.transportLost(),
+            onReachable: () => this.reachable(),
+            onError: options.onError,
+            onMode: options.onMode,
+            logger: this.#logger,
+            now: this.#now,
+            setTimeoutImpl: this.#setTimeout,
+            clearTimeoutImpl: this.#clearTimeout,
+        });
+        this.#watches.add(watch);
+        watch.start();
+        return {
+            get mode() {
+                return watch.mode;
+            },
+            close: () => {
+                this.#watches.delete(watch);
+                watch.stop();
+            },
+        };
+    }
     close() {
         if (this.#closed)
             return;
@@ -574,6 +640,9 @@ export class ClaustrumScopedCustody {
         if (this.#probeTimer)
             this.#clearTimeout(this.#probeTimer);
         this.#probeTimer = undefined;
+        for (const watch of this.#watches)
+            watch.stop();
+        this.#watches.clear();
         this.#kept.clear();
         this.#client.close();
     }