pi-usage-limits 0.1.4 → 0.1.5

package/README.md

@@ -24,10 +24,11 @@ A [pi](https://github.com/earendil-works/pi) extension that shows your **Claude*
 
 | Active model | Source | Shows |
 |---|---|---|
+| `openai` provider, including `gpt-6.1-sol` | No quota lookup | `OpenAI usage unavailable; check usage dashboard` |
+| `openai-codex` provider, or a non-`openai` model id containing `codex` | ChatGPT usage endpoint (pi's `openai-codex` login) | 5-hour and weekly usage |
 | Model id contains `claude` | Claude Agent SDK (Claude Code login) | 5-hour and 7-day utilization |
-| `openai` or `openai-codex` provider, or model id contains `codex` | ChatGPT usage endpoint (pi's `openai-codex` login) | 5-hour and weekly usage |
 
-OpenAI models such as `(openai) gpt-6.1-sol` show the same ChatGPT subscription limits using your `openai-codex` login, not OpenAI API limits.
+The `openai` provider's Sign in with ChatGPT flow has no documented quota endpoint. Check **ChatGPT → Settings → Usage**, as [OpenAI recommends](https://developers.openai.com/siwc/token-sharing-open-source/profiles-and-sessions#tracking-usage). For API-key authentication, check the [OpenAI API usage dashboard](https://platform.openai.com/usage) instead. This extension never substitutes `openai-codex` credentials or cached limits for `openai`, even when the model id contains `codex`.
 
 Other models show `<model> not supported yet`.
 
@@ -57,14 +58,20 @@ pi -e npm:pi-usage-limits
 | `model_select` | Show usage for the new model |
 | `agent_settled` | Refresh after a prompt completes |
 
-The cache lives at `~/.pi/agent/cache/pi-usage-limits.json`. Writes are atomic and protected by a lockfile, so parallel sessions don't corrupt it.
+The cache lives at `~/.pi/agent/cache/pi-usage-limits.json`. Entries pair each source's limits with a fetch timestamp and expire after 60 seconds. Codex entries also record the account ID and are used only after checking the current login. Limits are shared across models using the same usage source, never between `openai` and `openai-codex`.
+
+Writes use atomic replacement and a lockfile for read-modify-write updates. The lock does not deduplicate concurrent API refreshes. Malformed or incompatible entries are treated as cache misses; the old cache format is discarded on the next save. Cache I/O failures produce console diagnostics but do not prevent displaying freshly fetched limits. Refresh failures still surface as errors rather than silently serving stale limits.
 
 ## Caveats
 
-- **Claude** limits come from an experimental Claude Agent SDK API, which may change in a future SDK release.
+- **Claude** limits come from an experimental Claude Agent SDK API, which may change in a future SDK release. The cache assumes one Claude Code login per agent directory; switching Claude accounts may show the previous account's limits for up to 60 seconds.
 - **Codex** limits come from an undocumented ChatGPT endpoint (`chatgpt.com/backend-api/wham/usage`, the same one the Codex CLI uses), which may change without notice.
 - Each uncached Claude lookup starts a short-lived `claude` process, which takes about a second. It runs in the background.
 
+## Development
+
+Run the cache regression tests with `npm test`. Tests use a temporary agent directory and mocked HTTP responses; they do not access your real cache or subscription endpoints.
+
 ## License
 
 MIT

package/codex_limits.ts

@@ -44,12 +44,20 @@ const toWindow = (w: WhamWindow | undefined): CodexWindow | null =>
 export async function getCodexLimits(token: string): Promise<CodexLimits> {
   const id = accountId(token);
   if (!id) throw new Error("Codex token has no ChatGPT account id");
+
   const res = await fetch(USAGE_URL, {
     headers: { Authorization: `Bearer ${token}`, "ChatGPT-Account-Id": id },
     signal: AbortSignal.timeout(10_000),
   });
+
+  if (res.status === 401)
+    throw new Error(
+      "Codex usage request failed: HTTP 401; run /login openai-codex to sign in again",
+    );
+
   if (!res.ok)
     throw new Error(`Codex usage request failed: HTTP ${res.status}`);
+
   const body = await res.json();
   return {
     primary: toWindow(body?.rate_limit?.primary_window),

package/lock.ts

@@ -46,8 +46,14 @@ export async function withLock<T>(
   }
 }
 
-export const readJson = (file: string) =>
-  readFile(file, "utf8").then(JSON.parse, () => undefined);
+export async function readJson(file: string) {
+  try {
+    return JSON.parse(await readFile(file, "utf8"));
+  } catch (error: any) {
+    if (error.code === "ENOENT" || error instanceof SyntaxError) return undefined;
+    throw error;
+  }
+}
 
 // Atomic replace: lock-free readers see the old or new file, never a torn one
 export async function writeJson(file: string, data: unknown) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-usage-limits",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "",
   "keywords": [
     "pi-package",
@@ -9,6 +9,9 @@
   "author": "Anthony Ilinykh <anthonyilinykh@gmail.com>",
   "license": "MIT",
   "type": "module",
+  "scripts": {
+    "test": "tsx --test tests/*.test.ts"
+  },
   "pi": {
     "extensions": [
       "./index.ts"
@@ -16,7 +19,6 @@
   },
   "files": [
     "*.ts",
-    "!*.test.ts",
     "README.md",
     "VERSION"
   ],
@@ -25,6 +27,7 @@
     "@anthropic-ai/claude-agent-sdk": "*"
   },
   "devDependencies": {
-    "@types/node": "^26.6.3"
+    "@types/node": "^26.6.3",
+    "tsx": "^4.23.15"
   }
 }

package/state.ts

@@ -2,26 +2,80 @@ import { mkdir } from "node:fs/promises";
 import { join } from "path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { readJson, withLock, writeJson } from "./lock";
-import { ClaudeLimits } from "./claude_limits";
-import type { CodexLimits } from "./codex_limits";
+import type { ClaudeLimits } from "./claude_limits";
+import type { CodexLimits, CodexWindow } from "./codex_limits";
 
 const dir = join(getAgentDir(), "cache");
 const file = join(dir, "pi-usage-limits.json");
+const CACHE_TTL_MS = 60_000;
+
+type CacheEntry<T> = {
+  fetchedAt: number;
+  value: T;
+};
 
 export type State = {
-  anthropic_last_api_call?: number;
-  anthropic_last_limits?: ClaudeLimits;
-  codex_last_api_call?: number;
-  codex_last_limits?: CodexLimits;
+  anthropic?: CacheEntry<ClaudeLimits>;
+  codex?: CacheEntry<CodexLimits> & { accountId: string };
 };
 
+export function isFresh(entry: CacheEntry<unknown> | undefined, now = Date.now()) {
+  if (!entry || !Number.isFinite(entry.fetchedAt)) return false;
+  const age = now - entry.fetchedAt;
+  return age >= 0 && age < CACHE_TTL_MS;
+}
+
+const isNumber = (value: unknown): value is number =>
+  typeof value === "number" && Number.isFinite(value);
+
+const isClaudeLimits = (value: any): value is ClaudeLimits =>
+  typeof value?.subscription === "string" &&
+  typeof value?.available === "boolean" &&
+  isNumber(value?.rate_limits?.five_hour?.utilization) &&
+  isNumber(value?.rate_limits?.seven_day?.utilization);
+
+const isCodexWindow = (value: any): value is CodexWindow | null =>
+  value === null ||
+  (isNumber(value?.usedPercent) &&
+    (value?.windowDurationMins === null || isNumber(value?.windowDurationMins)) &&
+    (value?.resetsAt === null || isNumber(value?.resetsAt)));
+
+const isCodexLimits = (value: any): value is CodexLimits =>
+  isCodexWindow(value?.primary) && isCodexWindow(value?.secondary);
+
 export async function saveState(state: State) {
-  await mkdir(dir, { recursive: true });
-  await withLock(file, async () =>
-    writeJson(file, { ...(await readJson(file)), ...state }),
-  );
+  try {
+    await mkdir(dir, { recursive: true });
+    await withLock(file, async () =>
+      writeJson(file, { ...(await loadState()), ...state }),
+    );
+  } catch (error) {
+    console.warn("pi-usage-limits: could not save cache", error);
+  }
 }
 
 export async function loadState(): Promise<State | undefined> {
-  return readJson(file);
+  try {
+    const data = await readJson(file);
+    if (!data || typeof data !== "object") return undefined;
+    const state: State = {};
+    if (
+      isNumber(data.anthropic?.fetchedAt) &&
+      isClaudeLimits(data.anthropic?.value)
+    ) {
+      state.anthropic = data.anthropic;
+    }
+    if (
+      isNumber(data.codex?.fetchedAt) &&
+      typeof data.codex?.accountId === "string" &&
+      data.codex.accountId.length > 0 &&
+      isCodexLimits(data.codex?.value)
+    ) {
+      state.codex = data.codex;
+    }
+    return state;
+  } catch (error) {
+    console.warn("pi-usage-limits: could not read cache", error);
+    return undefined;
+  }
 }

package/usage.ts

@@ -1,6 +1,7 @@
-import { getLimits, ClaudeLimits } from "./claude_limits";
-import { loadState, saveState } from "./state";
+import { getLimits, type ClaudeLimits } from "./claude_limits";
+import { isFresh, loadState, saveState } from "./state";
 import {
+  accountId,
   getCodexLimits,
   type CodexLimits,
   type CodexWindow,
@@ -14,11 +15,12 @@ export async function getUsage(
   model: { id: string; provider?: string },
   auth: TokenSource,
 ): Promise<string> {
-  if (
-    model.provider === "openai" ||
-    model.provider === "openai-codex" ||
-    model.id.includes("codex")
-  ) {
+  // Sign in with ChatGPT has no documented quota endpoint; never substitute Codex usage.
+  if (model.provider === "openai") {
+    return "OpenAI usage unavailable; check usage dashboard";
+  }
+
+  if (model.provider === "openai-codex" || model.id.includes("codex")) {
     return getCodexUsage(auth);
   }
 
@@ -32,40 +34,36 @@ export async function getUsage(
 async function getClaudeUsage() {
   const state = await loadState();
 
-  if (
-    state?.anthropic_last_limits &&
-    Date.now() - (state.anthropic_last_api_call ?? 0) < 60_000
-  ) {
-    return formatClaudeUsage(state.anthropic_last_limits) + " 󰃨";
+  if (state?.anthropic && isFresh(state.anthropic)) {
+    return formatClaudeUsage(state.anthropic.value) + " 󰃨";
   }
 
   const limits = await getLimits();
 
   await saveState({
-    anthropic_last_api_call: Date.now(),
-    anthropic_last_limits: limits,
+    anthropic: { fetchedAt: Date.now(), value: limits },
   });
 
   return formatClaudeUsage(limits);
 }
 
 async function getCodexUsage(auth: TokenSource): Promise<string> {
-  const state = await loadState();
-
-  if (
-    state?.codex_last_limits &&
-    Date.now() - (state.codex_last_api_call ?? 0) < 60_000
-  ) {
-    return formatCodexUsage(state.codex_last_limits) + " 󰃨";
-  }
   // pi's own openai-codex login; pi refreshes the token, we never touch ~/.codex/auth.json
   const token = await auth.getApiKeyForProvider("openai-codex");
   if (!token) throw new Error("Codex: run /login openai-codex");
+
+  const id = accountId(token);
+  if (!id) throw new Error("Codex token has no ChatGPT account id");
+
+  const state = await loadState();
+  if (state?.codex && state.codex.accountId === id && isFresh(state.codex)) {
+    return formatCodexUsage(state.codex.value) + " 󰃨";
+  }
+
   const limits = await getCodexLimits(token);
 
   await saveState({
-    codex_last_api_call: Date.now(),
-    codex_last_limits: limits,
+    codex: { fetchedAt: Date.now(), value: limits, accountId: id },
   });
 
   return formatCodexUsage(limits);