@slkiser/opencode-quota 4.5.1 → 4.6.1

package/dist/tui.tsx

@@ -8,18 +8,21 @@ import type {
 } from "@opencode-ai/plugin/tui";
 import type { JSX } from "@opentui/solid";
 import { createEffect, createSignal, onCleanup, Show } from "solid-js";
+import { formatDisplayedPercentLabel, formatResetCountdown } from "./lib/format-utils.js";
 import {
   buildQuotaDialogCommandOutput,
   QUOTA_DIALOG_COMMANDS,
   type QuotaDialogCommandId,
   type QuotaDialogCommandSpec,
 } from "./lib/quota-dialog-commands.js";
+import { extractSingleWindowWindowLabel } from "./lib/quota-entry-display.js";
 import type { SessionTokenError } from "./lib/quota-status.js";
 import { disposeQuotaTelemetryOwner } from "./lib/quota-telemetry.js";
 import { getSidebarBodyLineColor } from "./lib/tui-line-style.js";
 import type {
   CompactStatusState,
   HomeBottomState,
+  PromptBarState,
   SidebarPanelState,
 } from "./lib/tui-panel-state.js";
 import {
@@ -40,6 +43,8 @@ import {
   loadTuiSessionQuotaSurfaces,
   normalizeTuiSessionID,
   resolveTuiSurfaceRegistration,
+  type TuiInitialRuntimeSeed,
+  type TuiSurfaceRegistration,
   writeTuiQuotaExportIfEnabled,
 } from "./lib/tui-runtime.js";
 import type { TuiCommandDisplay } from "./lib/types.js";
@@ -63,6 +68,7 @@ type SessionQuotaResource = {
   sessionID: string;
   sidebar: () => SidebarPanelState;
   compact: () => CompactStatusState;
+  promptBar: () => PromptBarState;
   retain: () => SessionQuotaResource;
   release: () => void;
 };
@@ -73,6 +79,78 @@ type HomeBottomResource = {
   release: () => void;
 };
 
+type TuiInitialLoadCoordinator = {
+  takeInitialSession: () => TuiInitialRuntimeSeed | undefined;
+  takeInitialHome: () => TuiInitialRuntimeSeed | undefined;
+};
+
+type TuiRegistrationState =
+  | { status: "pending" }
+  | {
+      status: "active";
+      registration: TuiSurfaceRegistration;
+      initialLoads?: TuiInitialLoadCoordinator;
+    }
+  | { status: "disposed" };
+
+type TuiRegistrationGate = {
+  current: () => TuiRegistrationState;
+  activate: (
+    registration: TuiSurfaceRegistration,
+    initialLoads?: TuiInitialLoadCoordinator,
+  ) => void;
+  dispose: () => void;
+};
+
+const FALLBACK_SURFACE_REGISTRATION: TuiSurfaceRegistration = {
+  commandDisplay: "inline",
+  sidebar: { enabled: true },
+  compact: {
+    enabled: false,
+    homeBottom: false,
+    sessionPrompt: false,
+    hasNativeProviderQuota: false,
+    suppressedByNativeProviderQuota: false,
+  },
+  promptBar: { enabled: false },
+  announcements: { homeBottom: false },
+  homeBottom: false,
+};
+
+function createTuiInitialLoadCoordinator(seed: TuiInitialRuntimeSeed): TuiInitialLoadCoordinator {
+  let sessionAvailable = true;
+  let homeAvailable = true;
+
+  return {
+    takeInitialSession() {
+      if (!sessionAvailable) return undefined;
+      sessionAvailable = false;
+      return seed;
+    },
+    takeInitialHome() {
+      if (!homeAvailable) return undefined;
+      homeAvailable = false;
+      return seed;
+    },
+  };
+}
+
+function createTuiRegistrationGate(): TuiRegistrationGate {
+  const [current, setCurrent] = createSignal<TuiRegistrationState>({ status: "pending" });
+
+  return {
+    current,
+    activate(registration, initialLoads) {
+      if (current().status !== "pending") return;
+      setCurrent({ status: "active", registration, initialLoads });
+    },
+    dispose() {
+      if (current().status === "disposed") return;
+      setCurrent({ status: "disposed" });
+    },
+  };
+}
+
 const sessionResources = new WeakMap<TuiPluginApi, Map<string, SessionQuotaResource>>();
 const homeResources = new WeakMap<TuiPluginApi, HomeBottomResource>();
 
@@ -85,18 +163,33 @@ function getSessionResourceMap(api: TuiPluginApi): Map<string, SessionQuotaResou
   return next;
 }
 
