@cad0p/pi-usage 0.11.4-20261103.0 → 0.11.4

package/README.md

@@ -6,7 +6,7 @@ One source of truth for quota: **the credentials Pi already owns**.
 > `@cad0p/pi-usage` is a fork of [J3pf/piQuota](https://github.com/J3pf/piQuota) (`@j3pf/piquota`). It adds:
 >
 > * **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. The accounts of one provider are queried in parallel (8 at a time, `PI_QUOTA_ACCOUNT_CONCURRENCY` from 1 to 32), so 14 OpenCode Go keys cost about one round trip instead of fourteen. Every request carries `User-Agent: pi-usage/<version> (+https://github.com/cad0p/pi-usage)` unless a provider needs its own client string: OpenCode Go asks clients not to use a generic HTTP-library name, and Node's default is `node`.
+> * **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.
 > * **Tokens by day and by model**: the tokens Pi's own session files recorded are folded per provider and shown in `/usage`, in `--json` (`localStats`) and in the Omarchy records, at a bounded scan cost.
 > * **`/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.
@@ -755,7 +755,7 @@ extensions/quota-panel.ts      Pi TUI line and /usage
 ## Tests
 
 ```bash
-node --test tests/*.test.mjs     # 359 tests, fake tokens only, no network
+node --test tests/*.test.mjs     # 354 tests, fake tokens only, no network
 ```
 
 Modules covered: `auth.json` parsing and de-duplication, the Claude Code store

package/bin/piquota.js

@@ -96,7 +96,6 @@ Omarchy:
 Environment:
   PI_QUOTA_LOCAL_STATS=0          skip the token scan of Pi's session files
   PI_QUOTA_LOCAL_STATS_BUDGET_MS  wall-clock budget for that scan (default 12000)
-  PI_QUOTA_ACCOUNT_CONCURRENCY    accounts of one provider queried at once (1-32, default 8)
 
 Guarantees:
   * ~/.pi/agent/auth.json is opened read-only. Never written, synced or refreshed.

package/package.json

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

package/src/engine.js

@@ -149,47 +149,6 @@ export function resolveClaudeCredentials(input) {
   };
 }
 
-/** Default number of accounts of one family queried at the same time. */
-export const DEFAULT_ACCOUNT_CONCURRENCY = 8;
-
-/**
- * `PI_QUOTA_ACCOUNT_CONCURRENCY` (1-32) bounds the parallel account requests of
- * one family; 1 restores the sequential behaviour.
- *
- * @param {Record<string, string | undefined>} env
- * @returns {number}
- */
-export function accountConcurrency(env) {
-  const value = Number.parseInt(env.PI_QUOTA_ACCOUNT_CONCURRENCY ?? "", 10);
-  if (!Number.isFinite(value) || value < 1) return DEFAULT_ACCOUNT_CONCURRENCY;
-  return Math.min(32, value);
-}
-
-/**
- * Map with at most `limit` calls in flight, results in input order.
- *
- * @template T, R
- * @param {T[]} items
- * @param {number} limit
- * @param {(item: T, index: number) => Promise<R>} fn
- * @returns {Promise<R[]>}
- */
-export async function mapBounded(items, limit, fn) {
-  /** @type {R[]} */
-  const results = new Array(items.length);
-  let next = 0;
-  const worker = async () => {
-    while (next < items.length) {
-      const index = next++;
-      results[index] = await fn(items[index], index);
-    }
-  };
-  // A non-numeric limit would otherwise start no worker and return holes.
-  const bounded = Number.isFinite(limit) ? Math.max(1, Math.floor(limit)) : 1;
-  await Promise.all(Array.from({ length: Math.min(bounded, items.length) }, worker));
-  return results;
-}
-
 /** @type {Record<string, (credential: any, options?: any) => Promise<import("./model.js").QuotaResult>>} */
 const PROVIDERS = {
   claude: fetchClaude,
@@ -355,18 +314,17 @@ export async function collectQuota(options = {}) {
         return;
       }
 
-      // Accounts of one family are independent requests, so they run in
-      // parallel (bounded): with 14 OpenCode Go keys a sequential loop cost
-      // ~3.8 s, a parallel one costs about one round trip. Results keep the
-      // credential order, and the backoff bookkeeping is replayed in that same
-      // order afterwards, so the final backoff state is exactly what the
-      // sequential loop produced.
-      const fetchQuota = PROVIDERS[family];
-      const outcomes = await mapBounded(credentials, accountConcurrency(env), async (credential) => {
+      /** @type {import("./model.js").QuotaResult[]} */
+      const results = [];
+      const familyWarnList = [];
+      for (const credential of credentials) {
         const freshness = checkFreshness(credential, now);
-        const warning = freshness.fresh
-          ? null
-          : `${family}: the ${expiredTokenName(credential)} expired ${Math.abs(freshness.expiresInMin ?? 0)}m ago; ${refreshHint(credential)}`;
+        if (!freshness.fresh) {
+          familyWarnList.push(
+            `${family}: the ${expiredTokenName(credential)} expired ${Math.abs(freshness.expiresInMin ?? 0)}m ago; ${refreshHint(credential)}`,
+          );
+        }
+        const fetchQuota = PROVIDERS[family];
         try {
           const result = await fetchQuota(credential, {
             now,
@@ -383,7 +341,18 @@ export async function collectQuota(options = {}) {
           // The renderers group siblings by family; the record builder needs the
           // slot to label each account without re-parsing its display string.
           result.slot = credential.slot ?? null;
-          return { result, warning, crashed: false };
+          if (isThrottled(result.error)) {
+            const seconds = recordBackoff(family, {
+              retryAfterSec: retryAfterFromError(result.error),
+              now,
+              env,
+              home: options.home,
+            }).seconds;
+            familyWarnList.push(`${family}: throttled upstream; pausing that family for ${seconds}s`);
+          } else if (result.ok || isAuthFailure(result.error)) {
+            clearBackoff(family, { env, home: options.home });
+          }
+          results.push(result);
         } catch (error) {
           // A provider must never take the whole report down.
           const crashed = degradedResult({
@@ -396,35 +365,8 @@ export async function collectQuota(options = {}) {
             expiresInMin: freshness.expiresInMin,
           });
           crashed.slot = credential.slot ?? null;
-          return { result: crashed, warning, crashed: true };
-        }
-      });
-
-      /** @type {import("./model.js").QuotaResult[]} */
-      const results = [];
-      const familyWarnList = [];
-      for (const { result, warning, crashed } of outcomes) {
-        if (warning) familyWarnList.push(warning);
-        if (!crashed) {
-          // Bookkeeping must degrade like the provider call it follows: a
-          // failing backoff write is a warning, never a rejected family.
-          try {
-            if (isThrottled(result.error)) {
-              const seconds = recordBackoff(family, {
-                retryAfterSec: retryAfterFromError(result.error),
-                now,
-                env,
-                home: options.home,
-              }).seconds;
-              familyWarnList.push(`${family}: throttled upstream; pausing that family for ${seconds}s`);
-            } else if (result.ok || isAuthFailure(result.error)) {
-              clearBackoff(family, { env, home: options.home });
-            }
-          } catch (error) {
-            familyWarnList.push(`${family}: could not update the backoff state: ${/** @type {{ message?: string }} */ (error)?.message ?? String(error)}`);
-          }
+          results.push(crashed);
         }
-        results.push(result);
       }
       byFamily[family] = results;
       familyWarnings[family] = familyWarnList;

package/src/http.js

@@ -5,41 +5,8 @@
  * redaction of secrets and error normalization stay in one place.
  */
 
-import { readFileSync } from "node:fs";
-
 const DEFAULT_TIMEOUT_MS = 15000;
 
-/**
- * The package's own User-Agent, sent on every request that does not set one.
- *
- * Without it Node's fetch announces itself as `node`, a generic HTTP-library
- * name. OpenCode Go's terms ask clients for their own User-Agent and have warned
- * and banned accounts over generic ones, and a usage poller that runs every few
- * minutes against every key of a user is exactly the traffic that gets looked
- * at. Providers that need a specific client string (Antigravity's CLI agent,
- * the dashboard's browser agent) keep setting their own.
- */
-export const PACKAGE_USER_AGENT = (() => {
-  try {
-    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
-    return `pi-usage/${pkg.version} (+https://github.com/cad0p/pi-usage)`;
-  } catch {
-    return "pi-usage (+https://github.com/cad0p/pi-usage)";
-  }
-})();
-
-/**
- * Copy `headers` and add `User-Agent` unless one is already set (any case).
- *
- * @param {Record<string, string> | undefined} headers
- * @returns {Record<string, string>}
- */
-export function withUserAgent(headers) {
-  const out = { ...(headers ?? {}) };
-  if (!Object.keys(out).some((name) => name.toLowerCase() === "user-agent")) out["User-Agent"] = PACKAGE_USER_AGENT;
-  return out;
-}
-
 /**
  * Redact credential-looking substrings from arbitrary text before it can reach
  * a log, a terminal or an error message.
@@ -129,7 +96,7 @@ export async function requestJson(url, options = {}) {
   try {
     const response = await fetchFn(url, {
       method: options.method ?? "GET",
-      headers: withUserAgent(options.headers),
+      headers: options.headers,
       body: options.body,
       signal: controller.signal,
     });