pi-fancy-footer 1.3.1 → 1.3.2

package/README.md

@@ -276,9 +276,10 @@ Notes:
   from `~/.pi/agent/auth.json`, falling back to Codex CLI credentials in
   `~/.codex/auth.json`. Claude uses pi Anthropic OAuth credentials from
   `~/.pi/agent/auth.json` and reads Claude.ai usage for the 5-hour and weekly
-  windows. Status is cached under `~/.cache/pi-fancy-footer/provider-status/`.
-  The widget is hidden when the active model selection is not backed by the
-  status provider.
+  windows. Status is cached under `~/.cache/pi-fancy-footer/provider-status/`;
+  when a refresh fails, cached quota windows keep showing until their reset times
+  pass instead of hiding the widget. The widget is hidden when the active model
+  selection is not backed by the status provider.
 - `provider-status` also refreshes from `x-codex-*` provider response headers
   when pi exposes them, avoiding a separate Codex status request after provider
   calls. Claude status refreshes from the Claude.ai usage endpoint, not
@@ -297,6 +298,7 @@ Notes:
 - `pull-request-ci-status` shows GitHub Actions workflow runs for the current
   PR head commit. It links to the relevant run and switches to failed as soon as
   one workflow fails, even when other workflows are still running.
+
 ## 🧱 Gauge styles
 
 The `gaugeStyle` setting controls the characters used by the `context-bar`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fancy-footer",