-function createSessionQuotaResource(api: TuiPluginApi, sessionID: string): SessionQuotaResource {
+function createSessionQuotaResource(
+  api: TuiPluginApi,
+  sessionID: string,
+  initialLoads?: TuiInitialLoadCoordinator,
+): SessionQuotaResource {
   const [sidebar, setSidebar] = createSignal<SidebarPanelState>({
     status: "loading",
     lines: [],
   });
   const [compact, setCompact] = createSignal<CompactStatusState>({ status: "loading" });
+  const [promptBar, setPromptBar] = createSignal<PromptBarState>({ status: "loading" });
 
+  let loadOrdinal = 0;
   const lifecycle = createTuiRefreshLifecycle({
-    load: () => loadTuiSessionQuotaSurfaces({ api, sessionID }),
+    load: () => {
+      const initialRuntimeSeed = loadOrdinal === 0 ? initialLoads?.takeInitialSession() : undefined;
+      loadOrdinal += 1;
+      return loadTuiSessionQuotaSurfaces({
+        api,
+        sessionID,
+        ...(initialRuntimeSeed ? { initialRuntimeSeed } : {}),
+      });
+    },
     apply: (next) => {
       setSidebar(next.sidebar);
       setCompact(next.compact);
+      setPromptBar(next.promptBar ?? { status: "loading" });
     },
     intervalMs: REFRESH_INTERVAL_MS,
     eventRefreshDelaysMs: EVENT_REFRESH_DELAYS_MS,
@@ -134,6 +227,7 @@ function createSessionQuotaResource(api: TuiPluginApi, sessionID: string): Sessi
     sessionID,
     sidebar,
     compact,
+    promptBar,
     retain: () => {
       lifecycle.retain();
       return resource;
@@ -144,12 +238,16 @@ function createSessionQuotaResource(api: TuiPluginApi, sessionID: string): Sessi
   return resource;
 }
 
-function acquireSessionQuotaResource(api: TuiPluginApi, sessionID: string): SessionQuotaResource {
+function acquireSessionQuotaResource(
+  api: TuiPluginApi,
+  sessionID: string,
+  initialLoads?: TuiInitialLoadCoordinator,
+): SessionQuotaResource {
   const resources = getSessionResourceMap(api);
   const existing = resources.get(sessionID);
   if (existing) return existing.retain();
 
-  const next = createSessionQuotaResource(api, sessionID).retain();
+  const next = createSessionQuotaResource(api, sessionID, initialLoads).retain();
   resources.set(sessionID, next);
   return next;
 }
@@ -157,14 +255,23 @@ function acquireSessionQuotaResource(api: TuiPluginApi, sessionID: string): Sess
 function createHomeBottomResource(
   api: TuiPluginApi,
   compactHomeBottomEnabled: boolean,
+  initialLoads?: TuiInitialLoadCoordinator,
 ): HomeBottomResource {
   const [bottom, setBottom] = createSignal<HomeBottomState>({
     status: "loading",
     compact: compactHomeBottomEnabled ? { status: "loading" } : { status: "disabled" },
   });
 
+  let loadOrdinal = 0;
   const lifecycle = createTuiRefreshLifecycle({
-    load: () => loadTuiHomeBottomStatus({ api }),
+    load: () => {
+      const initialRuntimeSeed = loadOrdinal === 0 ? initialLoads?.takeInitialHome() : undefined;
+      loadOrdinal += 1;
+      return loadTuiHomeBottomStatus({
+        api,
+        ...(initialRuntimeSeed ? { initialRuntimeSeed } : {}),
+      });
+    },
     apply: setBottom,
     afterApply: () => {
       // Fire-and-forget: write export file if enabled. A failed write must
@@ -201,11 +308,12 @@ function createHomeBottomResource(
 function acquireHomeBottomResource(
   api: TuiPluginApi,
   compactHomeBottomEnabled: boolean,
+  initialLoads?: TuiInitialLoadCoordinator,
 ): HomeBottomResource {
   const existing = homeResources.get(api);
   if (existing) return existing.retain();
 
-  const next = createHomeBottomResource(api, compactHomeBottomEnabled).retain();
+  const next = createHomeBottomResource(api, compactHomeBottomEnabled, initialLoads).retain();
   homeResources.set(api, next);
   return next;
 }
@@ -213,8 +321,9 @@ function acquireHomeBottomResource(
 function useSessionQuotaResource(
   api: TuiPluginApi,
   sessionID: () => string,
+  initialLoads?: TuiInitialLoadCoordinator,
 ): () => SessionQuotaResource {
-  let current = acquireSessionQuotaResource(api, sessionID());
+  let current = acquireSessionQuotaResource(api, sessionID(), initialLoads);
   const [resource, setResource] = createSignal(current);
 
   createEffect(() => {
@@ -222,7 +331,7 @@ function useSessionQuotaResource(
     if (current.sessionID === nextSessionID) return;
 
     const previous = current;
-    current = acquireSessionQuotaResource(api, nextSessionID);
+    current = acquireSessionQuotaResource(api, nextSessionID, initialLoads);
     setResource(current);
     previous.release();
   });
@@ -234,8 +343,12 @@ function useSessionQuotaResource(
   return resource;
 }
 
-function SidebarContentView(props: { api: TuiPluginApi; sessionID: string }) {
-  const resource = useSessionQuotaResource(props.api, () => props.sessionID);
+function SidebarContentView(props: {
+  api: TuiPluginApi;
+  sessionID: string;
+  initialLoads?: TuiInitialLoadCoordinator;
+}) {
+  const resource = useSessionQuotaResource(props.api, () => props.sessionID, props.initialLoads);
   const panel = () => resource().sidebar();
 
   const lines = () => getSidebarPanelLines(panel());
@@ -319,12 +432,13 @@ function CompactStatusLine(props: {
 function SessionPromptWithCompactStatus(props: {
   api: TuiPluginApi;
   sessionID: string;
+  initialLoads?: TuiInitialLoadCoordinator;
   visible?: boolean;
   disabled?: boolean;
   onSubmit?: () => void;
   promptRef?: TuiPromptRefCallback;
 }) {
-  const resource = useSessionQuotaResource(props.api, () => props.sessionID);
+  const resource = useSessionQuotaResource(props.api, () => props.sessionID, props.initialLoads);
   const panel = () => resource().compact();
 
   return (
@@ -341,8 +455,176 @@ function SessionPromptWithCompactStatus(props: {
   );
 }
 
-function HomeBottomView(props: { api: TuiPluginApi; compactHomeBottomEnabled: boolean }) {
-  const resource = acquireHomeBottomResource(props.api, props.compactHomeBottomEnabled);
+const PROMPT_BAR_WIDTH = 12;
+
+function shouldRenderPromptBar(
+  bar: PromptBarState,
+): bar is Extract<PromptBarState, { status: "ready" }> {
+  return bar.status === "ready" && Boolean(bar.entry);
+}
+
+function useSessionRunning(api: TuiPluginApi, sessionID: () => string): () => boolean {
+  const [running, setRunning] = createSignal(false);
+  createEffect(() => {
+    const id = sessionID();
+    if (!id) {
+      setRunning(false);
+      return;
+    }
+    const update = () => {
+      try {
+        const sessionState = api.state.session as {
+          status?: (sessionID: string) => { type?: string } | undefined;
+        };
+        const status = sessionState.status?.(id);
+        setRunning(status?.type === "busy" || status?.type === "retry");
+      } catch {
+        setRunning(false);
+      }
+    };
+    update();
+    const disposers = [
+      api.event.on("session.status", (event) => {
+        if (event.properties?.sessionID === id) {
+          update();
+        }
+      }),
+      api.event.on("session.updated", (event) => {
+        if (event.properties?.info?.id === id) {
+          update();
+        }
+      }),
+    ];
+    onCleanup(() => {
+      for (const dispose of disposers) {
+        if (typeof dispose === "function") {
+          dispose();
+        }
+      }
+    });
+  });
+  return running;
+}
+
+function buildPromptBarParts(params: {
+  bar: () => PromptBarState;
+  running: () => boolean;
+  phase: () => number;
+}): { label: string; barText: string; meta: string } | undefined {
+  const bar = params.bar();
+  if (!shouldRenderPromptBar(bar)) return undefined;
+  const entry = bar.entry;
+  if (!entry) return undefined;
+  const windowLabel =
+    extractSingleWindowWindowLabel(entry.label ?? "") ??
+    extractSingleWindowWindowLabel(entry.name ?? "") ??
+    "Quota";
+  const percent = formatDisplayedPercentLabel(
+    entry.percentRemaining ?? 0,
+    bar.percentDisplayMode ?? "remaining",
+  );
+  const reset = entry.resetTimeIso
+    ? formatResetCountdown(entry.resetTimeIso, {
+        compactRounded: true,
+        decimals: bar.resetTimeDecimals,
+      })
+    : "";
+  const p = Math.max(0, Math.min(100, Math.round(entry.percentRemaining ?? 0)));
+  const filled = Math.round((p / 100) * PROMPT_BAR_WIDTH);
+  const empty = PROMPT_BAR_WIDTH - filled;
+  let barText = "█".repeat(filled) + "░".repeat(empty);
+  if (params.running() && filled > 0) {
+    const cells = Array(filled).fill("▓");
+    const center = params.phase() % filled;
+    const gradient = ["▒", "▓", "█", "▓", "▒"];
+    for (let offset = -2; offset <= 2; offset++) {
+      const position = (center + offset + filled) % filled;
+      cells[position] = gradient[offset + 2];
+    }
+    barText = cells.join("") + "░".repeat(empty);
+  }
+  return {
+    label: windowLabel,
+    barText,
+    meta: [percent.replace(/\s+left$/u, ""), reset].filter(Boolean).join(" | "),
+  };
+}
+
+function PromptQuotaHint(props: {
+  api: TuiPluginApi;
+  bar: () => PromptBarState;
+  running: () => boolean;
+  phase: () => number;
+}) {
+  const parts = () => buildPromptBarParts(props);
+  const barColor = () => props.api.theme.current.textMuted;
+  const label = () => parts()?.label ?? "";
+  const bar = () => parts()?.barText ?? "";
+  const meta = () => parts()?.meta ?? "";
+
+  return (
+    <Show when={parts()}>
+      <box flexDirection="row" justifyContent="flex-end" gap={1}>
+        <text fg={props.api.theme.current.textMuted} wrapMode="none">
+          {label()}
+        </text>
+        <text fg={barColor()} wrapMode="none">
+          {bar()}
+        </text>
+        <text fg={props.api.theme.current.textMuted} wrapMode="none">
+          {meta()}
+        </text>
+      </box>
+    </Show>
+  );
+}
+
+function SessionQuotaPromptBar(props: {
+  api: TuiPluginApi;
+  sessionID: string;
+  initialLoads?: TuiInitialLoadCoordinator;
+  visible?: boolean;
+  disabled?: boolean;
+  onSubmit?: () => void;
+  promptRef?: TuiPromptRefCallback;
+}) {
+  const resource = useSessionQuotaResource(props.api, () => props.sessionID, props.initialLoads);
+  const promptBar = () => resource().promptBar();
+  const running = useSessionRunning(props.api, () => props.sessionID);
+  const [phase, setPhase] = createSignal(0);
+  createEffect(() => {
+    if (!running() || !shouldRenderPromptBar(promptBar())) {
+      setPhase(0);
+      return;
+    }
+    const interval = setInterval(() => setPhase((p) => p + 1), 160);
+    onCleanup(() => clearInterval(interval));
+  });
+
+  return (
+    <box gap={0}>
+      <props.api.ui.Prompt
+        sessionID={props.sessionID}
+        visible={props.visible}
+        disabled={props.disabled}
+        onSubmit={props.onSubmit}
+        ref={props.promptRef}
+      />
+      <PromptQuotaHint api={props.api} bar={promptBar} running={running} phase={phase} />
+    </box>
+  );
+}
+
+function HomeBottomView(props: {
+  api: TuiPluginApi;
+  compactHomeBottomEnabled: boolean;
+  initialLoads?: TuiInitialLoadCoordinator;
+}) {
+  const resource = acquireHomeBottomResource(
+    props.api,
+    props.compactHomeBottomEnabled,
+    props.initialLoads,
+  );
   onCleanup(() => resource.release());
 
   const announcement = () => getHomeBottomAnnouncementText(resource.bottom());
@@ -566,7 +848,7 @@ async function runQuotaDialogCommandAsync(
   }
 }
 
-function registerQuotaDialogCommands(api: TuiPluginApi, commandDisplay: TuiCommandDisplay): void {
+function registerQuotaDialogCommands(api: TuiPluginApi, gate: TuiRegistrationGate): void {
   const commandState: QuotaDialogCommandState = {};
   const dispose = api.keymap.registerLayer({
     commands: QUOTA_DIALOG_COMMANDS.map((spec) => ({
@@ -577,7 +859,15 @@ function registerQuotaDialogCommands(api: TuiPluginApi, commandDisplay: TuiComma
       category: "OpenCode Quota",
       slashName: spec.slashName,
       run(input?: unknown) {
-        void runQuotaDialogCommandAsync(api, spec.id, commandDisplay, input, commandState);
+        const state = gate.current();
+        if (state.status !== "active") return;
+        void runQuotaDialogCommandAsync(
+          api,
+          spec.id,
+          state.registration.commandDisplay,
+          input,
+          commandState,
+        );
       },
     })),
     bindings: [],
@@ -586,12 +876,75 @@ function registerQuotaDialogCommands(api: TuiPluginApi, commandDisplay: TuiComma
   api.lifecycle.onDispose(dispose);
 }
 
-function registerSidebarSlots(api: TuiPluginApi): void {
+function registerStableTuiSlots(api: TuiPluginApi, current: () => TuiRegistrationState): void {
   api.slots.register({
     order: SIDEBAR_ORDER,
     slots: {
       sidebar_content(_ctx, props: { session_id: string }) {
-        return <SidebarContentView api={api} sessionID={props.session_id} />;
+        const state = current();
+        if (state.status !== "active" || !state.registration.sidebar.enabled) return null;
+        return (
+          <SidebarContentView
+            api={api}
+            sessionID={props.session_id}
+            initialLoads={state.initialLoads}
+          />
+        );
+      },
+    },
+  });
+
+  api.slots.register({
+    order: COMPACT_ORDER,
+    slots: {
+      session_prompt(
+        _ctx,
+        props: {
+          session_id: string;
+          visible?: boolean;
+          disabled?: boolean;
+          on_submit?: () => void;
+          ref?: TuiPromptRefCallback;
+        },
+      ) {
+        const state = current();
+        if (state.status !== "active") return null;
+        if (state.registration.promptBar.enabled) {
+          return (
+            <SessionQuotaPromptBar
+              api={api}
+              sessionID={props.session_id}
+              initialLoads={state.initialLoads}
+              visible={props.visible}
+              disabled={props.disabled}
+              onSubmit={props.on_submit}
+              promptRef={props.ref}
+            />
+          );
+        }
+        if (!state.registration.compact.sessionPrompt) return null;
+        return (
+          <SessionPromptWithCompactStatus
+            api={api}
+            sessionID={props.session_id}
+            initialLoads={state.initialLoads}
+            visible={props.visible}
+            disabled={props.disabled}
+            onSubmit={props.on_submit}
+            promptRef={props.ref}
+          />
+        );
+      },
+      home_bottom() {
+        const state = current();
+        if (state.status !== "active" || !state.registration.homeBottom) return null;
+        return (
+          <HomeBottomView
+            api={api}
+            compactHomeBottomEnabled={state.registration.compact.homeBottom}
+            initialLoads={state.initialLoads}
+          />
+        );
       },
     },
   });
@@ -599,74 +952,43 @@ function registerSidebarSlots(api: TuiPluginApi): void {
 
 async function initializeTuiRegistration(
   api: TuiPluginApi,
-  isDisposed: () => boolean,
+  gate: TuiRegistrationGate,
 ): Promise<void> {
-  let surfaceRegistration;
+  let initialRuntimeSeed: TuiInitialRuntimeSeed | undefined;
+  let surfaceRegistration: Promise<{
+    registration: TuiSurfaceRegistration;
+    initialRuntimeSeed?: TuiInitialRuntimeSeed;
+  }>;
   try {
-    surfaceRegistration = await resolveTuiSurfaceRegistration(api);
-  } catch {
-    if (isDisposed()) return;
-    registerQuotaDialogCommands(api, "inline");
-    registerSidebarSlots(api);
-    return;
-  }
-
-  if (isDisposed()) return;
-  registerQuotaDialogCommands(api, surfaceRegistration.commandDisplay);
-
-  if (surfaceRegistration.sidebar.enabled) {
-    registerSidebarSlots(api);
-  }
-
-  const compactRegistration = surfaceRegistration.compact;
-  if (!compactRegistration.enabled && !surfaceRegistration.homeBottom) return;
-
-  const compactSlots: Record<string, (ctx: any, props: any) => JSX.Element | null> = {};
-
-  if (compactRegistration.sessionPrompt) {
-    compactSlots.session_prompt = (
-      _ctx,
-      props: {
-        session_id: string;
-        visible?: boolean;
-        disabled?: boolean;
-        on_submit?: () => void;
-        ref?: TuiPromptRefCallback;
+    surfaceRegistration = resolveTuiSurfaceRegistration(api, {
+      captureInitialRuntime(seed) {
+        initialRuntimeSeed = seed;
       },
-    ) => (
-      <SessionPromptWithCompactStatus
-        api={api}
-        sessionID={props.session_id}
-        visible={props.visible}
-        disabled={props.disabled}
-        onSubmit={props.on_submit}
-        promptRef={props.ref}
-      />
-    );
-  }
-
-  if (surfaceRegistration.homeBottom) {
-    compactSlots.home_bottom = () => (
-      <HomeBottomView api={api} compactHomeBottomEnabled={surfaceRegistration.compact.homeBottom} />
-    );
+    })
+      .then((registration) => ({ registration, initialRuntimeSeed }))
+      .catch(() => ({ registration: FALLBACK_SURFACE_REGISTRATION }));
+  } catch {
+    surfaceRegistration = Promise.resolve({ registration: FALLBACK_SURFACE_REGISTRATION });
   }
 
-  if (Object.keys(compactSlots).length > 0) {
-    api.slots.register({
-      order: COMPACT_ORDER,
-      slots: compactSlots,
-    });
-  }
+  registerQuotaDialogCommands(api, gate);
+  void surfaceRegistration.then(({ registration, initialRuntimeSeed }) =>
+    gate.activate(
+      registration,
+      initialRuntimeSeed ? createTuiInitialLoadCoordinator(initialRuntimeSeed) : undefined,
+    ),
+  );
+  registerStableTuiSlots(api, gate.current);
 }
 
 const tui: TuiPlugin = async (api) => {
-  let disposed = false;
+  const registrationGate = createTuiRegistrationGate();
   api.lifecycle.onDispose(() => {
-    disposed = true;
+    registrationGate.dispose();
     disposeQuotaTelemetryOwner(createTuiQuotaClient(api));
   });
 
-  void initializeTuiRegistration(api, () => disposed).catch(() => {});
+  void initializeTuiRegistration(api, registrationGate).catch(() => {});
 };
 
 const pluginModule: TuiPluginModule & { id: string } = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slkiser/opencode-quota",
-  "version": "4.5.1",
+  "version": "4.6.1",
   "description": "OpenCode quota & tokens usage with zero context window pollution. Supports GitHub Copilot, OpenAI (Plus/Pro), Qwen Code, Chutes AI, Synthetic, Google Antigravity, Z.ai coding plan and more.",
   "type": "module",
   "main": "./dist/index.js",