@bacnh85/pi-sub 0.1.37 → 0.1.39

package/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## 0.1.39 (2026-09-12)
+
+### Fixed
+
+- **Guarded footer render against an uninitialized theme proxy** (pi-budget
+  parity): `renderSubscriptionLine` dereferenced `ctx.ui.theme.fg` unguarded —
+  if the theme isn't ready yet the throw escapes as a rejected promise and can
+  exit pi (the same unhandledRejection class 0.1.37/0.1.38 fixed elsewhere).
+  The footer is now best-effort: skipped when the theme isn't available.
+- **Finite-cost guard on `message_end` accumulation** (pi-budget parity): a
+  string or NaN `cost.total` previously hit `+=` directly — a string cost
+  concatenated onto the accumulator and garbled every subsequent footer.
+  Costs are now coerced with `Number()` and only finite positive values
+  accumulate.
+- README intro: Router (pi-router) listed among supported providers.
+
+## 0.1.38 (2026-09-07)
+
+### Fixed
+
+- **Crash (pi exits) — third arm of the stale-ctx class**: pi 0.85.1 can
+  invalidate the extension ctx without ever delivering a matching
+  `session_shutdown` (orphaned/replaced runtime teardown; extension instances
+  are shared across sessions), so the 60s usage-refresh interval can fire with
+  `state.ctx` still installed but stale — the 0.1.18/0.1.37 guards (fire-time
+  ctx resolution, identity-guarded shutdown) never see it. `refreshUsage` is
+  async, so its throw became a rejected promise discarded by `void` →
+  `unhandledRejection` → pi's `uncaughtException` handler → exit. All deferred
+  refresh call sites now go through `deferRefresh`, which catches the
+  rejection and self-disarms (stops timers, drops in-flight state and the
+  stale ctx); `session_start` re-arms with the fresh ctx. Same crash class as
+  pi-messenger#25. The `/sub` command path disarms the same way when run
+  against an orphaned stale ctx, and regression tests now cover the 60s
+  interval arm, the command arm, and matcher independence from pi's exact
+  error wording.
+
 ## 0.1.37 (2026-09-07)
 
 ### Fixed

package/README.md

@@ -2,7 +2,7 @@
 
 Pi extension that shows subscription usage for the currently selected supported model provider.
 
- Supports OpenAI Codex (`openai-codex`) with live usage windows from ChatGPT's usage endpoint, OpenCode Go (`opencode-go`) with session cost tracking, and Z.ai GLM Coding Plan — both the international (`zai`) and China (`zai-coding-cn`, `open.bigmodel.cn`) endpoints — with quota monitoring. Also tracks Command Code (`commandcode`) 5-hour/weekly windows and monthly credit balance. Displays a subscription footer status after Pi's built-in status/token usage line.
+ Supports OpenAI Codex (`openai-codex`) with live usage windows from ChatGPT's usage endpoint, OpenCode Go (`opencode-go`) with session cost tracking, and Z.ai GLM Coding Plan — both the international (`zai`) and China (`zai-coding-cn`, `open.bigmodel.cn`) endpoints — with quota monitoring. Also tracks Router (pi-router, `router` provider) with response-speed tracking and optional OmniRoute quota windows, and Command Code (`commandcode`) 5-hour/weekly windows and monthly credit balance. Displays a subscription footer status after Pi's built-in status/token usage line.
 
 ## Install
 

package/extensions/index.ts

@@ -29,7 +29,7 @@ loadEnvFiles();
 const STATUS_KEY = "pi-sub";
 const MESSAGE_TYPE = "pi-sub-status";
 const USAGE_ENDPOINT = "https://chatgpt.com/backend-api/wham/usage";
-const REFRESH_INTERVAL_MS = 60_000;
+export const REFRESH_INTERVAL_MS = 60_000;
 const REFRESH_TTL_MS = 30_000;
 export const REFRESH_DEBOUNCE_MS = 2_000;
 const CODEX_PROVIDER = "openai-codex";
