@bacnh85/pi-sub 0.1.29 → 0.1.31

package/CHANGELOG.md

@@ -1,3 +1,55 @@
+## 0.1.31 (2026-08-22)
+
+- **Fixed glm-cn quota via OmniRoute**: OmniRoute's connection slug for the
+  Z.ai (CN) upstream is `glm-cn`, not `zai-coding-cn` (a Pi provider id).
+  Wrong slug returned "No cached usage data", so the plain-retry fallback
+  showed the aggregate snapshot (e.g. R:100% W:0%) instead of the Z.ai windows.
+  Alias `glmcn` now maps to the correct slug; footer shows `R:99%/3H`-style
+  windows matching the direct Z.ai display.
+- OmniRoute "reset in 2h 55m" countdowns are now converted into compact
+  footer labels (`/3H`), and "Unavailable" windows are skipped (previously
+  `0%`-style aggregates leaked in via the fallback).
+
+## 0.1.30 (2026-08-22)
+
+- Router usage is now **provider-scoped**: the active router model's upstream
+  prefix (e.g. `command-code` from `router/command-code/deepseek/deepseek-v4-flash`)
+  is passed as `?provider=` to the OmniRoute usage API, so the footer shows that
+  upstream's quota (e.g. opencode-go session/weekly windows).
+- Aliases normalized before the API call: `cmd`→`command-code`, `oc`→`opencode-go`,
+  `ds`→`deepseek`, `glmcn`/`glm-cn`→`zai-coding-cn`; generic router aliases
+  (auto/aug/no-think/tllm/combo/openrouter/nvidia/…) are filtered out.
+- When the selected upstream has no cached quota ("No cached usage data"),
+  the adapter retries without `?provider=` so the footer still shows the best
+  snapshot instead of empty windows.
+- Switching between router models with different upstreams now refreshes
+  immediately (adapter id includes the prefix, so stale in-flight results are
+  discarded via the generation guard).
+- `/sub` breakdown shows only the Provider quota section — personal USD budget
+  lines are no longer surfaced.
+- Self-check extended (17 assertions) and now exercises the real
+  `routerUpstreamPrefix` (aliases + generic filter).
+
+## 0.1.27 (2026-08-22)
+
+- Router adapter now fetches real usage from OmniRoute instances: GET
+  `<origin>/api/usage/om-usage` (Bearer = router API key from auth.json or
+  ROUTER_API_KEY env). The plain-text report (Personal quota Daily/Weekly +
+  Provider quota Session/Weekly) is parsed into the footer R:/W: windows.
+  Non-OmniRoute routers 404 → fall back to the endpoint-only display.
+  When the per-key usage command is disabled, the footer shows a hint to
+  enable it in the OmniRoute dashboard (API Keys → the key).
+- New pure parser `parseOmniUsageText` with an env-gated self-check
+  (PI_SUB_SELF_CHECK=1) — pi-sub stays pack-only for CI.
+
+## 0.1.26 (2026-08-21)
+
+- Router adapter: reads `router.baseUrl` from `~/.pi/agent/settings.json`
+  (env `ROUTER_BASE_URL`/`NINE_ROUTER_BASE_URL`) now that pi-router moved the
+  endpoint URL out of the old `9router-config.json` (which is migrated away on
+  pi-router load). Footer shows for both new `router/` and legacy `9router/`
+  provider models.
+
 # Changelog
 
 ## 0.1.29 (2026-08-15)

package/README.md

