@slkiser/opencode-quota 3.6.2 → 3.8.0

package/dist/tui.tsx

@@ -1,49 +1,113 @@
 /** @jsxImportSource @opentui/solid */
-import type { TuiPlugin, TuiPluginApi, TuiPluginModule } from "@opencode-ai/plugin/tui";
-import { createEffect, createSignal, onCleanup } from "solid-js";
+import type { JSX } from "@opentui/solid";
+import type {
+  TuiPlugin,
+  TuiPluginApi,
+  TuiPluginModule,
+  TuiPromptRef,
+} from "@opencode-ai/plugin/tui";
+import { Show, createEffect, createSignal, onCleanup } from "solid-js";
 
-import type { SidebarPanelState } from "./lib/tui-panel-state.js";
+import type { CompactStatusState, SidebarPanelState } from "./lib/tui-panel-state.js";
 
-import { getSidebarPanelLines, shouldRenderSidebarPanel } from "./lib/tui-panel-state.js";
+import {
+  getCompactStatusText,
+  getSidebarPanelLines,
+  shouldRenderCompactStatus,
+  shouldRenderSidebarPanel,
+} from "./lib/tui-panel-state.js";
 import { getSidebarBodyLineColor } from "./lib/tui-line-style.js";
-import { loadSidebarPanel } from "./lib/tui-runtime.js";
+import {
+  loadTuiHomeCompactStatus,
+  loadTuiSessionQuotaSurfaces,
+  resolveTuiSurfaceRegistration,
+} from "./lib/tui-runtime.js";
 
 const id = "@slkiser/opencode-quota";
 // Place Quota near the top so variable-height built-in sections
 // (MCP/LSP/Todo/Files) do not push it below the visible fold.
 const SIDEBAR_ORDER = 150;
+const COMPACT_ORDER = 90;
 const REFRESH_INTERVAL_MS = 60_000;
+const EVENT_REFRESH_DELAYS_MS = [150, 600] as const;
+const MOUNT_RECOVERY_DELAYS_MS = [500, 1_500, 4_000] as const;
 
