@slkiser/opencode-quota 4.5.0 → 4.6.0

package/dist/tui.tsx

@@ -40,6 +40,8 @@ import {
   loadTuiSessionQuotaSurfaces,
   normalizeTuiSessionID,
   resolveTuiSurfaceRegistration,
+  type TuiInitialRuntimeSeed,
+  type TuiSurfaceRegistration,
   writeTuiQuotaExportIfEnabled,
 } from "./lib/tui-runtime.js";
 import type { TuiCommandDisplay } from "./lib/types.js";
@@ -73,6 +75,77 @@ 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,
+  },
+  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,15 +158,28 @@ 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" });
 
+  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);
@@ -144,12 +230,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 +247,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 +300,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 +313,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 +323,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 +335,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 +424,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 +447,16 @@ function SessionPromptWithCompactStatus(props: {
   );
 }
 
-function HomeBottomView(props: { api: TuiPluginApi; compactHomeBottomEnabled: boolean }) {
-  const resource = acquireHomeBottomResource(props.api, props.compactHomeBottomEnabled);
+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 +680,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 +691,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,76 +708,105 @@ 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}
+          />
+        );
       },
     },
   });
-}
 
-const tui: TuiPlugin = async (api) => {
-  api.lifecycle.onDispose(() => {
-    disposeQuotaTelemetryOwner(createTuiQuotaClient(api));
+  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" || !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}
+          />
+        );
+      },
+    },
   });
+}
 
-  let surfaceRegistration;
+async function initializeTuiRegistration(
+  api: TuiPluginApi,
+  gate: TuiRegistrationGate,
+): Promise<void> {
+  let initialRuntimeSeed: TuiInitialRuntimeSeed | undefined;
+  let surfaceRegistration: Promise<{
+    registration: TuiSurfaceRegistration;
+    initialRuntimeSeed?: TuiInitialRuntimeSeed;
+  }>;
   try {
-    surfaceRegistration = await resolveTuiSurfaceRegistration(api);
+    surfaceRegistration = resolveTuiSurfaceRegistration(api, {
+      captureInitialRuntime(seed) {
+        initialRuntimeSeed = seed;
+      },
+    })
+      .then((registration) => ({ registration, initialRuntimeSeed }))
+      .catch(() => ({ registration: FALLBACK_SURFACE_REGISTRATION }));
   } catch {
-    registerQuotaDialogCommands(api, "inline");
-    registerSidebarSlots(api);
-    return;
-  }
-
-  registerQuotaDialogCommands(api, surfaceRegistration.commandDisplay);
-
-  if (surfaceRegistration.sidebar.enabled) {
-    registerSidebarSlots(api);
+    surfaceRegistration = Promise.resolve({ registration: FALLBACK_SURFACE_REGISTRATION });
   }
 
-  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;
-      },
-    ) => (
-      <SessionPromptWithCompactStatus
-        api={api}
-        sessionID={props.session_id}
-        visible={props.visible}
-        disabled={props.disabled}
-        onSubmit={props.on_submit}
-        promptRef={props.ref}
-      />
-    );
-  }
+  registerQuotaDialogCommands(api, gate);
+  void surfaceRegistration.then(({ registration, initialRuntimeSeed }) =>
+    gate.activate(
+      registration,
+      initialRuntimeSeed ? createTuiInitialLoadCoordinator(initialRuntimeSeed) : undefined,
+    ),
+  );
+  registerStableTuiSlots(api, gate.current);
+}
 
-  if (surfaceRegistration.homeBottom) {
-    compactSlots.home_bottom = () => (
-      <HomeBottomView api={api} compactHomeBottomEnabled={surfaceRegistration.compact.homeBottom} />
-    );
-  }
+const tui: TuiPlugin = async (api) => {
+  const registrationGate = createTuiRegistrationGate();
+  api.lifecycle.onDispose(() => {
+    registrationGate.dispose();
+    disposeQuotaTelemetryOwner(createTuiQuotaClient(api));
+  });
 
-  if (Object.keys(compactSlots).length > 0) {
-    api.slots.register({
-      order: COMPACT_ORDER,
-      slots: compactSlots,
-    });
-  }
+  void initializeTuiRegistration(api, registrationGate).catch(() => {});
 };
 
 const pluginModule: TuiPluginModule & { id: string } = {

package/package.json

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