@@ -51,12 +51,27 @@ The built-in `zai-coding-cn` provider targets the domestic BigModel endpoint (`o
 (Z.ai (CN) key#1a2b3c4d) R:55%/2H W:80%/3D 42 tok/s
 ```
 
-### 9router
+### Router (pi-router — formerly 9router)
 
-9router is a proxy/router with no upstream usage API, so the footer shows the configured endpoint and last response speed:
+For **OmniRoute** instances the footer shows real usage: `GET <origin>/api/usage/om-usage`
+with the router API key (auth.json `router` credential from `/login router`, or
+`ROUTER_API_KEY` env) returns the per-key report — Personal quota (daily/weekly
+USD budgets) and Provider quota (session/weekly connection windows) — rendered
+as `R:`/`W:` remaining-percent windows:
 
 ```text
-9router (172.30.55.22:20128) 145 tok/s
+Router usage R:80% W:28% 145 tok/s
+```
+
+Requirements:
+- The router instance must be OmniRoute (other routers 404 → endpoint-only fallback).
+- The API key must have the **usage command enabled** in the OmniRoute dashboard
+  (API Keys → the key → enable "usage command"); the footer shows a hint when it's off.
+
+The endpoint URL is read from `~/.pi/agent/settings.json` (`router.baseUrl`), env `ROUTER_BASE_URL` overrides:
+
+```text
+Router (172.30.55.22:20128) 145 tok/s
 ```
 
 ### Command Code

package/extensions/index.ts

@@ -16,8 +16,11 @@ const ZAI_PROVIDER = "zai";
 const ZAI_USAGE_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
 const ZAI_CODING_CN_PROVIDER = "zai-coding-cn";
 const ZAI_CODING_CN_USAGE_URL = "https://open.bigmodel.cn/api/monitor/usage/quota/limit";
-const NINE_ROUTER_PROVIDER = "9router";
-const NINE_ROUTER_CONFIG_PATH = path.join(os.homedir(), ".pi", "agent", "9router-config.json");
+const ROUTER_PROVIDER = "router";
+const LEGACY_9ROUTER_PROVIDER = "9router";
+// pi-router (formerly pi-9router): URL lives in settings.json `router.baseUrl`
+// (env override ROUTER_BASE_URL), key in auth.json `router` credential.
+const ROUTER_SETTINGS_PATH = path.join(os.homedir(), ".pi", "agent", "settings.json");
 const COMMAND_CODE_PROVIDER = "commandcode";
 const COMMAND_CODE_USAGE_URL = "https://api.commandcode.ai/alpha/billing/credits";
 
@@ -117,8 +120,8 @@ function isZaiCodingCnModel(model: ModelLike): boolean {
   return (model?.provider?.toLowerCase() ?? "") === ZAI_CODING_CN_PROVIDER;
 }
 
-function isNineRouterModel(model: ModelLike): boolean {
-  return (model?.provider?.toLowerCase() ?? "") === NINE_ROUTER_PROVIDER;
+function isRouterModel(model: ModelLike, provider: string = ROUTER_PROVIDER): boolean {
+  return (model?.provider?.toLowerCase() ?? "") === provider;
 }
 
 function isCommandCodeModel(model: ModelLike): boolean {
@@ -309,21 +312,137 @@ async function readZaiAuth(providerId: string, label: string): Promise<{ key: st
   return { key: entry.key, account: authAccountSnapshot(label, entry) };
 }
 
-// ponytail: duplicated from pi-9router — no shared config lib, 8 lines, acceptable
-function readNineRouterConfig(): { baseUrl: string; apiKey?: string } | null {
+// ponytail: duplicated from pi-router — no shared config lib, ~12 lines, acceptable
+function readRouterConfig(): { baseUrl: string } | null {
   try {
-    const exists = (p: string) => { try { return fs.statSync(p).isFile(); } catch { return false; } };
-    if (!exists(NINE_ROUTER_CONFIG_PATH)) return null;
-    const data = JSON.parse(fs.readFileSync(NINE_ROUTER_CONFIG_PATH, "utf8")) as Record<string, unknown>;
-    const baseUrl = process.env.NINE_ROUTER_BASE_URL || (typeof data.baseUrl === "string" ? data.baseUrl : undefined);
-    const apiKey = process.env.NINE_ROUTER_API_KEY || (typeof data.apiKey === "string" ? data.apiKey : undefined);
-    if (!baseUrl || typeof baseUrl !== "string") return null;
-    return { baseUrl, apiKey };
+    let baseUrl = process.env.ROUTER_BASE_URL || process.env.NINE_ROUTER_BASE_URL;
+    if (!baseUrl && fs.statSync(ROUTER_SETTINGS_PATH).isFile()) {
+      const settings = JSON.parse(fs.readFileSync(ROUTER_SETTINGS_PATH, "utf8")) as Record<string, unknown>;
+      const router = settings.router as { baseUrl?: unknown } | undefined;
+      if (typeof router?.baseUrl === "string" && router.baseUrl) baseUrl = router.baseUrl;
+    }
+    return baseUrl ? { baseUrl } : null;
   } catch {
     return null;
   }
 }
 
+/** Router API key: auth.json `router` credential (via /login), then env. */
+function readRouterApiKey(): string | undefined {
+  const stored = readStoredCredential(ROUTER_PROVIDER, piAuthPath()) as PiAuthEntry | undefined;
+  if (stored?.key) return stored.key;
+  return process.env.ROUTER_API_KEY || process.env.NINE_ROUTER_API_KEY || undefined;
+}
+
+/** Strip a `/v1` suffix so management routes (under the origin) can be
+ *  derived from the OpenAI-compatible baseUrl. */
+function routerOrigin(baseUrl: string): string {
+  return baseUrl.replace(/\/v1\/?$/, "");
+}
+
+/** Parse OmniRoute's `/api/usage/om-usage` plain-text report into windows.
+ *  Sections: "Personal quota" (per-key USD budgets: Daily/Weekly) and
+ *  "Provider quota" (connection session/weekly). Lines: `<Label>`,
+ *  `NN% left`, `⏱ reset in <countdown>`. Robust to missing/unknown blocks. */
+/** Convert OmniRoute's "reset in 2h 55m" countdown into the compact footer
+ *  label (e.g. 3H), matching the direct Z.ai display (R:99%/4H). */
+function countdownToLabel(text: string): string | undefined {
+  const m = text.match(/(?:(\d+)\s*d)?\s*(?:(\d+)\s*h)?\s*(?:(\d+)\s*m)?/);
+  if (!m || (!m[1] && !m[2] && !m[3])) return undefined;
+  const secs = Number(m[1] || 0) * 86400 + Number(m[2] || 0) * 3600 + Number(m[3] || 0) * 60;
+  return secs ? formatRemainingTime(Date.now() / 1000 + secs) : undefined;
+}
+
+export function parseOmniUsageText(text: string): {
+  personalDaily?: UsageWindow;
+  personalWeekly?: UsageWindow;
+  session?: UsageWindow;
+  providerWeekly?: UsageWindow;
+} {
+  const out: {
+    personalDaily?: UsageWindow;
+    personalWeekly?: UsageWindow;
+    session?: UsageWindow;
+    providerWeekly?: UsageWindow;
+  } = {};
+  const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  let inPersonal = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.toLowerCase() === "personal quota") { inPersonal = true; continue; }
+    if (line.toLowerCase() === "provider quota") { inPersonal = false; continue; }
+    const usedMatch = line.match(/^(\d+)%\s*left$/);
+    if (!usedMatch) continue;
+    const label = (lines[i - 1] ?? "").toLowerCase();
+    const resetMatch = lines[i + 1]?.match(/reset in (.+)$/);
+    const remaining = Number(usedMatch[1]);
+    if (remaining < 0 || remaining > 100) continue;
+    const window: UsageWindow = { remaining };
+      if (resetMatch) {
+        window.resetLabel = `⏱ ${resetMatch[1].trim()}`;
+        window.remainingLabel = countdownToLabel(resetMatch[1]);
+      }
+    if (inPersonal) {
+      if (label.includes("daily")) out.personalDaily = window;
+      else if (label.includes("weekly")) out.personalWeekly = window;
+    } else {
+      if (label.includes("session")) out.session = window;
+      else if (label.includes("weekly")) out.providerWeekly = window;
+    }
+  }
+  return out;
+}
+
+// ponytail: runnable self-check (pi-sub has no test runner — pack gate only)
+if (process.env.PI_SUB_SELF_CHECK === "1") {
+  const sample = [
+    "Personal quota", "Daily", "80% left", "⏱ reset in 15h 0m", "",
+    "Weekly", "90% left", "⏱ reset in 7d 0h 0m", "",
+    "Provider quota", "Session", "47% left", "⏱ reset in 9m", "",
+    "Weekly", "28% left", "⏱ reset in 1d 0h 0m",
+  ].join("\n");
+  const p = parseOmniUsageText(sample);
+  const assert = (cond: boolean, msg: string) => { if (!cond) throw new Error("pi-sub self-check: " + msg); };
+  assert(p.personalDaily?.remaining === 80, "personal daily 80");
+  // routerUpstreamPrefix: provider first segment, aliases + generic filtered
+  const rp = (id: string) => routerUpstreamPrefix({ id });
+  assert(rp("command-code/deepseek/deepseek-v4-flash") === "command-code", "prefix command-code");
+  assert(rp("cmd/deepseek/deepseek-v4-flash") === "command-code", "alias cmd → command-code");
+  assert(rp("oc/gpt-5") === "opencode-go", "alias oc → opencode-go");
+  // OmniRoute's connection slug is `glm-cn` (live-verified; zai-coding-cn is a
+  // Pi provider id, NOT an OmniRoute slug — wrong slug = no cached data).
+  assert(rp("glm-cn/glm-5.2") === "glm-cn", "glm-cn passes through");
+  assert(rp("glmcn/glm-5.2") === "glm-cn", "alias glmcn → glm-cn");
+  assert(rp("zai-coding/glm-5.2") === "zai-coding", "prefix zai-coding");
+  assert(rp("auto/best") === undefined, "generic auto filtered");
+  assert(rp("openrouter/gpt-5") === undefined, "generic openrouter filtered");
+  assert(rp("nvidia/gpt-5") === undefined, "generic nvidia filtered");
+  assert(p.personalWeekly?.remaining === 90, "personal weekly 90");
+  assert(p.session?.remaining === 47, "session 47");
+  assert(p.providerWeekly?.remaining === 28, "provider weekly 28");
+  assert(p.personalDaily?.resetLabel?.includes("15h"), "daily reset label");
+  const disabled = parseOmniUsageText("Usage command is disabled for this API key.");
+  assert(Object.keys(disabled).length === 0, "disabled text parses empty");
+  // Live-verified: provider without cached data → no windows (endpoint fallback).
+  const noCache = parseOmniUsageText("Provider quota\nNo cached usage data available.");
+  assert(Object.keys(noCache).length === 0, "no-cached-data parses empty");
+  // Live-verified: opencode-go quota via ?provider=opencode-go.
+  const live = parseOmniUsageText(
+    "Provider quota\nSession\n90% left\n⏱ reset in 1h 59m\n\nWeekly\n0% left\n⏱ reset in 1d 20h 26m"
+  );
+  assert(live.session?.remaining === 90, "session 90");
+  assert(live.providerWeekly?.remaining === 0, "weekly 0");
+  assert(live.session?.resetLabel?.includes("1h 59m"), "session reset");
+  // Live-verified 2026-08-22: glm-cn scoped quota — Session 99%, Weekly
+  // "Unavailable" (skipped, so W stays absent like the direct Z.ai footer).
+  const glmCn = parseOmniUsageText(
+    "Provider quota\nSession\n99% left\n⏱ reset in 2h 55m\n\nWeekly\nUnavailable\n⏱ reset in unknown"
+  );
+  assert(glmCn.session?.remaining === 99, "glm-cn session 99");
+  assert(glmCn.session?.remainingLabel === "3H", "glm-cn reset label 3H");
+  assert(glmCn.providerWeekly === undefined, "glm-cn weekly unavailable skipped");
+}
+
 async function fetchUsageFromPiAuth(entry: PiAuthEntry, signal?: AbortSignal): Promise<UsageApiSnapshot | undefined> {
   const accountId = getCodexAccountId(entry) ?? entry.accountId;
   if (!accountId) throw new Error("Missing openai-codex OAuth entry in Pi auth");
@@ -395,27 +514,100 @@ async function fetchOpenCodeGoUsage(_signal?: AbortSignal): Promise<Subscription
   }
 }
 
-async function fetchNineRouterUsage(_signal?: AbortSignal): Promise<SubscriptionUsageSnapshot> {
-  const cfg = readNineRouterConfig();
+async function fetchRouterUsage(signal?: AbortSignal, provider?: string): Promise<SubscriptionUsageSnapshot> {
+  const cfg = readRouterConfig();
   const now = Date.now();
   if (!cfg) {
     return {
-      providerDisplayName: "9router",
+      providerDisplayName: "Router",
       accounts: [],
       fetchedAt: now,
-      error: "9router not configured — run /login-9router",
+      error: "router not configured — set router.baseUrl in ~/.pi/agent/settings.json",
     };
   }
-  const account: SubscriptionAccountSnapshot = {
+  const apiKey = readRouterApiKey();
+  const baseAccount: SubscriptionAccountSnapshot = {
     id: cfg.baseUrl,
     isActive: true,
     accountLabel: cfg.baseUrl.replace(/^https?:\/\//, ""),
     lastActivity: "Now",
   };
+
+  // OmniRoute exposes per-key usage at GET <origin>/api/usage/om-usage
+  // (Bearer = the router API key). `?provider=` selects that upstream's quota
+  // (e.g. command-code/deepseek/deepseek-v4-flash → provider=command-code);
+  // without it the report shows the best/all snapshot. Plain text: Personal
+  // quota (Daily/Weekly USD budgets) + Provider quota (Session/Weekly).
+  // Non-OmniRoute routers 404 here — fall back to endpoint-only display.
+  if (apiKey) {
+    try {
+      const timeoutSignal = AbortSignal.timeout(7_000);
+      const combined = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+      const url = `${routerOrigin(cfg.baseUrl)}/api/usage/om-usage` +
+        (provider ? `?provider=${encodeURIComponent(provider)}` : "");
+      const response = await fetch(url, {
+        headers: { Accept: "text/plain", Authorization: `Bearer ${apiKey}` },
+        signal: combined,
+      });
+      if (response.ok) {
+        let text = await response.text();
+        if (text && !text.includes("disabled")) {
+          let w = parseOmniUsageText(text);
+          // Provider-scoped call but no cached quota for that upstream — retry
+          // without ?provider= so the report shows the best/all snapshot.
+          if (provider && !w.session && !w.providerWeekly) {
+            const plain = await fetch(url.replace(/\?provider=.*$/, ""), {
+              headers: { Accept: "text/plain", Authorization: `Bearer ${apiKey}` },
+              signal: combined,
+            });
+            if (plain.ok) {
+              const plainText = await plain.text();
+              if (plainText && !plainText.includes("disabled")) {
+                w = parseOmniUsageText(plainText);
+                text = plainText;
+              }
+            }
+          }
+          // personalDaily = per-key budget (nearest reset → R slot),
+          // provider weekly/session = upstream quota (W slot). Fall back sensibly.
+          const account: SubscriptionAccountSnapshot = {
+            ...baseAccount,
+            plan: provider ? `Router · ${provider}` : "Router usage",
+            fiveHour: w.personalDaily ?? w.session,
+            weekly: w.providerWeekly ?? w.personalWeekly,
+            // breakdown keeps only the provider-quota section — the raw text can
+            // include personal USD budget lines (privacy) and is noisy.
+            usageBreakdown: providerQuotaSection(text),
+          };
+          return {
+            providerDisplayName: "Router",
+            accounts: [account],
+            activeAccount: account,
+            fetchedAt: Date.now(),
+          };
+        }
+        // Usage command exists but is disabled for this key — keep the footer
+        // clean (endpoint display) and surface the hint in /sub detail only.
+        const keyFp = apiKey ? `${apiKey.slice(0, 4)}…${apiKey.slice(-4)}` : "?";
+        const hintAccount: SubscriptionAccountSnapshot = {
+          ...baseAccount,
+          usageBreakdown: `OmniRoute usage command is disabled for the router key ${keyFp} — ` +
+            `enable it in the dashboard (API Keys → the key ending ${apiKey?.slice(-4)} → usage command).`,
+        };
+        return {
+          providerDisplayName: "Router",
+          accounts: [hintAccount],
+          activeAccount: hintAccount,
+          fetchedAt: Date.now(),
+        };
+      }
+    } catch { /* non-OmniRoute or transient — fall through to endpoint display */ }
+  }
+
   return {
-    providerDisplayName: "9router",
-    accounts: [account],
-    activeAccount: account,
+    providerDisplayName: "Router",
+    accounts: [baseAccount],
+    activeAccount: baseAccount,
     fetchedAt: now,
   };
 }
@@ -704,11 +896,54 @@ function supportedAdapter(model: ModelLike): SubscriptionProviderAdapter | undef
   if (isOpenCodeGoModel(model)) return { id: OPC_PROVIDER, displayName: "OpenCode Go", fetchUsage: fetchOpenCodeGoUsage };
   if (isZaiModel(model)) return { id: ZAI_PROVIDER, displayName: "Z.ai", ...zaiUsageAdapter(ZAI_PROVIDER, ZAI_USAGE_URL, "Z.ai") };
   if (isZaiCodingCnModel(model)) return { id: ZAI_CODING_CN_PROVIDER, displayName: "Z.ai (CN)", ...zaiUsageAdapter(ZAI_CODING_CN_PROVIDER, ZAI_CODING_CN_USAGE_URL, "Z.ai (CN)") };
-  if (isNineRouterModel(model)) return { id: NINE_ROUTER_PROVIDER, displayName: "9router", fetchUsage: fetchNineRouterUsage };
+  if (isRouterModel(model)) {
+    const prefix = routerUpstreamPrefix(model);
+    return {
+      // Prefix in the id makes adapterChanged fire when switching upstreams
+      // (e.g. opencode-go → command-code), so the in-flight fetch from the
+      // previous model is discarded via the refreshGeneration guard.
+      id: prefix ? `${ROUTER_PROVIDER}:${prefix}` : ROUTER_PROVIDER,
+      displayName: "Router",
+      // ponytail: capture the upstream provider prefix so fetchRouterUsage can
+      // request that provider's quota from the OmniRoute usage API.
+      fetchUsage: (signal) => fetchRouterUsage(signal, prefix),
+    };
+  }
+  if (isRouterModel(model, LEGACY_9ROUTER_PROVIDER)) return { id: LEGACY_9ROUTER_PROVIDER, displayName: "9router (legacy)", fetchUsage: fetchRouterUsage };
   if (isCommandCodeModel(model)) return { id: COMMAND_CODE_PROVIDER, displayName: "Command Code", fetchUsage: fetchCommandCodeUsage };
   return undefined;
 }
 
+/** Strip everything up to and including the "Provider quota" section header
+ *  so /sub breakdown never shows personal USD budget lines. */
+function providerQuotaSection(text: string): string | undefined {
+  const idx = text.indexOf("Provider quota");
+  if (idx < 0) return undefined;
+  const section = text.slice(idx);
+  return section.trim().length > 0 ? section : undefined;
+}
+
+/** First path segment of a router model id = the upstream provider OmniRoute
+ *  routes to (e.g. `command-code/deepseek/deepseek-v4-flash` → `command-code`).
+ *  `router/provider/model` in pi flattens to id `provider/model`, so the prefix
+ *  is the first segment. Aliases normalize to the canonical provider id
+ *  (`cmd` → `command-code`); generic router aliases carry no provider info —
+ *  return undefined so the usage API picks the best snapshot. */
+function routerUpstreamPrefix(model: ModelLike): string | undefined {
+  const id = model?.id ?? "";
+  const first = id.split("/")[0]?.toLowerCase();
+  if (!first) return undefined;
+  // Alias normalization: OmniRoute exposes the same upstream under several ids.
+  if (first === "cmd") return "command-code";
+  if (first === "oc") return "opencode-go";
+  if (first === "ds") return "deepseek";
+  if (first === "glmcn") return "glm-cn"; // OmniRoute connection slug (not the Pi provider id zai-coding-cn)
+  // Generic router aliases / upstreams without cached quota data — no provider
+  // selection; the usage API returns the best snapshot instead.
+  const generic = new Set(["auto", "aug", "no-think", "tllm", "combo", "openrouter", "nvidia", "felo", "pepper", "mcode", "ddgw", "veoaifree-web", "veo-free"]);
+  return generic.has(first) ? undefined : first;
+}
+
 function formatRemaining(window: UsageWindow | undefined): string {
   if (!window) return "?";
   if (window.remainingLabel) return `${window.remaining}%/${window.remainingLabel}`;

package/package.json

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