-  "version": "1.3.1",
+  "version": "1.3.2",
   "description": "A fancy footer extension for pi",
   "type": "module",
   "peerDependencies": {

package/src/provider-status.test.ts

@@ -14,10 +14,7 @@ import {
   providerStatusColor,
   updateProviderStatusFromHeaders,
 } from "./provider-status.ts";
-import {
-  getGaugeStyle,
-  type ProviderStatusConfigSnapshot,
-} from "./shared.ts";
+import { getGaugeStyle, type ProviderStatusConfigSnapshot } from "./shared.ts";
 
 const now = new Date("2026-05-06T10:00:00Z");
 const providerStatusConfig: ProviderStatusConfigSnapshot = {
@@ -338,6 +335,295 @@ test("collectProviderStatus does not present expired cache as live status after
   assert.match(snapshot?.error ?? "", /No usable Codex OAuth credentials/);
 });
 
+test("collectProviderStatus keeps cached quota in effect after a failed refresh", async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), "pi-fancy-footer-test-"));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  const previousHome = process.env.HOME;
+  const previousXdgCacheHome = process.env.XDG_CACHE_HOME;
+  const previousFetch = globalThis.fetch;
+  process.env.HOME = dir;
+  process.env.XDG_CACHE_HOME = join(dir, "cache");
+  globalThis.fetch = async () =>
+    new Response(JSON.stringify({ error: { message: "rate limited" } }), {
+      status: 429,
+    });
+  t.after(() => {
+    if (previousHome === undefined) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+    if (previousXdgCacheHome === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = previousXdgCacheHome;
+    globalThis.fetch = previousFetch;
+  });
+
+  await mkdir(join(dir, ".pi", "agent"), { recursive: true });
+  await writeFile(
+    join(dir, ".pi", "agent", "auth.json"),
+    JSON.stringify({ anthropic: { access: "test-access-token" } }),
+    { mode: 0o600 },
+  );
+
+  const futureResetAt = Math.ceil(Date.now() / 1000) + 3_600;
+  const cacheDir = join(
+    process.env.XDG_CACHE_HOME,
+    "pi-fancy-footer",
+    "provider-status",
+  );
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(
+    join(cacheDir, "anthropic.json"),
+    JSON.stringify({
+      provider: "anthropic",
+      source: "api",
+      fetchedAt: "2026-05-06T09:00:00Z",
+      state: "ok",
+      primary: {
+        label: "5h",
+        usedPercent: 5,
+        leftPercent: 95,
+        resetAt: futureResetAt,
+      },
+      secondary: {
+        label: "7d",
+        usedPercent: 12,
+        leftPercent: 88,
+        resetAt: futureResetAt,
+      },
+      url: "https://claude.ai/settings/usage",
+    }),
+    { mode: 0o600 },
+  );
+
+  const snapshots = await collectProviderStatus({} as never, {
+    ...anthropicProviderStatusConfig,
+    cacheTtlMs: 1,
+  });
+
+  assert.equal(snapshots.length, 1);
+  const snapshot = snapshots[0];
+  assert.equal(snapshot?.source, "cache");
+  assert.equal(snapshot?.state, "ok");
+  assert.deepEqual(snapshot?.primary, {
+    label: "5h",
+    usedPercent: 5,
+    leftPercent: 95,
+    resetAt: futureResetAt,
+  });
+  assert.deepEqual(snapshot?.secondary, {
+    label: "7d",
+    usedPercent: 12,
+    leftPercent: 88,
+    resetAt: futureResetAt,
+  });
+  assert.match(snapshot?.error ?? "", /429/);
+});
+
+test("collectProviderStatus hides cached quota once its windows reset", async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), "pi-fancy-footer-test-"));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  const previousHome = process.env.HOME;
+  const previousXdgCacheHome = process.env.XDG_CACHE_HOME;
+  const previousFetch = globalThis.fetch;
+  process.env.HOME = dir;
+  process.env.XDG_CACHE_HOME = join(dir, "cache");
+  globalThis.fetch = async () => new Response("rate limited", { status: 429 });
+  t.after(() => {
+    if (previousHome === undefined) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+    if (previousXdgCacheHome === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = previousXdgCacheHome;
+    globalThis.fetch = previousFetch;
+  });
+
+  await mkdir(join(dir, ".pi", "agent"), { recursive: true });
+  await writeFile(
+    join(dir, ".pi", "agent", "auth.json"),
+    JSON.stringify({ anthropic: { access: "test-access-token" } }),
+    { mode: 0o600 },
+  );
+
+  const cacheDir = join(
+    process.env.XDG_CACHE_HOME,
+    "pi-fancy-footer",
+    "provider-status",
+  );
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(
+    join(cacheDir, "anthropic.json"),
+    JSON.stringify({
+      provider: "anthropic",
+      source: "api",
+      fetchedAt: "2026-05-06T09:00:00Z",
+      state: "ok",
+      primary: { label: "5h", usedPercent: 5, leftPercent: 95, resetAt: 1 },
+      secondary: {
+        label: "7d",
+        usedPercent: 12,
+        leftPercent: 88,
+        resetAt: 1,
+      },
+      url: "https://claude.ai/settings/usage",
+    }),
+    { mode: 0o600 },
+  );
+
+  const snapshots = await collectProviderStatus({} as never, {
+    ...anthropicProviderStatusConfig,
+    cacheTtlMs: 1,
+  });
+
+  assert.equal(snapshots.length, 1);
+  const snapshot = snapshots[0];
+  assert.equal(snapshot?.source, "api");
+  assert.equal(snapshot?.state, "unavailable");
+  assert.equal(snapshot?.primary, undefined);
+  assert.equal(snapshot?.secondary, undefined);
+  assert.match(snapshot?.error ?? "", /429/);
+});
+
+test("collectProviderStatus keeps cached quota in effect after a failed auth refresh", async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), "pi-fancy-footer-test-"));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  const previousHome = process.env.HOME;
+  const previousXdgCacheHome = process.env.XDG_CACHE_HOME;
+  const previousFetch = globalThis.fetch;
+  process.env.HOME = dir;
+  process.env.XDG_CACHE_HOME = join(dir, "cache");
+  globalThis.fetch = async () => new Response("rate limited", { status: 429 });
+  t.after(() => {
+    if (previousHome === undefined) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+    if (previousXdgCacheHome === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = previousXdgCacheHome;
+    globalThis.fetch = previousFetch;
+  });
+
+  await mkdir(join(dir, ".pi", "agent"), { recursive: true });
+  await writeFile(
+    join(dir, ".pi", "agent", "auth.json"),
+    JSON.stringify({
+      anthropic: {
+        access: "expired-access-token",
+        refresh: "test-refresh-token",
+        expires: Date.now() - 60_000,
+      },
+    }),
+    { mode: 0o600 },
+  );
+
+  const futureResetAt = Math.ceil(Date.now() / 1000) + 3_600;
+  const cacheDir = join(
+    process.env.XDG_CACHE_HOME,
+    "pi-fancy-footer",
+    "provider-status",
+  );
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(
+    join(cacheDir, "anthropic.json"),
+    JSON.stringify({
+      provider: "anthropic",
+      source: "api",
+      fetchedAt: "2026-05-06T09:00:00Z",
+      state: "ok",
+      primary: {
+        label: "5h",
+        usedPercent: 5,
+        leftPercent: 95,
+        resetAt: futureResetAt,
+      },
+      url: "https://claude.ai/settings/usage",
+    }),
+    { mode: 0o600 },
+  );
+
+  const snapshots = await collectProviderStatus({} as never, {
+    ...anthropicProviderStatusConfig,
+    cacheTtlMs: 1,
+  });
+
+  assert.equal(snapshots.length, 1);
+  const snapshot = snapshots[0];
+  assert.equal(snapshot?.source, "cache");
+  assert.equal(snapshot?.state, "ok");
+  assert.equal(snapshot?.primary?.resetAt, futureResetAt);
+  assert.match(snapshot?.error ?? "", /429/);
+});
+
+test("collectProviderStatus keeps cached quota in effect regardless of the failure cause", async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), "pi-fancy-footer-test-"));
+  t.after(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  const previousHome = process.env.HOME;
+  const previousXdgCacheHome = process.env.XDG_CACHE_HOME;
+  const previousFetch = globalThis.fetch;
+  process.env.HOME = dir;
+  process.env.XDG_CACHE_HOME = join(dir, "cache");
+  // A non-retryable failure (e.g. revoked credentials) must not invalidate a
+  // quota window that has not reset yet.
+  globalThis.fetch = async () => new Response("forbidden", { status: 403 });
+  t.after(() => {
+    if (previousHome === undefined) delete process.env.HOME;
+    else process.env.HOME = previousHome;
+    if (previousXdgCacheHome === undefined) delete process.env.XDG_CACHE_HOME;
+    else process.env.XDG_CACHE_HOME = previousXdgCacheHome;
+    globalThis.fetch = previousFetch;
+  });
+
+  await mkdir(join(dir, ".pi", "agent"), { recursive: true });
+  await writeFile(
+    join(dir, ".pi", "agent", "auth.json"),
+    JSON.stringify({ anthropic: { access: "test-access-token" } }),
+    { mode: 0o600 },
+  );
+
+  const futureResetAt = Math.ceil(Date.now() / 1000) + 3_600;
+  const cacheDir = join(
+    process.env.XDG_CACHE_HOME,
+    "pi-fancy-footer",
+    "provider-status",
+  );
+  await mkdir(cacheDir, { recursive: true });
+  await writeFile(
+    join(cacheDir, "anthropic.json"),
+    JSON.stringify({
+      provider: "anthropic",
+      source: "api",
+      fetchedAt: "2026-05-06T09:00:00Z",
+      state: "ok",
+      primary: {
+        label: "5h",
+        usedPercent: 5,
+        leftPercent: 95,
+        resetAt: futureResetAt,
+      },
+      url: "https://claude.ai/settings/usage",
+    }),
+    { mode: 0o600 },
+  );
+
+  const snapshots = await collectProviderStatus({} as never, {
+    ...anthropicProviderStatusConfig,
+    cacheTtlMs: 1,
+  });
+
+  assert.equal(snapshots.length, 1);
+  const snapshot = snapshots[0];
+  assert.equal(snapshot?.source, "cache");
+  assert.equal(snapshot?.state, "ok");
+  assert.equal(snapshot?.primary?.resetAt, futureResetAt);
+  assert.match(snapshot?.error ?? "", /403/);
+});
+
 test("updateProviderStatusFromHeaders honors disabled providers", async () => {
   const updated = await updateProviderStatusFromHeaders(
     {

package/src/provider-status.ts

@@ -28,6 +28,10 @@ const CLAUDE_SECONDARY_WINDOW_LABEL = "7d";
 
 type HeaderLike = Record<string, string | number | boolean | undefined | null>;
 
+type TokenRefreshResult =
+  | { ok: true; stdout: string }
+  | { ok: false; error: Error };
+
 export interface ProviderStatusSource {
   id: string;
   label: string;
@@ -106,10 +110,7 @@ export function isProviderStatusRelevantToModel(
   providerId: string,
   model: ModelLike | string | undefined,
 ): boolean {
-  if (
-    providerId !== CODEX_SOURCE.id &&
-    providerId !== ANTHROPIC_SOURCE.id
-  ) {
+  if (providerId !== CODEX_SOURCE.id && providerId !== ANTHROPIC_SOURCE.id) {
     return true;
   }
 
@@ -238,20 +239,76 @@ async function collectProviderStatusFromSource(
     await writeProviderStatusCache(snapshot).catch(() => undefined);
     return snapshot;
   } catch (error) {
-    if (isProviderStatusFresh(cached, config.cacheTtlMs)) {
-      return { ...cached, source: "cache" };
-    }
-    return {
-      provider: source.id,
-      source: "api",
-      fetchedAt: new Date().toISOString(),
-      state: "unavailable",
-      url: source.usageUrl,
-      error: error instanceof Error ? error.message : String(error),
-    };
+    // A refresh failed. The cached quota windows remain valid until they
+    // reset, regardless of why the refresh failed, so keep showing whichever
+    // windows are still in effect.
+    return (
+      displayableCachedStatus(cached, error) ??
+      unavailableProviderStatus(source, error)
+    );
   }
 }
 
+// Projects a cached snapshot onto the windows that are still in effect, i.e.
+// have not reset yet. Returns undefined when nothing is left to display.
+function displayableCachedStatus(
+  cached: ProviderStatusSnapshot | undefined,
+  error: unknown,
+  now = new Date(),
+): ProviderStatusSnapshot | undefined {
+  if (!cached) return undefined;
+
+  const primary = windowInEffect(cached.primary, now);
+  const secondary = windowInEffect(cached.secondary, now);
+  if (!primary && !secondary) return undefined;
+
+  const {
+    primary: _expiredPrimary,
+    secondary: _expiredSecondary,
+    ...rest
+  } = cached;
+  return {
+    ...rest,
+    source: "cache",
+    state: computeProviderStatusState(primary, secondary),
+    ...(primary ? { primary } : {}),
+    ...(secondary ? { secondary } : {}),
+    error: providerStatusErrorMessage(error),
+  };
+}
+
+// A window is in effect while its reset time is still in the future. Windows
+// without a reset time have no intrinsic lifetime, so they are not shown once
+// the refresh that would confirm them has failed.
+function windowInEffect(
+  window: ProviderStatusWindow | undefined,
+  now: Date,
+): ProviderStatusWindow | undefined {
+  if (!window?.resetAt) return undefined;
+  const resetAtMs = window.resetAt * 1000;
+  return Number.isFinite(resetAtMs) && resetAtMs > now.getTime()
+    ? window
+    : undefined;
+}
+
+function unavailableProviderStatus(
+  source: ProviderStatusSource,
+  error: unknown,
+): ProviderStatusSnapshot {
+  return {
+    provider: source.id,
+    source: "api",
+    fetchedAt: new Date().toISOString(),
+    state: "unavailable",
+    url: source.usageUrl,
+    error: providerStatusErrorMessage(error),
+  };
+}
+
+function providerStatusErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
 export async function updateProviderStatusFromHeaders(
   headers: HeaderLike,
   config?: ProviderStatusConfigSnapshot,
@@ -495,7 +552,9 @@ async function resolveClaudeAuth(): Promise<AuthCredentials> {
   );
 }
 
-async function refreshIfNeeded(auth: AuthCredentials): Promise<AuthCredentials> {
+async function refreshIfNeeded(
+  auth: AuthCredentials,
+): Promise<AuthCredentials> {
   if (!auth.refreshToken || !auth.expiresAtMs) return auth;
   if (auth.expiresAtMs > Date.now() + 5 * 60 * 1000) return auth;
   return refreshAuth(auth);
@@ -522,12 +581,15 @@ async function refreshAuth(auth: AuthCredentials): Promise<AuthCredentials> {
     client_id: refreshConfig.clientId,
   }).toString();
 
-  const result = await localRefresh(body, refreshConfig.tokenUrl);
+  const result = await requestTokenRefresh(
+    body,
+    refreshConfig.tokenUrl,
+    `${refreshConfig.label} auth refresh`,
+  );
 
-  if (result.code !== 0 || !result.stdout) {
-    throw new Error(
-      result.stderr || `Failed to refresh ${refreshConfig.label} auth`,
-    );
+  if (!result.ok) throw result.error;
+  if (!result.stdout) {
+    throw new Error(`Failed to refresh ${refreshConfig.label} auth`);
   }
 
   const refreshed = JSON.parse(result.stdout) as Record<string, unknown>;
@@ -538,7 +600,8 @@ async function refreshAuth(auth: AuthCredentials): Promise<AuthCredentials> {
     );
   }
 
-  const refreshToken = stringValue(refreshed.refresh_token) ?? auth.refreshToken;
+  const refreshToken =
+    stringValue(refreshed.refresh_token) ?? auth.refreshToken;
   const expiresIn = numberValue(refreshed.expires_in);
   const next: AuthCredentials = {
     ...auth,
@@ -552,10 +615,11 @@ async function refreshAuth(auth: AuthCredentials): Promise<AuthCredentials> {
   return next;
 }
 
-async function localRefresh(
+async function requestTokenRefresh(
   body: string,
   tokenUrl: string,
-): Promise<{ code: number; stdout: string; stderr: string }> {
+  label: string,
+): Promise<TokenRefreshResult> {
   try {
     const response = await fetch(tokenUrl, {
       method: "POST",
@@ -563,13 +627,19 @@ async function localRefresh(
       body,
     });
     const text = await response.text();
-    if (!response.ok) return { code: 1, stdout: "", stderr: text };
-    return { code: 0, stdout: text, stderr: "" };
+    if (!response.ok) {
+      return {
+        ok: false,
+        error: new Error(
+          `${label} failed (${response.status}): ${text.slice(0, 500)}`,
+        ),
+      };
+    }
+    return { ok: true, stdout: text };
   } catch (error) {
     return {
-      code: -1,
-      stdout: "",
-      stderr: error instanceof Error ? error.message : String(error),
+      ok: false,
+      error: error instanceof Error ? error : new Error(String(error)),
     };
   }
 }
@@ -705,7 +775,7 @@ function mergeProviderStatus(
     ...update,
     ...(primary ? { primary } : {}),
     ...(secondary ? { secondary } : {}),
-    ...(update.credits ?? existing.credits
+    ...((update.credits ?? existing.credits)
       ? { credits: update.credits ?? existing.credits }
       : {}),
     state: computeProviderStatusState(primary, secondary),
@@ -762,7 +832,9 @@ function normalizeClaudeUsageWindow(
   );
 }
 
-function windowLabelFromSeconds(seconds: number | undefined): string | undefined {
+function windowLabelFromSeconds(
+  seconds: number | undefined,
+): string | undefined {
   if (seconds === undefined || seconds <= 0) return undefined;
   if (seconds % 86_400 === 0) return `${seconds / 86_400}d`;
   if (seconds % 3_600 === 0) return `${seconds / 3_600}h`;
@@ -854,7 +926,9 @@ function stringValue(value: unknown): string | undefined {
 }
 
 function numberValue(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
 }
 
 function numberString(value: string | undefined): number | undefined {