@@ -1103,6 +1103,9 @@ export function renderSubscriptionLine(state: State): void {
   const ctx = state.ctx;
   if (!ctx) return;
   const theme = ctx.ui.theme;
+  // pi-budget parity: the theme proxy may not be initialized yet — dereferencing
+  // theme.fg throws (unhandledRejection → pi exits). Best-effort footer: skip.
+  if (!theme?.fg) return;
   if (!state.adapter) {
     // Unsupported provider (e.g. Ollama): still show the last response speed.
     ctx.ui.setStatus(STATUS_KEY, state.lastTokPerSec !== undefined ? theme.fg("dim", `${state.lastTokPerSec} tok/s`) : undefined);
@@ -1140,10 +1143,38 @@ export function renderSubscriptionLine(state: State): void {
   ctx.ui.setStatus(STATUS_KEY, theme.fg(color, line));
 }
 
+function isStaleCtxError(error: unknown): boolean {
+  // pi 0.85.1's wording is "This extension ctx is stale after session
+  // replacement or reload." (verified in the host bundle); "invalidated" is
+  // matched too so wording drift degrades to a harmless extra disarm instead
+  // of silently disabling recovery.
+  return error instanceof Error && /\bctx is stale\b|invalidated/i.test(error.message);
+}
+
+function selfDisarm(state: State): void {
+  stopTimer(state);
+  state.inFlight = undefined;
+  state.refreshGeneration++;
+  state.ctx = undefined;
+}
+
+/** pi can invalidate state.ctx without ever delivering a matching
+ *  session_shutdown (pi 0.85.1 orphaned-runtime teardown; instances are shared
+ *  across sessions), so a deferred refresh can hit a stale ctx. refreshUsage
+ *  is async — its throw becomes a rejected promise, and a void-discarded
+ *  rejection exits pi (unhandledRejection -> uncaughtException). Catch it and
+ *  self-disarm; session_start re-arms with the fresh ctx. Non-stale
+ *  rejections are swallowed: adapters already resolve error snapshots. */
+function deferRefresh(state: State, force: boolean): void {
+  refreshUsage(state, force).catch((error) => {
+    if (isStaleCtxError(error)) selfDisarm(state);
+  });
+}
+
 function startTimer(state: State): void {
   if (state.refreshTimer || !state.adapter) return;
   state.refreshTimer = setInterval(() => {
-    void refreshUsage(state, false);
+    deferRefresh(state, false);
   }, REFRESH_INTERVAL_MS);
 }
 
@@ -1208,7 +1239,7 @@ export function scheduleRefresh(state: State): void {
   if (state.debounceTimer) clearTimeout(state.debounceTimer);
   state.debounceTimer = setTimeout(() => {
     state.debounceTimer = undefined;
-    void refreshUsage(state, true);
+    deferRefresh(state, true);
   }, REFRESH_DEBOUNCE_MS);
 }
 
@@ -1298,12 +1329,12 @@ export default function (pi: ExtensionAPI) {
     // need to — and a late old-session event must not reinstall a stale ctx.
     state.ctx = ctx;
     updateActiveAdapter(state, ctx.model);
-    if (state.adapter) void refreshUsage(state, true);
+    if (state.adapter) deferRefresh(state, true);
   });
 
   pi.on("model_select", async (event, _ctx) => {
     updateActiveAdapter(state, event.model);
-    if (state.adapter) void refreshUsage(state, true);
+    if (state.adapter) deferRefresh(state, true);
   });
 
   pi.on("before_provider_request", async (_event, _ctx) => {
@@ -1312,7 +1343,11 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("message_end", async (event, _ctx) => {
     if (event.message.role === "assistant") {
-      state.cumulativeCost += (event.message.usage as any)?.cost?.total ?? 0;
+      // pi-budget parity: coerce + finite guard so a string/NaN cost.total can
+      // never poison the accumulator (string concat garbles every subsequent
+      // footer).
+      const cost = Number((event.message.usage as any)?.cost?.total);
+      if (Number.isFinite(cost) && cost > 0) state.cumulativeCost += cost;
       if (state.responseStartTime) {
         // usage.output already includes reasoning tokens (Pi SDK contract) —
         // this is total tok/s in both thinking and normal mode.
@@ -1364,16 +1399,23 @@ export default function (pi: ExtensionAPI) {
       return items.length > 0 ? items : null;
     },
     handler: async (args, ctx) => {
-      updateActiveAdapter(state, ctx.model);
-      const command = args.trim().toLowerCase();
-      const force = command === "refresh";
-      const snapshot = state.adapter ? await refreshUsage(state, force || !state.snapshot) : undefined;
-      const details = buildDetails(snapshot ?? state.snapshot, state);
-      pi.sendMessage({ customType: MESSAGE_TYPE, content: details, display: true });
-      // state.ctx (not captured ctx): the session could be replaced during the
-      // await above; if it was, skip the notification instead of touching a
-      // stale ctx.
-      if (force) state.ctx?.ui.notify("Subscription usage refreshed", "info");
+      try {
+        updateActiveAdapter(state, ctx.model);
+        const command = args.trim().toLowerCase();
+        const force = command === "refresh";
+        const snapshot = state.adapter ? await refreshUsage(state, force || !state.snapshot) : undefined;
+        const details = buildDetails(snapshot ?? state.snapshot, state);
+        pi.sendMessage({ customType: MESSAGE_TYPE, content: details, display: true });
+        // state.ctx (not captured ctx): the session could be replaced during the
+        // await above; if it was, skip the notification instead of touching a
+        // stale ctx.
+        if (force) state.ctx?.ui.notify("Subscription usage refreshed", "info");
+      } catch (error) {
+        // Orphaned stale ctx (invalidated without shutdown): disarm like the
+        // deferred paths instead of throwing into pi's dispatcher.
+        if (!isStaleCtxError(error)) throw error;
+        selfDisarm(state);
+      }
     },
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bacnh85/pi-sub",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "description": "Pi extension showing subscription usage for supported model providers.",
   "type": "module",
   "license": "MIT",