@cortexkit/opencode-openai-auth 1.1.0 → 1.3.0

package/src/tui-compiled/raw/shared/dc9290c2a7552ba6-watch.js

@@ -0,0 +1,253 @@
+/**
+ * While a vault watch is healthy, the roster is still read this often: the
+ * watch carries no history, so a lost notice or a silently dead stream is
+ * caught within this period.
+ */
+export const SAFETY_POLL_MS = 5 * 60_000;
+/**
+ * After a watch fails without being accepted, the host polls and tries one
+ * new watch this much later, so a refusing or draining module is never asked
+ * in a tight loop.
+ */
+export const WATCH_RETRY_MS = 5 * 60_000;
+/**
+ * First wait before re-subscribing a watch that closed after it had been
+ * accepted. It doubles for each further close in a row, up to WATCH_RETRY_MS.
+ */
+export const RESUBSCRIBE_BACKOFF_MS = 1_000;
+/**
+ * Tells whether a notice follows the previous one with nothing lost between
+ * them. `seq` restarts at 1 for every watch and `epoch` names the sending
+ * module's process lifetime. A sequence gap (notices are sheddable), a
+ * different epoch (the module restarted) or a notice of an unknown kind all
+ * mean changes may have been missed, so the caller must re-read everything.
+ */
+export class ChangeNoticeReader {
+    #epoch;
+    #seq = 0;
+    /**
+     * Begin a new watch, whose first notice is seq 1 again. The epoch is kept,
+     * so a module restart between two watches still reads as a break.
+     */
+    restart() {
+        this.#seq = 0;
+    }
+    continuous(notice) {
+        const continuous = notice.kind === 'changed' &&
+            notice.seq === this.#seq + 1 &&
+            (this.#epoch === undefined || notice.epoch === this.#epoch);
+        this.#epoch = notice.epoch;
+        this.#seq = notice.seq;
+        return continuous;
+    }
+}
+/**
+ * Runs `read` with at most one call in flight and at most one more queued
+ * behind it, however many requests arrive meanwhile. A request made while a
+ * read is running may have arrived after that read took its snapshot, so it
+ * earns exactly one more read; any further requests share that one.
+ */
+export class CoalescedRead {
+    #read;
+    #onError;
+    #running;
+    #queued = false;
+    constructor(read, onError) {
+        this.#read = read;
+        this.#onError = onError;
+    }
+    /** The read in flight (including its queued follow-up), if any. */
+    get running() {
+        return this.#running;
+    }
+    request() {
+        if (this.#running) {
+            this.#queued = true;
+            return this.#running;
+        }
+        this.#running = (async () => {
+            do {
+                this.#queued = false;
+                try {
+                    await this.#read();
+                }
+                catch (error) {
+                    this.#onError(error);
+                }
+            } while (this.#queued);
+        })().finally(() => {
+            this.#running = undefined;
+        });
+        return this.#running;
+    }
+}
+/**
+ * Keeps one vault `watchScoped` open for a host and runs the host's discovery
+ * when a notice shows the visible account list changed. Discovery runs only
+ * when the notice's view differs from the last discovered roster's view, when
+ * a notice shows a gap or a new epoch, or on the first notice of a watch that
+ * was re-subscribed after a close (the time between two watches was not
+ * observed). It never opens a second watch while one is open.
+ */
+export class ScopedRosterWatch {
+    #options;
+    #reader = new ChangeNoticeReader();
+    #reads;
+    #mode = 'polling';
+    #watch;
+    #timer;
+    #stopped = false;
+    #latestView;
+    #force = false;
+    /**
+     * How many accepted watches in a row have closed; each one doubles the wait
+     * before the next re-subscribe. Reset once a watch stays up five minutes.
+     */
+    #closes = 0;
+    constructor(options) {
+        this.#options = options;
+        this.#reads = new CoalescedRead(async () => {
+            const force = this.#force;
+            this.#force = false;
+            if (force || this.#latestView !== this.#options.view())
+                await this.#options.discover();
+        }, (error) => {
+            if (!this.#stopped)
+                this.#options.onError?.(error);
+        });
+    }
+    get mode() {
+        return this.#mode;
+    }
+    start() {
+        if (this.#stopped || this.#watch || this.#timer)
+            return;
+        if (typeof this.#options.client.watchScoped !== 'function') {
+            // A claustrum-client older than 0.12.0: poll exactly as before.
+            this.#setMode('fallback', 'client-without-watch');
+            return;
+        }
+        void this.#open(false);
+    }
+    stop() {
+        if (this.#stopped)
+            return;
+        this.#stopped = true;
+        if (this.#timer)
+            (this.#options.clearTimeoutImpl ?? clearTimeout)(this.#timer);
+        this.#timer = undefined;
+        const watch = this.#watch;
+        this.#watch = undefined;
+        watch?.handle.stop();
+    }
+    #setMode(mode, reason) {
+        if (this.#mode === mode)
+            return;
+        this.#mode = mode;
+        this.#options.logger?.debug('claustrum vault watch', { mode, reason });
+        this.#options.onMode?.(mode);
+    }
+    #later(delay, run) {
+        this.#timer = (this.#options.setTimeoutImpl ?? setTimeout)(() => {
+            this.#timer = undefined;
+            if (!this.#stopped)
+                run();
+        }, delay);
+        this.#timer.unref?.();
+    }
+    async #open(resubscribed) {
+        let token;
+        try {
+            token = await this.#options.enrollmentToken();
+        }
+        catch (error) {
+            if (this.#stopped)
+                return;
+            this.#options.onError?.(error);
+            this.#fallback('token-unreadable');
+            return;
+        }
+        const watchScoped = this.#options.client.watchScoped;
+        if (this.#stopped || this.#watch || !watchScoped)
+            return;
+        this.#reader.restart();
+        // A re-subscribed watch reads on its first notice: changes made while no
+        // watch was open were never announced.
+        this.#force = resubscribed;
+        let watch;
+        let handle;
+        try {
+            handle = watchScoped.call(this.#options.client, (notice) => {
+                if (this.#stopped || !watch || this.#watch !== watch)
+                    return;
+                watch.notices++;
+                if (watch.notices === 1) {
+                    this.#options.onReachable?.();
+                    watch.acceptedAt = (this.#options.now ?? Date.now)();
+                    this.#setMode('watching', 'accepted');
+                }
+                if (!this.#reader.continuous(notice))
+                    this.#force = true;
+                this.#latestView = notice.view;
+                // The read itself decides whether to list, against the roster as
+                // it stands when the read runs.
+                void this.#reads.request();
+            }, { enrollmentToken: token });
+        }
+        catch (error) {
+            this.#options.onError?.(error);
+            this.#fallback('watch-failed');
+            return;
+        }
+        watch = { handle, notices: 0 };
+        this.#watch = watch;
+        this.#setMode('polling', resubscribed ? 'resubscribing' : 'opening');
+        const opened = watch;
+        handle.closed.then((end) => this.#closed(opened, end), (error) => this.#closed(opened, { kind: 'transport_lost', error }));
+    }
+    #closed(watch, end) {
+        if (this.#stopped || this.#watch !== watch)
+            return;
+        this.#watch = undefined;
+        if (end.kind === 'stopped')
+            return;
+        if (end.kind === 'transport_lost')
+            this.#options.onTransportLost?.();
+        if (end.kind === 'unsupported') {
+            // An older vault answers unknown_method: poll exactly as before.
+            this.#setMode('fallback', 'vault-without-watch');
+            return;
+        }
+        if (end.kind === 'refused') {
+            this.#fallback('refused');
+            try {
+                this.#options.onRefused(end.error);
+            }
+            catch (error) {
+                this.#options.onError?.(error);
+            }
+            return;
+        }
+        if (watch.notices > 0) {
+            // An accepted watch that closed (the vault restarted, or a revocation
+            // ended it) gets one new watch. A revocation then shows up as that
+            // watch's refusal.
+            const now = (this.#options.now ?? Date.now)();
+            if (watch.acceptedAt !== undefined &&
+                now - watch.acceptedAt >= SAFETY_POLL_MS)
+                this.#closes = 0;
+            const delay = Math.min(RESUBSCRIBE_BACKOFF_MS * 2 ** Math.min(this.#closes, 16), WATCH_RETRY_MS);
+            this.#closes++;
+            this.#setMode('polling', 'resubscribing');
+            this.#later(delay, () => void this.#open(true));
+            return;
+        }
+        // Zero notices: the watch was never accepted (the vault is draining, or
+        // the connection failed). The client already made one read to learn why.
+        this.#fallback(end.kind);
+    }
+    #fallback(reason) {
+        this.#setMode('fallback', reason);
+        this.#later(WATCH_RETRY_MS, () => void this.#open(false));
+    }
+}

package/src/tui-compiled/raw/shared/e8d3c8da776ef9cd-index.js

@@ -6,13 +6,16 @@
 import { ClaustrumClient, } from "@cortexkit/claustrum-client";
 import { insulaUsageTransport } from "./d0f0b6be200311af-insula.js";
 export { ClaustrumCredentialError, } from "@cortexkit/claustrum-client";
+export { ClaustrumUnreachableError, classifyVaultFailure, VAULT_FAILURE_CLASSES, } from "./94f53cfd572ba4bb-availability.js";
 export { ClaustrumConsumer, } from "./169b2b4bf30909bc-consumer.js";
-export { ClaustrumScopedCustody, decideScopedRetryAfter401, isScopedCredentialRotation, SERVING_MARGIN_MS, } from "./0f77ebc3c914c9c6-custody.js";
+export { ClaustrumScopedCustody, decideScopedRetryAfter401, isScopedCredentialRotation, KEPT_RECEIPT_MARGIN_MS, SERVING_MARGIN_MS, } from "./0f77ebc3c914c9c6-custody.js";
 export { ClaustrumEnrollmentManager, classifyEnrollmentError, connectClaustrumEnrollmentClient, disconnectClaustrumEnrollment, enrollmentAuthority, enrollmentName, getClaustrumEnrollmentPaths, hostEnrollmentPaths, RETRYABLE_ENROLLMENT_CODES, readClaustrumEnrollmentStatus, readClaustrumEnrollmentToken, resetClaustrumEnrollmentState, TERMINAL_ENROLLMENT_CODES, } from "./b9588ad4725c1d10-enrollment.js";
 export { ClaustrumConsumerError, } from "./ca0fccaba1d87af4-errors.js";
 export { assertHostSlotMatchesMode, assertNotCustodyPlaceholder, CUSTODY_PLACEHOLDER_PREFIX, classifyHostSlot, custodyPlaceholder, custodyPlaceholderKey, isCustodyPlaceholder, isCustodyPlaceholderValue, } from "./d9d2892a4c371301-host-slot.js";
+export { acquireInsulaQuotaSource, } from "./d0f0b6be200311af-insula.js";
 export { acceptAccount, declineAccount, isDeclined, } from "./7c140680fc81be92-interlock.js";
 export { acceptVaultRoute, DEFAULT_ROUTE_PREFIX, declineVaultRoute, mutateVaultRoster, projectVaultRoster, readVaultRoster, recordVaultAccountQuota, recordVaultQuota, refreshVaultRoster, resolveVaultPrimary, vaultRoutingRows, } from "./30f5bc480f31f51c-roster.js";
+export { ChangeNoticeReader, RESUBSCRIBE_BACKOFF_MS, SAFETY_POLL_MS, ScopedRosterWatch, WATCH_RETRY_MS, } from "./dc9290c2a7552ba6-watch.js";
 /**
  * Connect the client that lists and fetches this consumer's vault credentials
  * on the request path. `connectionFile` is required: this library

package/src/tui-compiled/raw/sidebar-state.js

@@ -1,5 +1,6 @@
 import {
   formatQuota,
+  isQuotaStale,
   projectQuota,
   quotaWindowName
 } from "./shared/d5a8f1061ee2f114-index.js";
@@ -266,7 +267,7 @@ export function resolveSessionSidebarRouting(state, sessionId, now = Date.now())
 }
 function vaultAccountsInPlacementOrder(state) {
   const accounts = state.vaultAccounts ?? [], byId = new Map(accounts.map((account) => [account.id, account]));
-  return orderForPlacement(accounts.map((account) => account.id), state.route === "sticky-balanced" ? "roster" : orderedPlacement(state.route), vaultMainRouteId(accounts) ?? "").flatMap((id) => {
+  return orderForPlacement(accounts.map((account) => account.id), placementOf(state), vaultMainRouteId(accounts) ?? "").flatMap((id) => {
     const account = byId.get(id);
     return account ? [account] : [];
   });
@@ -962,6 +963,67 @@ export function getCollapsedQuotaSummary(quota, now = Date.now()) {
     text: !projection || projection.limits.length === 0 && !projection.budget ? null : formatQuota(projection, { now, form: "compact" })
   };
 }
+function placementOf(state) {
+  return state.route === "sticky-balanced" ? "roster" : orderedPlacement(state.route);
+}
+export function getCollapsedAccountLines(state, options = {}) {
+  const now = options.now ?? Date.now(), activeId = resolveActiveAccount(state).id;
+  return (state.vaultAccounts !== void 0 ? vaultAccountsInPlacementOrder(state).map((account) => ({
+    id: account.id,
+    name: account.label ?? account.id,
+    quota: account.quota,
+    killed: account.killed
+  })) : localAccountsInPlacementOrder(state, activeId, options.showFallbacks ?? !0)).map((account) => {
+    const projection = sidebarQuotaProjection(account.quota, now), reading = projection && (projection.limits.length > 0 || projection.budget) ? projection : void 0;
+    return {
+      id: account.id,
+      name: account.name,
+      killed: account.killed,
+      active: account.id === activeId,
+      stale: reading ? isQuotaStale(reading, { now }) : !1,
+      text: reading ? formatQuota(reading, { now, form: "narrow" }) : null
+    };
+  });
+}
+function localAccountsInPlacementOrder(state, activeId, showFallbacks) {
+  const accounts = [
+    {
+      id: "main",
+      name: "main",
+      quota: state.main.quota,
+      killed: state.main.killed
+    },
+    ...state.fallbacks.filter((account) => account.enabled && (showFallbacks || account.id === activeId)).map((account) => ({
+      id: account.id,
+      name: account.label ?? account.id,
+      quota: account.quota,
+      killed: account.killed
+    }))
+  ], byId = new Map(accounts.map((account) => [account.id, account]));
+  return orderForPlacement(accounts.map((account) => account.id), placementOf(state), "main").flatMap((id) => {
+    const account = byId.get(id);
+    return account ? [account] : [];
+  });
+}
+export function displayWidth(text) {
+  const bun = globalThis.Bun;
+  return bun?.stringWidth ? bun.stringWidth(text) : Array.from(text).length;
+}
+export function fitCollapsedLabel(label, columns) {
+  if (displayWidth(label) <= columns)
+    return label;
+  if (columns < 1)
+    return "";
+  let kept = "", used = 0;
+  for (const char of label) {
+    const width = displayWidth(char);
+    if (used + width > columns - 1)
+      break;
+    kept += char;
+    used += width;
+  }
+  return `${kept}\u2026`;
+}
 const PACING_MIN_ELAPSED_MS = 300000, PACING_MIN_ELAPSED_FRACTION = 0.01, ON_PACE_DELTA = 1;
 export function computeQuotaPacing(window, windowMs, now) {
   if (!window.resetsAt)

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

@@ -18,7 +18,7 @@ import {
   createEffect,
   createSignal,
   For,
-  type JSX,
+  Index,
   onCleanup,
   Show,
 } from "solid-js"
@@ -28,8 +28,12 @@ import { createRpcClient } from "./rpc/rpc-client.js"
 import { resolveRpcDir } from "./rpc/rpc-dir.js"
 import {
   type AccountQuota,
+  type CollapsedAccountLine,
   computeQuotaPacing,
   DEFAULT_SIDEBAR_STATE,
+  displayWidth,
+  fitCollapsedLabel,
+  getCollapsedAccountLines,
   getCollapsedQuotaSummary,
   getPresentQuotaWindows,
   getSidebarState,
@@ -250,17 +254,72 @@ function StatRow(props: {
   )
 }
 
-// Compact row for the collapsed view: muted label left, caller-provided value
-// right. Mirrors StatRow's layout so columns line up.
-function CollapsedRow(props: {
+// 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
+// drawn muted. The row measures its own width so only the label is cut (with
+// …) when the line does not fit; the quota text is never cut.
+function CollapsedAccountRow(props: {
   theme: ThemeCurrent
-  label: string
-  children: JSX.Element
+  line: CollapsedAccountLine
+  tone: Tone
 }) {
+  const [width, setWidth] = createSignal(0)
+  let row: { width: number } | undefined
+  const dim = () => props.line.stale || !props.line.active
+  const label = () => {
+    const columns = width()
+    if (columns <= 0) return props.line.name
+    // The value side is the text plus ` ●`, or a lone `—`; one column
+    // separates it from the label.
+    const value =
+      props.line.text === null ? 1 : displayWidth(props.line.text) + 2
+    return fitCollapsedLabel(props.line.name, columns - value - 1)
+  }
   return (
-    <box width='100%' flexDirection='row' justifyContent='space-between'>
-      <text fg={props.theme.textMuted}>{props.label}</text>
-      {props.children}
+    <box
+      ref={(element: { width: number }) => {
+        row = element
+      }}
+      onSizeChange={() => setWidth(row?.width ?? 0)}
+      width='100%'
+      flexDirection='row'
+      justifyContent='space-between'
+    >
+      <text
+        fg={toneColor(props.theme, dim() ? 'muted' : 'text')}
+        wrapMode='none'
+        flexShrink={1}
+      >
+        {label()}
+      </text>
+      <Show
+        when={props.line.text !== null}
+        fallback={<text fg={props.theme.textMuted}>{'\u2014'}</text>}
+      >
+        <box flexDirection='row' flexShrink={0}>
+          <Show
+            when={!dim()}
+            fallback={
+              <text fg={toneColor(props.theme, 'muted')}>
+                {props.line.text}
+              </text>
+            }
+          >
+            <text fg={toneColor(props.theme, props.tone)}>
+              <b>{props.line.text}</b>
+            </text>
+          </Show>
+          <text
+            fg={toneColor(
+              props.theme,
+              props.line.killed ? 'err' : dim() ? 'muted' : props.tone,
+            )}
+          >
+            {props.line.killed ? ' \u2298' : ' \u25cf'}
+          </text>
+        </box>
+      </Show>
     </box>
   )
 }
@@ -823,6 +882,10 @@ function QuotaSidebar(props: {
     route: sessionRouting().route,
   })
   const activeAccount = () => resolveActiveAccount(sessionState())
+  const collapsedLines = () =>
+    getCollapsedAccountLines(sessionState(), {
+      showFallbacks: prefs().sections.fallbackAccounts,
+    })
   const quotaLabelWidth = () => computeQuotaLabelWidth(renderedQuotas(state()))
   const activeQuotaSummary = () =>
     getCollapsedQuotaSummary(activeAccount().quota)
@@ -910,28 +973,17 @@ function QuotaSidebar(props: {
         </Show>
       </box>
 
-      {/* Collapsed: active account's present quota windows + dot (red ⊘ when killed) */}
+      {/* Collapsed: one line per account, narrow quota text + dot (red ⊘ when killed) */}
       <Show when={collapsed() && hasData()}>
-        <CollapsedRow theme={theme()} label={activeAccount().name}>
-          <Show
-            when={activeQuotaSummary().text != null}
-            fallback={<text fg={theme().textMuted}>{'\u2014'}</text>}
-          >
-            <box flexDirection='row'>
-              <text fg={toneColor(theme(), activeQuotaTone())}>
-                <b>{activeQuotaSummary().text}</b>
-              </text>
-              <text
-                fg={toneColor(
-                  theme(),
-                  activeAccount().killed ? 'err' : activeQuotaTone(),
-                )}
-              >
-                {activeAccount().killed ? ' \u2298' : ' \u25cf'}
-              </text>
-            </box>
-          </Show>
-        </CollapsedRow>
+        <Index each={collapsedLines()}>
+          {(line) => (
+            <CollapsedAccountRow
+              theme={theme()}
+              line={line()}
+              tone={activeQuotaTone()}
+            />
+          )}
+        </Index>
       </Show>
 
       {/* Expanded: full sections. Also render when there's no data so the