opencode-context-indicator 1.1.1 → 1.1.3

package/README.md

@@ -73,6 +73,10 @@ other          5.6k   12%
 updated 12:30:01
 ```
 
+> Requires a `file://` install from a path outside `node_modules`; on the npm
+> path the sidebar is auto-disabled. See
+> [Live sidebar: npm vs file:// install](#live-sidebar-npm-vs-file-install).
+
 ### Slash commands (V2)
 
 On OpenCode 2.x (Desktop **and** terminal TUI) the plugin registers two slash
@@ -192,6 +196,13 @@ back to a plain notice if needed.
   with no category data (no cache/snapshot and the fallback failed or ran out of
   budget) is tagged `no-data`; `ctx` / `model` / `updatedAt` still come from
   `state.json` / the live lookup, while its category cells stay `n/a`.
+* **The denominator survives a transient model-registry miss.** If the serving
+  instance's `ctx.model.list()` returns no usable limits (freshly loaded instance,
+  provider not yet registered, malformed payload), the window is recovered from
+  the `state.json` snapshot instead of degrading the `ctx` column to `?`; limits
+  are also seeded from the snapshot at startup, and the retry backs off
+  (30 s → 5 min, capped). A known `usable`/`limit`/`agent` is never overwritten
+  with `null` when another instance rewrites the snapshot.
 * Both commands append their payload to `context-breakdown.log` (final-summaries
   section), so it stays recoverable even if delivery fails.
 * If `ctx.session.synthetic` throws, the command logs an actionable error and the
@@ -225,6 +236,9 @@ Notes — these reflect what the plugin API actually exposes today:
   therefore delivers everything through the log file, the TUI sidebar and the
   `/context` / `/context-breakdown` slash commands. The sidebar is a TUI-process
   slot and does not exist in the Desktop app; the slash commands work in **both**.