-function SidebarContentView(props: {
-  api: TuiPluginApi;
+type TuiPromptRefCallback = (ref: TuiPromptRef | undefined) => void;
+
+type SessionQuotaResource = {
   sessionID: string;
-}) {
-  const [panel, setPanel] = createSignal<SidebarPanelState>({
+  sidebar: () => SidebarPanelState;
+  compact: () => CompactStatusState;
+  retain: () => SessionQuotaResource;
+  release: () => void;
+};
+
+type HomeCompactResource = {
+  compact: () => CompactStatusState;
+  retain: () => HomeCompactResource;
+  release: () => void;
+};
+
+const sessionResources = new WeakMap<TuiPluginApi, Map<string, SessionQuotaResource>>();
+const homeResources = new WeakMap<TuiPluginApi, HomeCompactResource>();
+
+function getSessionResourceMap(api: TuiPluginApi): Map<string, SessionQuotaResource> {
+  const existing = sessionResources.get(api);
+  if (existing) return existing;
+
+  const next = new Map<string, SessionQuotaResource>();
+  sessionResources.set(api, next);
+  return next;
+}
+
+function createSessionQuotaResource(api: TuiPluginApi, sessionID: string): SessionQuotaResource {
+  const [sidebar, setSidebar] = createSignal<SidebarPanelState>({
     status: "loading",
     lines: [],
   });
+  const [compact, setCompact] = createSignal<CompactStatusState>({ status: "loading" });
 
+  let refCount = 0;
   let disposed = false;
   let loadVersion = 0;
+  let inFlight = false;
+  let queued = false;
   const timers = new Set<ReturnType<typeof setTimeout>>();
 
   const reload = () => {
+    if (disposed) return;
+
+    if (inFlight) {
+      queued = true;
+      loadVersion += 1;
+      return;
+    }
+
+    inFlight = true;
     const currentVersion = ++loadVersion;
 
-    void loadSidebarPanel({
-      api: props.api,
-      sessionID: props.sessionID,
-    })
+    void loadTuiSessionQuotaSurfaces({ api, sessionID })
       .then((next) => {
         if (disposed || currentVersion !== loadVersion) return;
-        setPanel(next);
+        setSidebar(next.sidebar);
+        setCompact(next.compact);
       })
       .catch(() => {
         if (disposed || currentVersion !== loadVersion) return;
+      })
+      .finally(() => {
+        if (disposed) return;
+        inFlight = false;
+        if (queued) {
+          queued = false;
+          reload();
+        }
       });
   };
 
   const queueRefresh = (delay: number) => {
+    if (disposed) return;
+
     const timer = setTimeout(() => {
       timers.delete(timer);
       reload();
@@ -52,77 +116,299 @@ function SidebarContentView(props: {
   };
 
   const scheduleRefresh = () => {
-    queueRefresh(150);
-    queueRefresh(600);
+    for (const delay of EVENT_REFRESH_DELAYS_MS) queueRefresh(delay);
   };
 
   // TUI/session state can hydrate asynchronously after mount or session switch,
   // so retry a few times to recover from empty first-load reads.
   const scheduleMountRecovery = () => {
-    queueRefresh(500);
-    queueRefresh(1_500);
-    queueRefresh(4_000);
+    for (const delay of MOUNT_RECOVERY_DELAYS_MS) queueRefresh(delay);
   };
 
-  createEffect(() => {
-    props.sessionID;
-    reload();
-    scheduleMountRecovery();
-  });
-
   const interval = setInterval(reload, REFRESH_INTERVAL_MS);
   const unsubscribers = [
-    props.api.event.on("session.updated", (event) => {
-      if (event.properties?.info?.id === props.sessionID) {
+    api.event.on("session.updated", (event) => {
+      if (event.properties?.info?.id === sessionID) {
         scheduleRefresh();
       }
     }),
-    props.api.event.on("message.updated", (event) => {
-      if (event.properties?.info?.sessionID === props.sessionID) {
+    api.event.on("message.updated", (event) => {
+      if (event.properties?.info?.sessionID === sessionID) {
         scheduleRefresh();
       }
     }),
-    props.api.event.on("message.removed", (event) => {
-      if (event.properties?.sessionID === props.sessionID) {
+    api.event.on("message.removed", (event) => {
+      if (event.properties?.sessionID === sessionID) {
         scheduleRefresh();
       }
     }),
-    props.api.event.on("tui.session.select", (event) => {
-      if (event.properties?.sessionID === props.sessionID) {
+    api.event.on("tui.session.select", (event) => {
+      if (event.properties?.sessionID === sessionID) {
         scheduleRefresh();
       }
     }),
   ];
 
-  onCleanup(() => {
+  const dispose = () => {
+    if (disposed) return;
+
     disposed = true;
     clearInterval(interval);
     for (const timer of timers) clearTimeout(timer);
     timers.clear();
     for (const unsubscribe of unsubscribers) unsubscribe();
+    getSessionResourceMap(api).delete(sessionID);
+  };
+
+  const resource: SessionQuotaResource = {
+    sessionID,
+    sidebar,
+    compact,
+    retain: () => {
+      refCount += 1;
+      return resource;
+    },
+    release: () => {
+      refCount -= 1;
+      if (refCount <= 0) dispose();
+    },
+  };
+
+  reload();
+  scheduleMountRecovery();
+
+  return resource;
+}
+
+function acquireSessionQuotaResource(api: TuiPluginApi, sessionID: string): SessionQuotaResource {
+  const resources = getSessionResourceMap(api);
+  const existing = resources.get(sessionID);
+  if (existing) return existing.retain();
+
+  const next = createSessionQuotaResource(api, sessionID).retain();
+  resources.set(sessionID, next);
+  return next;
+}
+
+function createHomeCompactResource(api: TuiPluginApi): HomeCompactResource {
+  const [compact, setCompact] = createSignal<CompactStatusState>({ status: "loading" });
+
+  let refCount = 0;
+  let disposed = false;
+  let loadVersion = 0;
+  let inFlight = false;
+  let queued = false;
+  const timers = new Set<ReturnType<typeof setTimeout>>();
+
+  const reload = () => {
+    if (disposed) return;
+
+    if (inFlight) {
+      queued = true;
+      loadVersion += 1;
+      return;
+    }
+
+    inFlight = true;
+    const currentVersion = ++loadVersion;
+
+    void loadTuiHomeCompactStatus({ api })
+      .then((next) => {
+        if (disposed || currentVersion !== loadVersion) return;
+        setCompact(next);
+      })
+      .catch(() => {
+        if (disposed || currentVersion !== loadVersion) return;
+      })
+      .finally(() => {
+        if (disposed) return;
+        inFlight = false;
+        if (queued) {
+          queued = false;
+          reload();
+        }
+      });
+  };
+
+  const queueRefresh = (delay: number) => {
+    if (disposed) return;
+
+    const timer = setTimeout(() => {
+      timers.delete(timer);
+      reload();
+    }, delay);
+    timers.add(timer);
+  };
+
+  const scheduleRefresh = () => {
+    for (const delay of EVENT_REFRESH_DELAYS_MS) queueRefresh(delay);
+  };
+
+  const interval = setInterval(reload, REFRESH_INTERVAL_MS);
+  const unsubscribers = [
+    api.event.on("session.updated", scheduleRefresh),
+    api.event.on("message.updated", scheduleRefresh),
+    api.event.on("message.removed", scheduleRefresh),
+    api.event.on("tui.session.select", scheduleRefresh),
+  ];
+
+  const dispose = () => {
+    if (disposed) return;
+
+    disposed = true;
+    clearInterval(interval);
+    for (const timer of timers) clearTimeout(timer);
+    timers.clear();
+    for (const unsubscribe of unsubscribers) unsubscribe();
+    homeResources.delete(api);
+  };
+
+  const resource: HomeCompactResource = {
+    compact,
+    retain: () => {
+      refCount += 1;
+      return resource;
+    },
+    release: () => {
+      refCount -= 1;
+      if (refCount <= 0) dispose();
+    },
+  };
+
+  reload();
+
+  return resource;
+}
+
+function acquireHomeCompactResource(api: TuiPluginApi): HomeCompactResource {
+  const existing = homeResources.get(api);
+  if (existing) return existing.retain();
+
+  const next = createHomeCompactResource(api).retain();
+  homeResources.set(api, next);
+  return next;
+}
+
+function useSessionQuotaResource(api: TuiPluginApi, sessionID: () => string): () => SessionQuotaResource {
+  let current = acquireSessionQuotaResource(api, sessionID());
+  const [resource, setResource] = createSignal(current);
+
+  createEffect(() => {
+    const nextSessionID = sessionID();
+    if (current.sessionID === nextSessionID) return;
+
+    const previous = current;
+    current = acquireSessionQuotaResource(api, nextSessionID);
+    setResource(current);
+    previous.release();
   });
 
-  if (!shouldRenderSidebarPanel(panel())) return null;
+  onCleanup(() => {
+    current.release();
+  });
+
+  return resource;
+}
+
+function SidebarContentView(props: {
+  api: TuiPluginApi;
+  sessionID: string;
+}) {
+  const resource = useSessionQuotaResource(props.api, () => props.sessionID);
+  const panel = () => resource().sidebar();
 
   const lines = () => getSidebarPanelLines(panel());
 
   return (
-    <box gap={0}>
-      <text fg={props.api.theme.current.text}>
-        <b>Quota</b>
-      </text>
+    <Show when={shouldRenderSidebarPanel(panel())}>
       <box gap={0}>
-        {lines().map((line) => (
-          <text fg={getSidebarBodyLineColor(line, props.api.theme.current)} wrapMode="none">
-            {line || " "}
-          </text>
-        ))}
+        <text fg={props.api.theme.current.text}>
+          <b>Quota</b>
+        </text>
+        <box gap={0}>
+          {lines().map((line) => (
+            <text fg={getSidebarBodyLineColor(line, props.api.theme.current)} wrapMode="none">
+              {line || " "}
+            </text>
+          ))}
+        </box>
       </box>
+    </Show>
+  );
+}
+
+function CompactStatusLine(props: {
+  api: TuiPluginApi;
+  panel: () => CompactStatusState;
+  justifyContent: "flex-start" | "center" | "flex-end";
+  blankLineBefore?: boolean;
+}) {
+  const text = () => {
+    const panel = props.panel();
+    if (!shouldRenderCompactStatus(panel)) return "";
+    return getCompactStatusText(panel);
+  };
+
+  const line = () => (
+    <box flexDirection="row" justifyContent={props.justifyContent}>
+      <text fg={props.api.theme.current.textMuted} wrapMode="none">
+        {text()}
+      </text>
     </box>
   );
+
+  return (
+    <Show when={text()}>
+      <Show when={props.blankLineBefore} fallback={line()}>
+        <box gap={0}>
+          <text> </text>
+          {line()}
+        </box>
+      </Show>
+    </Show>
+  );
 }
 
-const tui: TuiPlugin = async (api) => {
+function SessionPromptWithCompactStatus(props: {
+  api: TuiPluginApi;
+  sessionID: string;
+  visible?: boolean;
+  disabled?: boolean;
+  onSubmit?: () => void;
+  promptRef?: TuiPromptRefCallback;
+}) {
+  const resource = useSessionQuotaResource(props.api, () => props.sessionID);
+  const panel = () => resource().compact();
+
+  return (
+    <box gap={0}>
+      <props.api.ui.Prompt
+        sessionID={props.sessionID}
+        visible={props.visible}
+        disabled={props.disabled}
+        onSubmit={props.onSubmit}
+        ref={props.promptRef}
+      />
+      <CompactStatusLine api={props.api} panel={panel} justifyContent="flex-end" />
+    </box>
+  );
+}
+
+function HomeCompactStatusView(props: { api: TuiPluginApi }) {
+  const resource = acquireHomeCompactResource(props.api);
+  onCleanup(() => resource.release());
+
+  return (
+    <CompactStatusLine
+      api={props.api}
+      panel={resource.compact}
+      justifyContent="center"
+      blankLineBefore
+    />
+  );
+}
+
+function registerSidebarSlots(api: TuiPluginApi): void {
   api.slots.register({
     order: SIDEBAR_ORDER,
     slots: {
@@ -131,6 +417,58 @@ const tui: TuiPlugin = async (api) => {
       },
     },
   });
+}
+
+const tui: TuiPlugin = async (api) => {
+  let surfaceRegistration;
+  try {
+    surfaceRegistration = await resolveTuiSurfaceRegistration(api);
+  } catch {
+    registerSidebarSlots(api);
+    return;
+  }
+
+  if (surfaceRegistration.sidebar.enabled) {
+    registerSidebarSlots(api);
+  }
+
+  const compactRegistration = surfaceRegistration.compact;
+  if (!compactRegistration.enabled) 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;
+      },
+    ) => (
+      <SessionPromptWithCompactStatus
+        api={api}
+        sessionID={props.session_id}
+        visible={props.visible}
+        disabled={props.disabled}
+        onSubmit={props.on_submit}
+        promptRef={props.ref}
+      />
+    );
+  }
+
+  if (compactRegistration.homeBottom) {
+    compactSlots.home_bottom = () => <HomeCompactStatusView api={api} />;
+  }
+
+  if (Object.keys(compactSlots).length > 0) {
+    api.slots.register({
+      order: COMPACT_ORDER,
+      slots: compactSlots,
+    });
+  }
 };
 
 const pluginModule: TuiPluginModule & { id: string } = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slkiser/opencode-quota",
-  "version": "3.6.2",
+  "version": "3.8.0",
   "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",