@hank-warren/pi-statusline 0.2.1 → 0.2.2

package/README.md

@@ -27,7 +27,7 @@ Numbers are colored by remaining headroom: green above 60, yellow 41–60, orang
 
 Usage is fetched from the providers' own usage endpoints with Pi's stored tokens — read-only; tokens are never refreshed or written. Fetches happen on session start and after each turn, throttled to at most once every five minutes (the Anthropic usage endpoint rate-limits aggressively), and are strictly best-effort: on any failure the last-known value is kept, and providers without credentials (or before the first successful fetch) are simply omitted, leaving the statusline exactly as before. While a provider that *does* have credentials still has no value, the throttle drops to 30 seconds — Pi only refreshes an expired OAuth access token when that provider is first used, so a session starting with a stale Anthropic token would otherwise show no Claude meter for a full interval.
 
-Polling is host-wide, not per-session. Usage percentages describe the account rather than the session, and a busy machine runs dozens of pi processes, so every process shares `~/.pi/agent/statusline-usage.json`: it holds the last good snapshot plus the time the last poll was *started*, written atomically via a temp file and rename. A session adopts the cached values on its first refresh — so the meters are populated before it has issued a single request — and only polls when that shared timestamp is older than the interval. A provider answering `429` is parked for fifteen minutes (tracked per provider, so a rate-limited Anthropic never stops codex from updating) and stops counting as pending, since retrying harder is what earns the rate limit in the first place. Requires a Nerd Font new enough to include the codicon brand glyphs (v3.5.0+); older fonts render them as replacement boxes.
+Polling is host-wide, not per-session. Usage percentages describe the account rather than the session, and a busy machine runs dozens of pi processes, so every process shares `~/.pi/agent/statusline-usage.json`: it holds the last good snapshot plus the time the last poll was *started*, written atomically via a temp file and rename. A session adopts the cached values on its first refresh — so the meters are populated before it has issued a single request — and only polls when that shared timestamp is older than the interval. A provider answering `429` is parked for fifteen minutes (tracked per provider, so a rate-limited Anthropic never stops codex from updating) and stops counting as pending, since retrying harder is what earns the rate limit in the first place. Each provider's cache entry is keyed to a fingerprint (a sha256 prefix, never the token itself) of the credentials that fetched it: switching accounts — or rotating a token — discards that provider's cached numbers and backoff and polls immediately, so an exhausted old account's meters never masquerade as the new account's. Requires a Nerd Font new enough to include the codicon brand glyphs (v3.5.0+); older fonts render them as replacement boxes.
 
 ## Neon cache-wave celebration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hank-warren/pi-statusline",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Compact Pi footer statusline with Git/worktree context, token usage, and neon celebrations for exceptional prompt-cache hits.",
   "type": "module",
   "keywords": [

package/usage.ts

@@ -1,3 +1,4 @@
+import { createHash } from "node:crypto";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -121,6 +122,31 @@ export interface UsageTrackerOptions {
 
 type ProviderKey = "claude" | "codex";
 
+const PROVIDER_KEYS = ["claude", "codex"] as const;
+
+/** Non-reversible per-provider credential fingerprints; never raw tokens. */
+type ProviderIdentities = Partial<Record<ProviderKey, string>>;
+
+function fingerprint(material: string): string {
+	return createHash("sha256").update(material).digest("hex").slice(0, 16);
+}
+
+/**
+ * Fingerprint the credentials each provider would be polled with. Usage
+ * percentages belong to an account, so a cached value is only trustworthy
+ * while the credentials that produced it are still the ones in auth.json —
+ * after an account switch, yesterday's "1% left" is somebody else's meter.
+ */
+function credentialIdentities(auth: AuthEntries): ProviderIdentities {
+	const identities: ProviderIdentities = {};
+	if (hasClaudeAuth(auth)) identities.claude = fingerprint(String(auth.anthropic?.access));
+	if (hasCodexAuth(auth)) {
+		const entry = auth["openai-codex"];
+		identities.codex = fingerprint(`${entry?.access as string}\n${entry?.accountId as string}`);
+	}
+	return identities;
+}
+
 /**
  * Host-wide poll state shared by every pi process. Usage percentages are a
  * property of the account, not of a session, so one poll per interval per host
@@ -133,23 +159,57 @@ interface UsageCache {
 	/** Absolute times before which a rate-limited provider must not be polled. */
 	backoff: Partial<Record<ProviderKey, number>>;
 	snapshot: UsageSnapshot;
+	/** Credential fingerprints the snapshot was fetched with. */
+	identity: ProviderIdentities;
 }
 
-const EMPTY_CACHE: UsageCache = { attemptedAt: Number.NEGATIVE_INFINITY, backoff: {}, snapshot: {} };
+const EMPTY_CACHE: UsageCache = {
+	attemptedAt: Number.NEGATIVE_INFINITY,
+	backoff: {},
+	snapshot: {},
+	identity: {},
+};
+
+/**
+ * Drop cached values that were fetched with different credentials. A token
+ * rotation looks the same as an account switch here; the cost of treating it
+ * as one is a single immediate re-poll, while trusting a stale identity means
+ * showing another account's numbers as if they were current.
+ */
+function pruneCache(cache: UsageCache, identity: ProviderIdentities): UsageCache {
+	const snapshot = { ...cache.snapshot };
+	const backoff = { ...cache.backoff };
+	let changed = false;
+	for (const key of PROVIDER_KEYS) {
+		if (cache.identity[key] === identity[key]) continue;
+		if (snapshot[key] !== undefined || backoff[key] !== undefined) changed = true;
+		delete snapshot[key];
+		delete backoff[key];
+	}
+	if (!changed) return cache;
+	// The pruned values also claimed the shared throttle slot; the new account's
+	// first poll must not wait out a window started for somebody else.
+	return { attemptedAt: Number.NEGATIVE_INFINITY, backoff, snapshot, identity };
+}
 
 function parseUsageCache(json: unknown): UsageCache | undefined {
 	if (typeof json !== "object" || json === null) return undefined;
-	const body = json as { attemptedAt?: unknown; backoff?: unknown; snapshot?: unknown };
+	const body = json as { attemptedAt?: unknown; backoff?: unknown; snapshot?: unknown; identity?: unknown };
 	if (typeof body.attemptedAt !== "number" || !Number.isFinite(body.attemptedAt)) return undefined;
 	const snapshot = typeof body.snapshot === "object" && body.snapshot !== null ? (body.snapshot as UsageSnapshot) : {};
 	const backoff: UsageCache["backoff"] = {};
-	if (typeof body.backoff === "object" && body.backoff !== null) {
-		for (const key of ["claude", "codex"] as const) {
+	const identity: ProviderIdentities = {};
+	for (const key of PROVIDER_KEYS) {
+		if (typeof body.backoff === "object" && body.backoff !== null) {
 			const value = (body.backoff as Record<string, unknown>)[key];
 			if (typeof value === "number" && Number.isFinite(value)) backoff[key] = value;
 		}
+		if (typeof body.identity === "object" && body.identity !== null) {
+			const value = (body.identity as Record<string, unknown>)[key];
+			if (typeof value === "string") identity[key] = value;
+		}
 	}
-	return { attemptedAt: body.attemptedAt, backoff, snapshot };
+	return { attemptedAt: body.attemptedAt, backoff, snapshot, identity };
 }
 
 interface AuthEntries {
@@ -184,6 +244,7 @@ export class UsageTracker {
 	private readonly onChange?: () => void;
 	private readonly now: () => number;
 	private current: UsageSnapshot = {};
+	private identities: ProviderIdentities = {};
 	private awaitingProvider = true;
 	private readonly rateLimited = new Set<ProviderKey>();
 	private lastAttempt = Number.NEGATIVE_INFINITY;
@@ -229,7 +290,9 @@ export class UsageTracker {
 	 */
 	private async performRefresh(): Promise<void> {
 		const auth = (await this.readAuth()) ?? {};
-		const cache = (await this.readCache()) ?? EMPTY_CACHE;
+		const identity = credentialIdentities(auth);
+		const cache = pruneCache((await this.readCache()) ?? EMPTY_CACHE, identity);
+		this.pruneCurrent(identity);
 		// Another process's values are as good as ours and cost no request, so a new
 		// session shows real numbers on its very first render.
 		this.publish(this.merge(cache.snapshot, auth), auth, cache);
@@ -243,8 +306,9 @@ export class UsageTracker {
 
 		this.lastAttempt = now;
 		// Claim the slot before fetching so sibling processes skip this window even
-		// if our own request is slow or fails outright.
-		await this.writeCache({ ...cache, attemptedAt: now });
+		// if our own request is slow or fails outright. The claim carries the fresh
+		// identity so siblings do not re-prune and stampede the same window.
+		await this.writeCache({ ...cache, attemptedAt: now, identity });
 
 		const [claude, codex] = await Promise.all([
 			claudeAllowed ? this.fetchClaude(auth) : Promise.resolve(undefined),
@@ -258,11 +322,29 @@ export class UsageTracker {
 		this.rateLimited.clear();
 
 		const next = this.merge({ claude, codex }, auth);
-		const updated: UsageCache = { attemptedAt: now, backoff, snapshot: next };
+		const updated: UsageCache = { attemptedAt: now, backoff, snapshot: next, identity };
 		this.publish(next, auth, updated);
 		await this.writeCache(updated);
 	}
 
+	/**
+	 * Drop in-memory values fetched with previous credentials so merge() cannot
+	 * resurrect another account's numbers, and let the changed identity reopen
+	 * this process's own throttle gate.
+	 */
+	private pruneCurrent(identity: ProviderIdentities): void {
+		const changedKeys = PROVIDER_KEYS.filter((key) => this.identities[key] !== identity[key]);
+		this.identities = identity;
+		if (changedKeys.length === 0) return;
+		this.lastAttempt = Number.NEGATIVE_INFINITY;
+		if (!changedKeys.some((key) => this.current[key] !== undefined)) return;
+		const next = { ...this.current };
+		for (const key of changedKeys) delete next[key];
+		this.current = next;
+		// snapshot() changed even if the upcoming publish() sees no further delta.
+		this.onChange?.();
+	}
+
 	/**
 	 * Layer fresh values over the last-known ones and drop providers without
 	 * credentials: a logged-out provider must disappear immediately, while a