@cad0p/pi-usage 0.11.3 → 0.11.4

package/omarchy/cad0p.pi-usage/manifest.json

@@ -0,0 +1,56 @@
+{
+  "schemaVersion": 1,
+  "id": "cad0p.pi-usage",
+  "name": "AI Usage",
+  "version": "1.0.0",
+  "author": "cad0p",
+  "license": "MIT",
+  "description": "Every AI subscription's limits, accounts and token use in one scrolling bar panel, one collapsible section per provider. Derived from Omarchy's Agents plugin.",
+  "kinds": [
+    "bar-widget"
+  ],
+  "activation": "on-demand",
+  "entryPoints": {
+    "barWidget": "Panel.qml"
+  },
+  "barWidget": {
+    "displayName": "AI Usage",
+    "description": "One bar icon and one panel: every provider a collapsible section with its limits, every account of a multi-account provider, tokens by day and tokens by model.",
+    "category": "AI",
+    "defaultSection": "right",
+    "aliases": [
+      "ai-usage",
+      "pi-usage",
+      "quota"
+    ],
+    "allowMultiple": false,
+    "defaults": {
+      "providers": {},
+      "omarchyCollectors": "Auto",
+      "refreshIntervalSec": 900
+    },
+    "schema": [
+      {
+        "key": "omarchyCollectors",
+        "type": "enum",
+        "label": "Run Omarchy's collectors",
+        "options": [
+          "Auto",
+          "On",
+          "Off"
+        ],
+        "defaultValue": "Auto",
+        "description": "Auto runs omarchy-agent-usage-update only while the built-in Agents widget is not on the bar."
+      },
+      {
+        "key": "refreshIntervalSec",
+        "type": "integer",
+        "label": "Collector interval (seconds)",
+        "min": 30,
+        "max": 3600,
+        "step": 30,
+        "defaultValue": 900
+      }
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cad0p/pi-usage",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "publishConfig": {
     "access": "public"
   },
@@ -16,6 +16,7 @@
     "bin",
     "src",
     "extensions",
+    "omarchy",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"

package/src/auth/pi-auth.js

@@ -24,6 +24,9 @@ export const FAMILY_BY_PROVIDER = {
   "openai-codex": "codex",
   anthropic: "claude",
   antigravity: "antigravity",
+  // Pi's built-in /login stores Antigravity under this key; `antigravity` is
+  // kept for stores written by older Pi releases and third-party plugins.
+  "google-antigravity": "antigravity",
   "opencode-go": "opencode-go",
 };
 

package/src/cli/args.js

@@ -18,6 +18,7 @@
  * @property {boolean} version
  * @property {boolean} status
  * @property {boolean} clearCache
+ * @property {boolean} rebuildTotals
  * @property {number} ttlMs
  * @property {number} timeoutMs
  * @property {string[]} unknown          Flags this parser does not own.
@@ -70,6 +71,7 @@ export function parseArgs(argv, defaults = {}) {
     status: false,
     box: false,
     clearCache: false,
+    rebuildTotals: false,
     ttlMs: defaults.defaultTtlMs ?? 60_000,
     timeoutMs: defaults.defaultTimeoutMs ?? 15_000,
     unknown: [],
@@ -142,6 +144,9 @@ export function parseArgs(argv, defaults = {}) {
       case "--clear-cache":
         parsed.clearCache = true;
         break;
+      case "--rebuild-totals":
+        parsed.rebuildTotals = true;
+        break;
       default:
         // Owned by a subcommand, which reads it from `raw` itself.
         if (SUBCOMMAND_FLAGS.has(arg)) break;

package/src/cli/commands/stats.js

@@ -0,0 +1,76 @@
+/**
+ * `piquota stats`: read or rebuild the durable token history.
+ *
+ * The history is the one place tokens accumulate across runs; this command is
+ * the read-only view of it and the recovery path for a lost `totals.json`.
+ */
+
+import { acquireHistoryLock, loadTotals, rebuildTotalsFromMonths, releaseHistoryLock, resolveHistoryDir } from "../../local/history.js";
+import { resolveLocalStatsCachePath } from "../../local/pi-sessions.js";
+import { redact } from "../../http.js";
+import { err, out } from "../output.js";
+
+/**
+ * @param {{
+ *   rebuild?: boolean,
+ *   env?: Record<string, string | undefined>,
+ *   home?: string,
+ *   historyDir?: string,
+ *   cachePath?: string,
+ * }} [options]
+ * @returns {number} Exit code.
+ */
+export function runStatsCommand(options = {}) {
+  const env = options.env ?? process.env;
+  const historyDir = options.historyDir ?? resolveHistoryDir({ env, home: options.home });
+  /** @type {string[]} */
+  const warnings = [];
+
+  if (options.rebuild) {
+    // The rebuild rewrites the same file a scan freezes into, so it takes the
+    // same lock: a concurrent scan must not interleave its freeze with it.
+    const lockPath = `${options.cachePath ?? resolveLocalStatsCachePath({ env, home: options.home })}.lock`;
+    const lock = acquireHistoryLock({ lockPath });
+    if (!lock.acquired) {
+      err(`stats: another piquota run holds the history lock (${lock.path}); try again in a moment`);
+      return 1;
+    }
+    let result;
+    try {
+      result = rebuildTotalsFromMonths({ historyDir, warnings });
+    } finally {
+      releaseHistoryLock(lock);
+    }
+    for (const warning of warnings) err(`warning: ${warning}`);
+    if (!result.ok) {
+      err(`stats: could not rebuild the history totals: ${redact(result.error ?? "unknown error")}`);
+      return 1;
+    }
+    out(
+      `stats: rebuilt ${result.path} from ${result.months} month file(s): ${result.days} frozen day(s), ` +
+        `${result.families} family/ies, last frozen day ${result.lastFrozenDay || "none"}`,
+    );
+    return 0;
+  }
+
+  const history = loadTotals({ historyDir, warnings });
+  for (const warning of warnings) err(`warning: ${warning}`);
+  if (!history.exists || history.totals.families.size === 0) {
+    out(`stats: no frozen token history at ${historyDir}`);
+    return 0;
+  }
+
+  let prompts = 0;
+  let sessions = 0;
+  const days = new Set();
+  for (const family of history.totals.families.values()) {
+    prompts += family.totalPrompts;
+    sessions += family.totalSessions;
+    for (const date of family.activeDates) days.add(date);
+  }
+  out(`stats: ${historyDir}`);
+  out(`  last frozen day: ${history.totals.lastFrozenDay || "none"}`);
+  out(`  families: ${Array.from(history.totals.families.keys()).sort().join(", ")}`);
+  out(`  frozen days: ${days.size} · prompts: ${prompts} · session-days: ${sessions}`);
+  return 0;
+}

package/src/engine.js

@@ -8,6 +8,8 @@
 
 import { checkFreshness, LABEL_BY_FAMILY, loadPiCredentials, resolveAuthPaths } from "./auth/pi-auth.js";
 import { loadClaudeCodeCredential } from "./auth/claude-code-auth.js";
+import { redact } from "./http.js";
+import { collectLocalStats } from "./local/pi-sessions.js";
 import { degradedResult, displayIdentity, selectPrimaryWindow } from "./model.js";
 import { backoffState, clearBackoff, isAuthFailure, isThrottled, recordBackoff, retryAfterFromError } from "./providers/backoff.js";
 import { fetchQuota as fetchClaude } from "./providers/claude.js";
@@ -166,6 +168,11 @@ const PROVIDERS = {
  * @property {string[]} warnings
  * @property {import("./model.js").QuotaResult[]} providers   Flattened, family-ordered.
  * @property {Record<string, import("./model.js").QuotaResult[]>} byFamily
+ * @property {Record<string, import("./local/pi-sessions.js").LocalFamilyStats>} localStats
+ *           Tokens Pi's own session files recorded, per family. Empty when the
+ *           scan is disabled, still warming up or has nothing to report.
+ * @property {import("./local/pi-sessions.js").LocalScanMeta | null} localStatsMeta
+ *           How the token scan went, including `partial` and `locked`.
  */
 
 /**
@@ -186,6 +193,11 @@ const PROVIDERS = {
  *   stores?: import("./browser/cookies.js").CookieStore[],
  *   allowBrowser?: boolean,
  *   claudeCodePaths?: string[] | null,
+ *   localStats?: boolean | import("./local/pi-sessions.js").LocalStatsOptions,
+ *     Local token statistics from Pi's session files. Off unless asked for, so
+ *     tests and library callers never read a real home directory; the CLI turns
+ *     it on with a time budget. Pass an object to inject session roots or a
+ *     cache path, or false to disable it explicitly.
  * }} [options]
  * @returns {Promise<PiQuotaReport>}
  */
@@ -239,6 +251,17 @@ export async function collectQuota(options = {}) {
 
   const hasOpenAi = loaded.rawProviders?.includes("openai") || Boolean(env.OPENAI_API_KEY);
 
+  // The local scan runs beside the network calls: a first full scan of the
+  // session store costs seconds, and adding that to the quota round-trip would
+  // push the /usage extension closer to its 30 s exec timeout.
+  const localStatsOptions = typeof options.localStats === "object" && options.localStats !== null ? options.localStats : {};
+  const localStatsTask =
+    options.localStats === undefined || options.localStats === false
+      ? null
+      : collectLocalStats({ env, home: options.home, now, ...localStatsOptions }).catch(
+          (error) => /** @type {{ error: unknown }} */ ({ error }),
+        );
+
   await Promise.all(
     families.map(async (family) => {
       const credentials = credentialsFor(family);
@@ -364,6 +387,25 @@ export async function collectQuota(options = {}) {
     provider.primaryWindowId = selectPrimaryWindow(provider.windows ?? [])?.id ?? null;
   }
 
+  // Local statistics are a bonus, never a reason for a provider to fail: a
+  // rejected scan is reported as one warning and the report carries no numbers.
+  /** @type {Record<string, import("./local/pi-sessions.js").LocalFamilyStats>} */
+  let localStats = {};
+  /** @type {PiQuotaReport["localStatsMeta"]} */
+  let localStatsMeta = null;
+  if (localStatsTask) {
+    const local = await localStatsTask;
+    if ("error" in local) {
+      warnings.push(
+        `local token stats: ${redact(/** @type {{ message?: string }} */ (local.error)?.message ?? String(local.error))}`,
+      );
+    } else {
+      localStats = local.byFamily;
+      localStatsMeta = local.scan;
+      warnings.push(...local.warnings);
+    }
+  }
+
   return {
     engine: "pi-quota",
     schemaVersion: 1,
@@ -376,6 +418,8 @@ export async function collectQuota(options = {}) {
     warnings,
     providers,
     byFamily,
+    localStats,
+    localStatsMeta,
   };
 }