@cad0p/pi-usage 0.11.2 → 0.11.3

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.11.3] - 2026-11-02
+
+<!-- USER-EDITABLE SECTION START -->
+First fix release of the fork. With Claude Code uninstalled, Claude now reads Pi's own login instead of a dead Claude Code store, and `/usage` shows every OpenCode Go account.
+
+- **Claude source:** `auto` passes over an expired Claude Code token when Pi's `anthropic` login is fresh, and adds a warning naming the switch. `PI_QUOTA_CLAUDE_SOURCE=claude-code` still pins the CLI store. The report cache is keyed by the Claude source setting, so a switch refetches.
+- **Multi-account panel:** a provider with several accounts is one header plus one line per account (its fullest window, or `key rejected` / `no Go plan`), rendered as a component so Pi's ten-line widget cap no longer truncates it.
+- **Summary:** `OP-Go: 7/14 ok · lowest 24% (#7)` instead of account #1's number.
+- `piquota --version` reads `package.json`.
+<!-- USER-EDITABLE SECTION END -->
+
+### 🐛 Bug Fixes
+
+- /usage live bugs — dead Claude store, truncated panel, account-#1 summary (closes #5)
+
+

package/README.md

@@ -8,7 +8,8 @@ One source of truth for quota: **the credentials Pi already owns**.
 > * **OpenCode Go from the API key**: `GET https://opencode.ai/zen/go/v1/usage` returns the rolling (5h), weekly and monthly windows for the key Pi already stores, so no browser session is needed.
 > * **Numbered accounts**: `auth.json` entries such as `opencode-go-2` … `opencode-go-14` (the [pi-fallback-provider](https://github.com/cad0p/pi-fallback-provider) sibling convention) are read as extra accounts of their base provider.
 > * **One Omarchy tab per provider**: a multi-account provider shows each account's binding window (`#2 · Monthly`) in a single tab, and summarises failed accounts.
-> * **`/usage` on demand**: the Pi command is `/usage` only, and nothing is pinned above the editor or in the footer unless you ask for it.
+> * **`/usage` on demand**: the Pi command is `/usage` only, and nothing is pinned above the editor or in the footer unless you ask for it. A multi-account provider gets one line per account in the panel.
+> * **No dead Claude store**: `auto` passes over an expired Claude Code token when Pi's own `anthropic` login is fresh, and says so in the warnings.
 >
 > Everything below still applies; the CLI is still called `piquota`.
 
@@ -97,9 +98,12 @@ There are two ways to be signed in to Claude, and a user may have either or both
 | Claude Code CLI | `~/.claude/.credentials.json` (honours `CLAUDE_CONFIG_DIR`); on macOS, when that file is absent, the `Claude Code-credentials` login Keychain item (read-only, via `security find-generic-password`; macOS may ask once to allow access) | What `npm:pi-claude-code-provider` drives. A subscription with usage credits disabled answers `400` on Pi's own entry for every request, and this is the source that still works. |
 | Pi's own entry | `~/.pi/agent/auth.json` → `anthropic` | `/login anthropic` in Pi, without the plugin installed. |
 
-**The Claude Code CLI wins when both are present.** The choice is a *preference, not
-a fallback*: only the selected source is tried, so a broken preferred source is
-reported rather than silently masked by the other one. Override it with
+**The Claude Code CLI wins when both are present and its token is still valid.** The
+choice is a *preference, not a fallback*: only the selected source is tried, so a
+broken preferred source is reported rather than silently masked by the other one.
+The one exception is an expired Claude Code token next to a fresh Pi login: a store
+left behind by an uninstalled CLI never refreshes again, so `auto` reads Pi's login
+instead and adds a warning naming the switch. Override it with
 `PI_QUOTA_CLAUDE_SOURCE=pi` or `=claude-code`; `--explain` prints which one was used
 and why.
 
@@ -243,6 +247,12 @@ above the editor and leaves the footer alone. Turn a surface on with `/usage box
 it fresh with a background refresh (and a gentle refresh after each agent turn).
 `/usage hide` gives the row back.
 
+A provider with several accounts is shown as one header (`OP-Go · 7 of 14 accounts
+ok`) plus one line per account: its fullest window, or the reason it failed (`key
+rejected`, `no Go plan`). The panel is rendered as a component, so Pi's ten-line
+cap on plain widgets never truncates it, and the summary names the account with the
+most room: `OP-Go: 7/14 ok · lowest 24% (#7)`.
+
 `/usage box` pins the **five-row box above the editor**:
 
 ```
@@ -477,7 +487,7 @@ extensions/quota-panel.ts      Pi TUI line and /usage
 | `no claude credential in the Pi store or from the Claude Code CLI` | Neither Claude source is configured. `/login anthropic` in Pi, or install Claude Code and run `claude` once. |
 | `Claude Code CLI has no readable credentials; looked for …` | The store is missing, empty or corrupt. `piquota --explain` prints every path that was tried. |
 | `Claude Code token expired or rejected; run \`claude\` once` | Claude Code's own access token lapsed. Run any `claude` command; piQuota never refreshes it. |
-| Claude reports `plan pro` but the window looks wrong | The store is chosen by preference, not by success. `PI_QUOTA_CLAUDE_SOURCE=pi piquota` forces the other source. |
+| Claude reports `plan pro` but the window looks wrong | The store is chosen by preference, not by success. `PI_QUOTA_CLAUDE_SOURCE=pi piquota` forces the other source; the cache is keyed by that setting, so the switch refetches. |
 | `rate limited (HTTP 429); retry in Ns` | The vendor throttled the usage endpoint. Wait, or raise `--ttl`. |
 | `Antigravity token rejected` | Refresh failed; `/login antigravity` in Pi. `--no-refresh` disables the attempt. |
 | `no "auth" cookie for opencode.ai in N readable store(s)` | Run `piquota auth opencode`, or paste the cookie. |
@@ -488,7 +498,7 @@ extensions/quota-panel.ts      Pi TUI line and /usage
 ## Tests
 
 ```bash
-node --test tests/*.test.mjs     # 261 tests, fake tokens only, no network
+node --test tests/*.test.mjs     # 265 tests, fake tokens only, no network
 ```
 
 Modules covered: `auth.json` parsing and de-duplication, the Claude Code store

package/bin/piquota.js

@@ -12,6 +12,8 @@
  *                                the rail slot gentle-pi needs to paint the quota card
  */
 
+import { readFileSync } from "node:fs";
+
 import { clearCache, withCache } from "../src/cache.js";
 import { parseArgs } from "../src/cli/args.js";
 import { runAuthCommand } from "../src/cli/commands/auth.js";
@@ -19,13 +21,19 @@ import { runGentlePiCommand } from "../src/cli/commands/gentle-pi.js";
 import { runOmarchyCommand } from "../src/cli/commands/omarchy.js";
 import { explainLines, resolveFamilies } from "../src/cli/explain.js";
 import { err, out } from "../src/cli/output.js";
-import { collectQuota, enabledFamilies } from "../src/engine.js";
+import { collectQuota, enabledFamilies, normalizeClaudeSourceMode } from "../src/engine.js";
 import { redact } from "../src/http.js";
 import { mergeLastGood } from "../src/sticky.js";
 import { renderBoxWidget, renderCompact, renderPanel, renderStatusLine } from "../src/render/panel.js";
 import { ansiPalette } from "../src/render/theme.js";
 
-const VERSION = "0.11.1";
+const VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8")).version;
+
+/**
+ * The cache answers for the settings it was collected under: a Claude source
+ * switch must refetch instead of serving the other source's result.
+ */
+const CACHE_KEY = `claude-source:${normalizeClaudeSourceMode(process.env.PI_QUOTA_CLAUDE_SOURCE)}`;
 
 const HELP = `piquota ${VERSION} — read-only quota from Pi's provider credentials
 
@@ -120,7 +128,7 @@ async function main() {
       const loadFresh = () => collectQuota({ families: everyFamily, timeoutMs: args.timeoutMs, refresh, force: args.force });
       const fresh = args.noCache
         ? await loadFresh()
-        : (await withCache({ ttlMs: args.ttlMs, force: args.force, families: everyFamily }, loadFresh)).report;
+        : (await withCache({ ttlMs: args.ttlMs, force: args.force, families: everyFamily, key: CACHE_KEY }, loadFresh)).report;
       return mergeLastGood(fresh, {}).report;
     };
     return runOmarchyCommand({ load });
@@ -149,7 +157,7 @@ async function main() {
   if (args.noCache) {
     report = await load();
   } else {
-    const result = await withCache({ ttlMs: args.ttlMs, force: args.force, families: selected }, load);
+    const result = await withCache({ ttlMs: args.ttlMs, force: args.force, families: selected, key: CACHE_KEY }, load);
     report = result.report;
     cached = result.cached;
     ageMs = result.ageMs;

package/extensions/quota-panel.ts

@@ -486,26 +486,146 @@ function renderSidebarCard(report: QuotaReport | null, theme: Theme, width: numb
 }
 
 /** The detailed panel: every account and every window, with a used-fraction bar. */
+/**
+ * Clip one line to `width` visible columns, keeping SGR sequences intact. Every
+ * glyph this extension paints is one column wide, so code points are columns.
+ */
+function clipToWidth(line: string, width: number): string {
+  let visible = 0;
+  let out = "";
+  let styled = false;
+  for (let index = 0; index < line.length; ) {
+    const sgr = /^\u001b\[[0-9;]*m/.exec(line.slice(index));
+    if (sgr) {
+      out += sgr[0];
+      styled = true;
+      index += sgr[0].length;
+      continue;
+    }
+    const char = String.fromCodePoint(line.codePointAt(index) as number);
+    // Close any open style so a cut line cannot bleed colour into the next one.
+    if (visible + 1 > width) return styled ? `${out}\u001b[0m` : out;
+    out += char;
+    visible += 1;
+    index += char.length;
+  }
+  return out;
+}
+
+/**
+ * The panel as a component rather than a string array: Pi caps string-array
+ * widgets at ten lines, and a multi-account family alone can exceed that.
+ */
+function panelComponent(lines: string[]) {
+  return () => ({
+    render: (width: number) => lines.map((line) => ` ${clipToWidth(line, Math.max(0, width - 1))}`),
+    invalidate() {},
+  });
+}
+
+/**
+ * The one-line notify summary. A multi-account family reports how many accounts
+ * answer and the account with the most room, not whichever key happens to be #1.
+ */
+function summarize(report: QuotaReport): string {
+  const active = report.providers.filter((provider) => provider.notConfigured !== true);
+  return firstPerFamily(active)
+    .map((provider) => {
+      const name = SHORT_NAME[provider.family] ?? provider.family;
+      if (isMultiAccount(active, provider)) {
+        const accounts = active.filter((other) => other.family === provider.family);
+        const scored = accounts
+          .filter((account) => account.ok)
+          .map((account) => ({ account, used: usedOf(bindingWindow(account)) }))
+          .filter((entry): entry is { account: QuotaProvider; used: number } => entry.used !== null);
+        const counted = `${accounts.filter((account) => account.ok).length}/${accounts.length} ok`;
+        if (scored.length === 0) return `${name}: ${counted}`;
+        const lowest = scored.reduce((best, entry) => (entry.used < best.used ? entry : best));
+        return `${name}: ${counted} · lowest ${Math.round(lowest.used)}% (${lowest.account.account})`;
+      }
+      if (!provider.ok) return `${name}: ${errorCaption(provider.error)}`;
+      const used = usedOf(headline(provider));
+      return `${name}: ${used === null ? "n/a" : `${Math.round(used)}% used`}`;
+    })
+    .join(" · ");
+}
+
+/** The account's fullest window: the one that stops its next prompt. */
+function bindingWindow(provider: QuotaProvider): QuotaWindow | null {
+  let best: QuotaWindow | null = null;
+  for (const window of provider.windows) {
+    const used = usedOf(window);
+    if (used === null) continue;
+    if (best === null || used > (usedOf(best) as number)) best = window;
+  }
+  return best;
+}
+
+/** Short per-account failure reason; mirrors src/omarchy/record.js. */
+function accountReason(error: string | null | undefined): string {
+  const text = String(error ?? "");
+  if (/key rejected|key was rejected/i.test(text)) return "key rejected";
+  if (/Go plan not active|Workspace access denied/i.test(text)) return "no Go plan";
+  return errorCaption(error);
+}
+
+/** `#N` accounts of one family, i.e. a family Pi holds several credentials for. */
+function isMultiAccount(providers: QuotaProvider[], provider: QuotaProvider): boolean {
+  return typeof provider.account === "string"
+    && provider.account.startsWith("#")
+    && providers.filter((other) => other.family === provider.family).length > 1;
+}
+
+/**
+ * One family, many accounts: a header plus one line per account with only its
+ * binding window, so fourteen keys stay fourteen lines instead of fifty-six.
+ */
+function renderAccountRows(accounts: QuotaProvider[], theme: Theme): string[] {
+  const family = accounts[0].family;
+  const healthy = accounts.filter((account) => account.ok).length;
+  const header = `${paint(BRAND[family] ?? "#8B949E", SHORT_NAME[family] ?? accounts[0].label)} ${theme.fg("dim", `· ${healthy} of ${accounts.length} accounts ok`)}`;
+  const lines = [header];
+  const width = Math.max(...accounts.map((account) => account.account.length));
+  for (const account of accounts) {
+    const label = theme.fg("dim", account.account.padEnd(width));
+    if (!account.ok) {
+      const kind = errorKind(account.error);
+      const color = kind === "transient" || kind === "throttle" ? "warning" : kind === "expired" || kind === "auth" ? "error" : "dim";
+      lines.push(`  ${label}  ${theme.fg(color, errorGlyph(account.error))} ${theme.fg("warning", accountReason(account.error))}`);
+      continue;
+    }
+    const window = bindingWindow(account);
+    const used = usedOf(window);
+    if (window === null || used === null) {
+      lines.push(`  ${label}  ${theme.fg("dim", "no rate-limit windows reported")}`);
+      continue;
+    }
+    const band = bandFor(used);
+    const reset = window.resetsInSec === null ? "" : theme.fg("dim", ` · reset in ${humanDuration(window.resetsInSec)}`);
+    lines.push(
+      `  ${label}  ${paint(band.color, band.glyph)} ${paint(band.color, bar(used))} ` +
+        `${paint(band.color, `${used.toFixed(used < 10 ? 1 : 0)}%`.padStart(5))} ` +
+        `${theme.fg("dim", window.id)}${reset}`,
+    );
+  }
+  return lines;
+}
+
 function renderPanel(report: QuotaReport, theme: Theme): string[] {
   const lines: string[] = [];
   const active = report.providers.filter((provider) => provider.notConfigured !== true);
   const unconfigured = report.providers.filter((provider) => provider.notConfigured === true);
-
-  const familyCounts = new Map<string, number>();
-  for (const provider of active) familyCounts.set(provider.family, (familyCounts.get(provider.family) ?? 0) + 1);
+  const renderedFamilies = new Set<string>();
 
   for (const provider of active) {
-    // A multi-account family gets one row per account. The title carries the
-    // label ("OP-Go #2") so the account is not repeated in the meta line.
-    const multi = (familyCounts.get(provider.family) ?? 0) > 1
-      && typeof provider.account === "string"
-      && provider.account.startsWith("#");
-    const title = multi
-      ? `${SHORT_NAME[provider.family] ?? provider.label} ${provider.account}`
-      : provider.label;
-    const name = paint(BRAND[provider.family] ?? "#8B949E", title);
-    const meta: string[] = [];
-    if (!multi) meta.push(provider.account);
+    if (isMultiAccount(active, provider)) {
+      if (renderedFamilies.has(provider.family)) continue;
+      renderedFamilies.add(provider.family);
+      lines.push(...renderAccountRows(active.filter((other) => other.family === provider.family), theme));
+      continue;
+    }
+    const name = paint(BRAND[provider.family] ?? "#8B949E", provider.label);
+    const meta: string[] = [provider.account];
     if (provider.plan) meta.push(`plan ${provider.plan}`);
     // Two stores can back Claude, and this is the one place that says which.
     if (provider.sourceKind === "claude-code") meta.push("Claude Code CLI");
@@ -647,7 +767,7 @@ export default function quotaPanelExtension(pi: ExtensionAPI): void {
     }
 
     if (panelVisible && report) {
-      ctx.ui.setWidget(WIDGET_KEY, renderPanel(report, theme), { placement: "aboveEditor" });
+      ctx.ui.setWidget(WIDGET_KEY, panelComponent(renderPanel(report, theme)), { placement: "aboveEditor" });
       return;
     }
 
@@ -939,16 +1059,7 @@ export default function quotaPanelExtension(pi: ExtensionAPI): void {
       ctx.ui.notify(`Quota unavailable: ${lastError}`, "error");
       return;
     }
-    const active = firstPerFamily(report.providers.filter((provider) => provider.notConfigured !== true));
-    const summary = active
-      .map((provider) => {
-        const name = SHORT_NAME[provider.family] ?? provider.family;
-        if (!provider.ok) return `${name}: ${errorCaption(provider.error)}`;
-        const used = usedOf(headline(provider));
-        return `${name}: ${used === null ? "n/a" : `${Math.round(used)}% used`}`;
-      })
-      .join(" · ");
-    ctx.ui.notify(summary || "No active providers configured in Pi", "info");
+    ctx.ui.notify(summarize(report) || "No active providers configured in Pi", "info");
   };
 
   pi.registerCommand("usage", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cad0p/pi-usage",
-  "version": "0.11.2",
+  "version": "0.11.3",
   "publishConfig": {
     "access": "public"
   },

package/src/cache.js

@@ -69,6 +69,7 @@ export function resolveCachePath(options = {}) {
  *   now?: number,
  *   env?: Record<string, string | undefined>,
  *   home?: string,
+ *   key?: string,       Settings fingerprint; a cached report saved under another key is a miss.
  * }} [options]
  * @returns {{ report: import("./engine.js").PiQuotaReport, ageMs: number, path: string } | null}
  */
@@ -100,6 +101,9 @@ export function readCache(options = {}) {
   if (savedAt === null) return null;
   const ageMs = now - savedAt;
   if (ageMs > ttlMs) return null;
+  // A report collected under other settings (e.g. another Claude source) answers a
+  // different question, so it is a miss rather than a stale hit.
+  if (options.key !== undefined && /** @type {{ key?: unknown }} */ (parsed).key !== options.key) return null;
 
   for (const provider of report.providers) {
     for (const win of provider.windows ?? []) {
@@ -122,6 +126,8 @@ export function readCache(options = {}) {
  *   now?: number,
  *   env?: Record<string, string | undefined>,
  *   home?: string,
+ *   merge?: boolean,
+ *   key?: string,
  * }} [options]
  * @returns {{ ok: boolean, path: string, error?: string }}
  */
@@ -135,7 +141,11 @@ export function writeCache(report, options = {}) {
       finalReport = mergeReportIntoCache(existing.report, report);
     }
   }
-  const payload = JSON.stringify({ savedAt: now, report: finalReport }, null, 2);
+  const payload = JSON.stringify(
+    options.key === undefined ? { savedAt: now, report: finalReport } : { savedAt: now, key: options.key, report: finalReport },
+    null,
+    2,
+  );
 
   try {
     mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
@@ -191,6 +201,7 @@ export function describeCache(options = {}) {
  *   path?: string,
  *   families?: string[],
  *   merge?: boolean,
+ *   key?: string,
  *   env?: Record<string, string | undefined>,
  *   home?: string,
  * }} options

package/src/engine.js

@@ -100,6 +100,26 @@ export function resolveClaudeCredentials(input) {
     now: input.now,
   });
 
+  // `auto` prefers the Claude Code CLI only while its token is still usable. A
+  // leftover store from an uninstalled CLI never refreshes again, so once it has
+  // expired Pi's own login is the better source whenever Pi still has a fresh one.
+  if (claudeCode.ok && mode === "auto" && !checkFreshness(claudeCode.credential, input.now ?? Date.now()).fresh) {
+    const freshPi = fromPi.filter((credential) => checkFreshness(credential, input.now ?? Date.now()).fresh);
+    if (freshPi.length > 0) {
+      const expiredMin = Math.abs(checkFreshness(claudeCode.credential, input.now ?? Date.now()).expiresInMin ?? 0);
+      return {
+        credentials: freshPi,
+        mode: "pi",
+        unavailable: null,
+        // Said out loud so the switch is never silent: the report names the source
+        // it used and why the preferred one was passed over.
+        notice: `claude: the Claude Code token expired ${expiredMin}m ago; using Pi's anthropic login instead`,
+        claudeCodePaths: claudeCode.paths,
+        recoveredLock: claudeCode.recoveredLock ?? null,
+      };
+    }
+  }
+
   if (claudeCode.ok) {
     return {
       credentials: [claudeCode.credential],
@@ -191,6 +211,7 @@ export async function collectQuota(options = {}) {
     platform: options.platform,
     usersRoot: options.usersRoot,
     claudeCodePaths: options.claudeCodePaths,
+    now,
   });
 
   /**
@@ -207,6 +228,7 @@ export async function collectQuota(options = {}) {
   const byFamily = {};
   /** @type {string[]} */
   const warnings = [...loaded.warnings];
+  if (claude.notice) warnings.push(claude.notice);
   if (claude.recoveredLock) {
     warnings.push(
       `claude: removed abandoned OAuth refresh lock (${Math.round((claude.recoveredLock.ageMs ?? 0) / 1000)}s old) at ${claude.recoveredLock.lockPath}`,