+  The TUI sidebar is **live only for a `file://` install** from a path outside
+  `node_modules`; on the npm path it is auto-disabled (upstream `#33884`) — see
+  [Live sidebar: npm vs file:// install](#live-sidebar-npm-vs-file-install).
 * **V1 has no sidebar and no slash command.** The command/slot API (and the
   `./tui` entry) is a V2 feature; OpenCode 1.x has no equivalent, so V1 is
   toast + log only.
@@ -275,13 +289,55 @@ or add it to `opencode.jsonc`:
 ```
 
 The `./tui` sidebar entry is loaded automatically alongside the main plugin in
-the terminal TUI. For a CLI-only setup against remote servers, the package can
-also be listed in [`cli.json`](https://opencode.ai/v2/docs/cli/plugins):
+the terminal TUI — but its live behaviour depends on the install method, see
+[Live sidebar: npm vs file:// install](#live-sidebar-npm-vs-file-install) below.
+For a CLI-only setup against remote servers, the package can also be listed in
+[`cli.json`](https://opencode.ai/v2/docs/cli/plugins):
 
 ```json
 { "plugins": ["opencode-context-indicator"] }
 ```
 
+### Live sidebar: npm vs file:// install
+
+The TUI sidebar is a **TUI-process slot**. On OpenCode 2.x it behaves
+differently depending on **how the plugin was installed** — an upstream OpenCode
+limitation (`anomalyco/opencode#33884`), not a plugin bug: OpenCode's TUI loader
+skips the host Solid transform for any path inside a `node_modules` directory, so
+a slot mounted from an npm install renders once and then never live-updates.
+
+| Install | Desktop | TUI commands | TUI live sidebar |
+| --- | :---: | :---: | :---: |
+| npm (`opencode plugin add opencode-context-indicator`) | ✅ | ✅ | ❌ auto-disabled (upstream #33884) |
+| `file://` (path **outside** any `node_modules`) | ✅ | ✅ | ✅ live |
+
+On the **npm** path the plugin detects that it lives under `node_modules` and
+**disables the sidebar gracefully** — it logs a single hint and registers no
+slot, so you never see a frozen "no data yet" panel. The `/context` /
+`/context-breakdown` slash commands and the breakdown log file keep working on
+every install.
+
+#### Getting the live sidebar (`file://` install)
+
+1. Put the package **outside** any `node_modules`: clone the repository, or
+   unpack the npm tarball (`npm pack opencode-context-indicator`, then extract
+   the `.tgz`) — e.g. into `C:\Users\you\plugins\opencode-context-indicator`.
+   Double-check that the chosen path contains **no `node_modules` segment**
+   (e.g. `C:\Users\you\plugins\...`, not `.../node_modules/...`).
+2. Point OpenCode at that directory in `~/.config/opencode/opencode.jsonc`:
+
+   ```jsonc
+   {
+     "plugins": ["file:///C:/Users/you/plugins/opencode-context-indicator"]
+   }
+   ```
+
+3. Restart OpenCode. The sidebar is now live and updates as context grows.
+
+> ⚠️ The `file://` path must **not** contain a `node_modules` segment. If it
+> does, OpenCode skips the Solid transform and the sidebar will not update; the
+> plugin auto-disables it and logs the hint above.
+
 ### OpenCode 1.x (V1)
 
 Add the package name to the `plugin` array in your `opencode.json`:
@@ -303,9 +359,11 @@ helper resolves. The `lib/` folder is support code, not a separate plugin entry:
 ~/.config/opencode/plugins/lib/dedup.js
 ```
 
-To use the sidebar locally as well, place `tui.tsx` where your OpenCode
-installation resolves the package's `./tui` entry (npm install is the
-recommended path for the sidebar).
+To use the sidebar locally as well, point OpenCode at a `file://` copy of the
+package that lives **outside any `node_modules`** (see
+[Live sidebar: npm vs file:// install](#live-sidebar-npm-vs-file-install)) — that
+is the only install path that keeps the sidebar live. An npm install auto-disables
+the sidebar instead.
 
 ---
 
@@ -322,9 +380,17 @@ recommended path for the sidebar).
 * **OpenCode ≥ 2.0.16** for the V2 path (built and verified against
   **2.0.19**).
 * **TUI sidebar**: terminal TUI only, requires the OpenTUI rendering stack that
-  ships with OpenCode (`@opentui/core`, `@opentui/solid`, `solid-js`). These are
-  declared as **optional** peer dependencies, so the main plugin installs and
-  runs fine without them (the sidebar simply is not available).
+  ships with OpenCode. `@opentui/core` and `solid-js` are **optional** peer
+  dependencies resolved by OpenCode at runtime; the main plugin installs and runs
+  fine without them (the sidebar simply is not available). `@opentui/solid` is
+  instead shipped as a **pinned direct dependency** (exact `0.5.12`): OpenCode's
+  TUI loader does not expose a host instance of it, so for npm-installed plugins
+  the JSX pragma would otherwise fail to resolve `@opentui/solid/jsx-runtime`
+  (upstream: opencode issue #33884 — `node_modules` plugins are excluded from the
+  host Solid transform and get an isolated OpenTUI copy). Because of that same
+  upstream limitation, on the **npm** path the sidebar is **auto-disabled**
+  (the plugin logs one hint and registers no slot) — use a `file://` install for
+  the live sidebar, see [Live sidebar: npm vs file:// install](#live-sidebar-npm-vs-file-install).
 
 ---
 

package/index.js

@@ -177,7 +177,8 @@ const CRITICAL_THROTTLE_MS = 10000; // min gap between critical (>90%) toasts
 const ERROR_TOAST_DEDUP_MS = 60000; // same error -> at most one toast / window
 const COMPACTED_TOAST_DEDUP_MS = 60000; // compacted-toast dedup window
 const PROVIDERS_TTL_MS = 5 * 60 * 1000; // providers()/model.list() cache TTL after SUCCESS
-const PROVIDERS_FAIL_TTL_MS = 30 * 1000; // retry-no-sooner gate after FAILURE
+const PROVIDERS_FAIL_TTL_MS = 30 * 1000; // retry-no-sooner base after FAILURE (doubles per consecutive miss)
+const V2_LIMITS_MAX_BACKOFF_MS = 5 * 60 * 1000; // cap for the model.list retry backoff
 const PROVIDERS_FETCH_TIMEOUT_MS = 2000; // hard cap for one providers() call (V1)
 const V2_MODEL_FETCH_TIMEOUT_MS = 8000; // hard cap for one ctx.model.list() call (V2)
 const TOAST_MS_ERROR = 8000; // duration for error / overflow toasts
@@ -278,6 +279,7 @@ let providersInFlight = null;
 // absolute tokens (as in V1).
 let v2LimitsLoadedAt = 0;
 let v2LimitsFailAt = 0;
+let v2LimitsFailCount = 0; // consecutive soft-failures -> exponential retry backoff
 let v2LimitsInFlight = null;
 
 // Bounded list of final summaries written on session.idle
@@ -472,6 +474,14 @@ function writeStateFile(
     const prevEntry = all[sessionID] || null;
     const pc = all[sessionID]?.categories || null;
 
+    // Same model AND provider? Only then is a previously persisted denominator
+    // meaningful — a session that switched model (or provider, even with the
+    // same modelID) must not inherit the old window.
+    const sameModelAsPrev =
+      prevEntry != null &&
+      prevEntry.model === (modelID || "unknown") &&
+      (prevEntry.providerID || "") === (providerID || "");
+
     const catUser = bd ? bd.userChars || 0 : pc?.user ?? 0;
     const catAssistant = bd ? bd.assistantChars || 0 : pc?.assistant ?? 0;
     const catReasoning = bd ? bd.reasoningChars || 0 : pc?.reasoning ?? 0;
@@ -504,13 +514,23 @@ function writeStateFile(
       sessionID,
       parentID,
       role: parentID ? "sub" : "main",
-      agent: sessionAgentCache.get(sessionID) || null,
+      agent: sessionAgentCache.get(sessionID) || prevEntry?.agent || null,
       model: modelID || "unknown",
       providerID: providerID || "",
       ctx: total,
       input: inputTokens || 0,
-      usable: denom,
-      limit: limit != null ? limit : null,
+      // Do NOT clobber a known denominator with null: multiple plugin instances
+      // share this file and one of them may lack modelLimits (its ctx.model.list
+      // returned nothing). Keep the previous model's known value when the live
+      // lookup came back empty, so a transient miss never becomes permanent.
+      usable:
+        denom != null ? denom : sameModelAsPrev ? prevEntry.usable ?? null : null,
+      limit:
+        limit != null
+          ? limit
+          : sameModelAsPrev && typeof prevEntry.limit === "number"
+            ? prevEntry.limit
+            : null,
       reasoning: typeof reasoningTokens === "number" ? reasoningTokens : 0,
       categories: {
         user: catUser,
@@ -1916,7 +1936,14 @@ async function ensureV2Breakdown(ctx, sessionID) {
 async function ensureModelLimits(ctx) {
   const now = Date.now();
   if (now - v2LimitsLoadedAt < PROVIDERS_TTL_MS) return; // fresh success
-  if (now - v2LimitsFailAt < PROVIDERS_FAIL_TTL_MS) return; // recent failure
+  // Recent failure: back off exponentially (30s, 60s, 120s … capped at 5 min)
+  // so a registry that is slow to expose the provider is retried without
+  // hammering it, while a one-off blip still recovers quickly.
+  const failBackoff = Math.min(
+    PROVIDERS_FAIL_TTL_MS * Math.pow(2, Math.max(0, v2LimitsFailCount - 1)),
+    V2_LIMITS_MAX_BACKOFF_MS,
+  );
+  if (now - v2LimitsFailAt < failBackoff) return; // recent failure
   if (v2LimitsInFlight) return v2LimitsInFlight; // dedup parallel callers
   v2LimitsInFlight = (async () => {
     try {
@@ -1927,7 +1954,13 @@ async function ensureModelLimits(ctx) {
       );
       const models = Array.isArray(res) ? res : res?.data;
       if (!Array.isArray(models)) {
+        v2LimitsFailCount++;
         v2LimitsFailAt = Date.now(); // malformed payload -> retry soon
+        const seeded = hydrateModelLimitsFromState();
+        logErr(
+          "model.list returned no model array — limits unavailable, will retry",
+          { payloadType: typeof res, hydratedFromState: seeded },
+        );
         return;
       }
       let found = 0;
@@ -1964,11 +1997,36 @@ async function ensureModelLimits(ctx) {
       // An empty / limit-less payload right after boot (registry not ready yet)
       // must NOT be cached as success, or limits would stay unknown for the
       // full TTL — treat it as a soft failure and retry after the fail gate.
-      if (found > 0) v2LimitsLoadedAt = Date.now();
-      else v2LimitsFailAt = Date.now();
+      if (found > 0) {
+        v2LimitsLoadedAt = Date.now();
+        v2LimitsFailCount = 0; // recovered
+      } else {
+        // Soft failure: the registry answered but carried no usable limit for
+        // any model (provider not registered yet, or `limit` absent). Log WHY
+        // once per backoff window, and fall back to the shared snapshot so
+        // denominators do not vanish meanwhile.
+        const withLimit = models.filter(
+          (m) => m?.limit && typeof m.limit === "object",
+        ).length;
+        const lanit = models.filter(
+          (m) => m?.providerID === "lanit" || m?.provider?.id === "lanit",
+        ).length;
+        const seeded = hydrateModelLimitsFromState();
+        v2LimitsFailCount++;
+        v2LimitsFailAt = Date.now();
+        logErr(
+          "model.list yielded 0 usable limits — retrying",
+          { models: models.length, withLimit, lanit, hydratedFromState: seeded },
+        );
+      }
     } catch (err) {
-      v2LimitsFailAt = Date.now(); // failed attempt -> short retry gate
-      logErr("model.list failed", err);
+      v2LimitsFailCount++;
+      v2LimitsFailAt = Date.now(); // failed attempt -> backoff gate
+      const seeded = hydrateModelLimitsFromState();
+      logErr(
+        `model.list failed (hydrated ${seeded} limit(s) from state.json)`,
+        err,
+      );
     } finally {
       v2LimitsInFlight = null;
     }
@@ -2377,6 +2435,56 @@ function readStateSnapshot() {
   }
 }
 
+// Seed `modelLimits` from previously persisted state.json entries. state.json is
+// a SHARED cross-instance snapshot rewritten at every live step, so it carries a
+// model's window even when THIS instance's ctx.model.list() came back empty (a
+// cold instance, or one whose model registry did not expose the provider).
+// Without this, a transient list miss degraded every denominator to "?" — and
+// because writeStateFile used to rewrite usable/limit from the (empty) in-memory
+// map, the degradation became permanent. Strictly additive: real in-memory
+// records always win (never overwritten). Returns the number of records seeded.
+function hydrateModelLimitsFromState() {
+  try {
+    const all = readStateSnapshot();
+    let added = 0;
+    for (const entry of Object.values(all)) {
+      const providerID =
+        typeof entry?.providerID === "string" ? entry.providerID : "";
+      const modelID = entry?.model;
+      const key = modelKey(providerID, modelID);
+      if (!key || !modelID || modelID === "unknown") continue;
+      if (modelLimits.has(key)) continue; // a real record always wins
+      // A state entry stores the derived usable window (`usable`) and the raw
+      // context window (`limit`) — NOT the input/output/reserved triple. Seed
+      // `usable` as `input` (reserved 0) so getUsableContext() re-derives EXACTLY
+      // the same denominator the warm instance persisted; seeding `limit` as
+      // context instead would let the cold instance show the raw context window
+      // (e.g. 200k) while the warm one shows the true usable window (e.g. 168k).
+      // Fall back to `limit` as context only when no `usable` was recorded.
+      const usable =
+        typeof entry?.usable === "number" && entry.usable > 0
+          ? entry.usable
+          : null;
+      const ctxLimit =
+        typeof entry?.limit === "number" && entry.limit > 0
+          ? entry.limit
+          : null;
+      let rec = null;
+      if (usable != null) {
+        rec = { context: ctxLimit, input: usable, output: null, reserved: 0 };
+      } else if (ctxLimit != null) {
+        rec = { context: ctxLimit, input: null, output: null, reserved: null };
+      }
+      if (rec == null) continue;
+      modelLimits.set(key, rec);
+      added++;
+    }
+    return added;
+  } catch {
+    return 0;
+  }
+}
+
 // True when a state.json entry carries no measured tokens at all: a session
 // registered (session.created) but with no served step. `writeStateFile` always
 // persists `categories` as an object, so the emptiness test must SUM those
@@ -2796,6 +2904,10 @@ export default {
     // to the generic 200k default), so the transform is not used for limit
     // population.
 
+    // Seed limits from the shared snapshot FIRST: another instance may already
+    // have resolved them, so a cold start never shows "?" denominators.
+    hydrateModelLimitsFromState();
+
     // Fire-and-forget prefetch of effective model limits.
     ensureModelLimits(ctx).catch((err) =>
       logErr("model limits prefetch failed", err),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-context-indicator",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Real-time OpenCode context-window usage indicator: per-category token breakdown written to a log file, plus an optional TUI sidebar. Dual V1 + V2 plugin entry.",
   "type": "module",
   "license": "MIT",
@@ -37,7 +37,6 @@
   "peerDependencies": {
     "@opencode/plugin": ">=2.0.16",
     "@opentui/core": ">=0.5.12",
-    "@opentui/solid": ">=0.5.12",
     "solid-js": ">=1.9.0"
   },
   "peerDependenciesMeta": {
@@ -47,17 +46,16 @@
     "@opentui/core": {
       "optional": true
     },
-    "@opentui/solid": {
-      "optional": true
-    },
     "solid-js": {
       "optional": true
     }
   },
+  "dependencies": {
+    "@opentui/solid": "0.5.12"
+  },
   "devDependencies": {
     "@opencode/plugin": "^2.0.19",
     "@opentui/core": "^0.5.12",
-    "@opentui/solid": "^0.5.12",
     "solid-js": "^1.9.12"
   }
 }

package/tui.tsx

@@ -23,8 +23,19 @@
  * file renders "no data yet". The main plugin never imports this file, so the
  * absence of the OpenTUI peers cannot break the server/V1 path.
  *
- * Peer requirements (declared optional in package.json): @opentui/core,
- * @opentui/solid, solid-js.
+ * Runtime requirements: @opentui/core and solid-js are optional peers resolved
+ * by OpenCode at runtime. @opentui/solid is a pinned direct dependency (exact
+ * 0.5.12): OpenCode's TUI loader does not expose a host instance of it, so for
+ * npm-installed plugins the JSX pragma would otherwise fail to resolve
+ * `@opentui/solid/jsx-runtime` (upstream opencode issue #33884).
+ *
+ * Graceful mode: when this file is loaded from an npm install (its own path is
+ * inside a `node_modules` directory), OpenCode skips the host Solid transform
+ * for `node_modules` paths, so a mounted slot renders once and then never
+ * live-updates (anomalyco/opencode#33884). Rather than freeze a permanent
+ * "no data yet" panel, the entry detects that case, logs a single hint and
+ * registers no slot. Install via `file://` from a path outside any
+ * `node_modules` for the live sidebar (see README → "Live sidebar").
  */
 import {Plugin, usePlugin} from "@opencode/plugin/tui"
 import {createSignal, Show} from "solid-js"
@@ -32,11 +43,25 @@ import type {ColorInput} from "@opentui/core"
 import {readFileSync} from "node:fs"
 import {tmpdir} from "node:os"
 import {join} from "node:path"
+import {fileURLToPath} from "node:url"
 
 const STATE_FILE = join(tmpdir(), "opencode-context-indicator-state.json")
 const POLL_MS = 1000
 const LABEL_WIDTH = 12
 
+// True when this module was loaded from an npm install, i.e. its own file path
+// contains a `node_modules` segment (OpenCode's TUI loader skips the host Solid
+// transform for such paths → slots mount once but never live-update; see the
+// Graceful mode note above). Normalised to forward slashes for Windows paths.
+function isNodeModulesInstall(): boolean {
+  try {
+    const selfPath = fileURLToPath(import.meta.url).replace(/\\/g, "/").toLowerCase()
+    return selfPath.includes("/node_modules/")
+  } catch {
+    return false
+  }
+}
+
 type Categories = {
   user?: number
   assistant?: number
@@ -163,6 +188,19 @@ function Sidebar(props: { entry: () => StateEntry | null }) {
 export default Plugin.define({
   id: "context-indicator.tui",
   setup(context) {
+    // npm installs (path under node_modules) cannot get live slot updates on
+    // this OpenCode version. Stay inert and log a single hint instead of
+    // registering a slot that would freeze on "no data yet".
+    if (isNodeModulesInstall()) {
+      console.log(
+        "[context-indicator] TUI sidebar disabled: npm-installed plugins cannot get " +
+          "live updates on this OpenCode version (anomalyco/opencode#33884). " +
+          'Install via file:// (see README → "Live sidebar") for the live sidebar. ' +
+          "Slash commands still work everywhere.",
+      )
+      return
+    }
+
     // Re-read the bridge file once per second and re-render reactively.
     const [tick, setTick] = createSignal(0)
     let currentSession: string | undefined