@jameslovespancakes/pi-plus 1.0.0

package/src/services/usage-service.ts

@@ -0,0 +1,186 @@
+import { agentPath, readJson, writeJson } from "../core/store.ts";
+import { isClaudeAccount, type UsageRow } from "../core/quota/pool.ts";
+import { fetchAll } from "../core/quota/usage-source.ts";
+
+/**
+ * The single owner of subscription usage state.
+ *
+ * Previously the only poller lived inside the footer extension and was gated on
+ * `ctx.hasUI`, so `list_models` silently read empty rows whenever the footer was
+ * hidden or the session was headless (including every workflow subagent).
+ * Consumers now call `ensureFresh()` for on-demand data and `subscribe()` for
+ * push updates; only one poll is ever in flight regardless of consumer count.
+ */
+
+export const REFRESH_MS = 5 * 60 * 1000;
+const MIN_INTERVAL_MS = 90_000;
+const BACKOFF_MS = 10 * 60 * 1000;
+const CACHE_MAX_AGE_MS = 60 * 60 * 1000;
+
+export interface UsageState {
+  rows: UsageRow[];
+  errors: string[];
+  updatedAt?: number;
+  loading: boolean;
+  accounts: number;
+  codexPlan?: string;
+  /**
+   * Last time each account group's quota was observed to drop. This is the only
+   * available proxy for "recently used": providers expose remaining quota but
+   * never report which account served a request.
+   */
+  lastUsedAt?: Record<string, number>;
+}
+
+const state: UsageState = { rows: [], errors: [], loading: true, accounts: 0, lastUsedAt: {} };
+const listeners = new Set<() => void>();
+
+let nextAllowedFetch = 0;
+let inFlight: Promise<void> | undefined;
+let timer: NodeJS.Timeout | undefined;
+let started = false;
+
+function cachePath(): string {
+  return agentPath("usage-bar-cache.json");
+}
+
+/** Seed from the last session so a restart shows figures before the first fetch. */
+function loadCache(): void {
+  const cached = readJson<UsageState | undefined>(cachePath(), undefined);
+  if (!cached || !Array.isArray(cached.rows) || !cached.updatedAt) return;
+  if (Date.now() - cached.updatedAt > CACHE_MAX_AGE_MS) return;
+  state.rows = cached.rows.filter((row) => !row.group.startsWith("Claude pool ×"));
+  state.accounts = cached.accounts ?? 0;
+  state.codexPlan = cached.codexPlan;
+  state.updatedAt = cached.updatedAt;
+  state.lastUsedAt = cached.lastUsedAt ?? {};
+  state.loading = false;
+}
+
+function saveCache(): void {
+  writeJson(cachePath(), {
+    rows: state.rows,
+    accounts: state.accounts,
+    codexPlan: state.codexPlan,
+    updatedAt: state.updatedAt,
+    lastUsedAt: state.lastUsedAt,
+  });
+}
+
+loadCache();
+
+function emit(): void {
+  for (const listener of listeners) {
+    try {
+      listener();
+    } catch { /* a bad subscriber must not break the poll */ }
+  }
+}
+
+/**
+ * Stamps an account as recently used when its headline window falls. A rise
+ * (quota reset) or an unchanged figure is not a usage signal.
+ */
+function recordUsageDrops(fresh: UsageRow[]): void {
+  const previous = new Map(
+    state.rows.filter((row) => row.label === "5h").map((row) => [row.group, row.remaining]),
+  );
+  const stamps = { ...(state.lastUsedAt ?? {}) };
+  for (const row of fresh) {
+    if (row.label !== "5h") continue;
+    const before = previous.get(row.group);
+    if (before !== undefined && row.remaining < before - 0.01) stamps[row.group] = Date.now();
+  }
+  state.lastUsedAt = stamps;
+}
+
+export function usageState(): UsageState {
+  return state;
+}
+
+/**
+ * Account groups ordered by most recent observed use, capped at `limit`.
+ * Accounts never seen in use fall back to alphabetical, so the list is stable.
+ */
+export function recentAccounts(limit: number): string[] {
+  const stamps = state.lastUsedAt ?? {};
+  const groups = [...new Set(state.rows.filter(isClaudeAccount).map((row) => row.group))];
+  return groups
+    .sort((a, b) => (stamps[b] ?? 0) - (stamps[a] ?? 0) || a.localeCompare(b))
+    .slice(0, limit);
+}
+
+/** Notified after every state change. Returns an unsubscribe function. */
+export function subscribe(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+/**
+ * The endpoints are rate limited, so results are cached and refreshes are
+ * throttled. Failures keep the previous figures on screen.
+ */
+export async function refreshUsage(ctx: any, force = false): Promise<void> {
+  if (inFlight) return inFlight;
+  const now = Date.now();
+  const dueAt = Math.max(nextAllowedFetch, (state.updatedAt ?? 0) + MIN_INTERVAL_MS);
+  if (!force && state.updatedAt && now < dueAt) return;
+
+  inFlight = (async () => {
+    try {
+      const result = await fetchAll(ctx);
+      const rateLimited = result.errors.some((error) => error.includes("429"));
+      recordUsageDrops(result.rows);
+
+      // Per-account merge: groups that failed this cycle keep their last figures.
+      const freshGroups = new Set(result.rows.map((row) => row.group));
+      const retained = state.rows
+        .filter((row) => !row.group.startsWith("Claude pool ×")
+          && !freshGroups.has(row.group)
+          && (!isClaudeAccount(row) || result.groups.includes(row.group)))
+        .map((row) => ({ ...row, stale: true }));
+
+      state.rows = [...result.rows, ...retained];
+      state.accounts = result.groups.length;
+      state.updatedAt = Date.now(); // poll time only; rows retain their own checkedAt
+      state.errors = result.errors;
+      if (result.codexPlan !== undefined) state.codexPlan = result.codexPlan;
+      nextAllowedFetch = rateLimited ? Date.now() + BACKOFF_MS : 0;
+      saveCache();
+    } catch (error) {
+      state.errors = [`Usage refresh failed: ${error instanceof Error ? error.message : String(error)}`];
+    } finally {
+      state.loading = false;
+    }
+  })().finally(() => {
+    inFlight = undefined;
+    emit();
+  });
+
+  return inFlight;
+}
+
+/**
+ * Guarantees usable data for a caller that does not own the poll loop.
+ * This is what makes `list_models` correct in headless sessions.
+ */
+export async function ensureFresh(ctx: any): Promise<UsageState> {
+  const stale = !state.updatedAt || Date.now() - state.updatedAt > REFRESH_MS;
+  if (stale) await refreshUsage(ctx);
+  return state;
+}
+
+/** Starts the shared interval. Safe to call from multiple domains. */
+export function startPolling(ctx: any): void {
+  if (started) return;
+  started = true;
+  void refreshUsage(ctx);
+  timer ??= setInterval(() => void refreshUsage(ctx), REFRESH_MS);
+  timer.unref?.();
+}
+
+export function stopPolling(): void {
+  if (timer) clearInterval(timer);
+  timer = undefined;
+  started = false;
+}

package/src/ui/format.ts

@@ -0,0 +1,73 @@
+/** Presentation helpers with no domain knowledge. */
+
+export function formatTokens(count: number): string {
+  if (count < 1000) return String(count);
+  if (count < 10_000) return `${(count / 1000).toFixed(1)}k`;
+  if (count < 1_000_000) return `${Math.round(count / 1000)}k`;
+  if (count < 10_000_000) return `${(count / 1_000_000).toFixed(1)}M`;
+  return `${Math.round(count / 1_000_000)}M`;
+}
+
+export function sanitize(text: string): string {
+  return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
+}
+
+/** Keep long ids readable by trimming the middle rather than the tail. */
+export function fitId(id: string, width: number): string {
+  if (id.length <= width) return id.padEnd(width);
+  return `${id.slice(0, 12)}…${id.slice(id.length - (width - 13))}`;
+}
+
+export function formatShortReset(resetAt?: number): string {
+  if (!resetAt) return "";
+  const seconds = Math.max(0, Math.round((resetAt - Date.now()) / 1000));
+  if (seconds < 3600) return `${Math.max(1, Math.round(seconds / 60))}m`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h`;
+  return `${Math.floor(seconds / 86400)}d`;
+}
+
+export function formatReset(resetAt?: number): string {
+  if (!resetAt) return "";
+  const seconds = Math.max(0, Math.round((resetAt - Date.now()) / 1000));
+  if (seconds < 60) return "resets <1m";
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor((seconds % 86400) / 3600);
+  const minutes = Math.floor((seconds % 3600) / 60);
+  if (days > 0) return `resets ${days}d ${hours}h`;
+  if (hours > 0) return `resets ${hours}h ${minutes}m`;
+  return `resets ${minutes}m`;
+}
+
+const TRUECOLOR = /truecolor|24bit/i.test(process.env.COLORTERM ?? "") || !!process.env.WT_SESSION;
+
+export function hasTruecolor(): boolean {
+  return TRUECOLOR;
+}
+
+function hslToAnsi(hue: number, saturation: number, lightness: number): string {
+  const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+  const secondary = chroma * (1 - Math.abs(((hue / 60) % 2) - 1));
+  const match = lightness - chroma / 2;
+  const [r, g, b] = hue < 60 ? [chroma, secondary, 0]
+    : hue < 120 ? [secondary, chroma, 0]
+    : hue < 180 ? [0, chroma, secondary]
+    : hue < 240 ? [0, secondary, chroma]
+    : hue < 300 ? [secondary, 0, chroma]
+    : [chroma, 0, secondary];
+  const to255 = (value: number) => Math.round((value + match) * 255);
+  return `\u001b[38;2;${to255(r)};${to255(g)};${to255(b)}m`;
+}
+
+/** Smooth red (empty) to green (full) ramp for a 0-100 fullness value. */
+export function levelColor(remaining: number): (text: string) => string {
+  const clamped = Math.min(100, Math.max(0, remaining));
+  if (!TRUECOLOR) return (text: string) => text;
+  const hue = 120 * Math.pow(clamped / 100, 1.35);
+  const lightness = clamped <= 12 ? 0.58 : 0.48;
+  const escape = hslToAnsi(hue, 0.85, lightness);
+  return (text: string) => `${escape}${text}\u001b[39m`;
+}
+
+export function themeLevel(remaining: number): "error" | "warning" | "success" {
+  return remaining <= 10 ? "error" : remaining <= 25 ? "warning" : "success";
+}

package/src/ui/usage-bars.ts

@@ -0,0 +1,154 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { combinedWindow, isClaudeAccount, poolAvailability, scopedLabels, type UsageRow } from "../core/quota/pool.ts";
+import type { UsageState } from "../services/usage-service.ts";
+import { formatReset, formatShortReset, hasTruecolor, levelColor, themeLevel } from "./format.ts";
+
+/**
+ * Renders the Claude/Codex quota bars. Takes state as an argument rather than
+ * importing the service, so the renderer stays a pure function of its input.
+ */
+
+type Cell = { label: string; remaining?: number; resetAt?: number; partial?: boolean };
+
+function pooled(state: UsageState, label: string): Cell | undefined {
+  return combinedWindow(state.rows, label, state.accounts, Date.now(), true);
+}
+
+function codexCell(state: UsageState, display: string, match: (label: string) => boolean): Cell | undefined {
+  const row = state.rows.find((candidate) => candidate.group === "Codex" && match(candidate.label));
+  return row ? { label: display, remaining: row.remaining, resetAt: row.resetAt } : { label: display };
+}
+
+/**
+ * Turns a scoped limit id into something that fits the label column.
+ *
+ * Anthropic names these with an internal id, e.g.
+ * `7d claude-weekly-scoped-fable`. Rendered raw it was truncated to the 6
+ * column label width and came out as "claude", which named neither the window
+ * nor the model. The trailing segment is the model family, so that is what is
+ * shown.
+ */
+function scopedDisplayName(label: string): string {
+  const family = label.replace(/^7d\s+/, "").split("-").pop() ?? label;
+  return family.charAt(0).toUpperCase() + family.slice(1);
+}
+
+function buildColumns(state: UsageState, modelId?: string): { claude: Cell[]; codex: Cell[] } {
+  // Three fixed tiers, so the block keeps its shape whether or not a scoped
+  // limit is currently reported.
+  const scoped = scopedLabels(state.rows, modelId)[0];
+  const scopedCell = scoped
+    ? { ...(pooled(state, scoped) ?? { label: scoped }), label: scopedDisplayName(scoped) }
+    : { label: "Fable" };
+
+  const claude: Cell[] = [
+    { ...(pooled(state, "5h") ?? { label: "5h" }), label: "5h" },
+    { ...(pooled(state, "7d") ?? { label: "7d" }), label: "weekly" },
+    scopedCell,
+  ];
+
+  // Codex reports only the two windows; it has no scoped equivalent.
+  const codex: Cell[] = [
+    codexCell(state, "5h", (label) => label === "5h") ?? { label: "5h" },
+    codexCell(state, "weekly", (label) => label === "weekly") ?? { label: "weekly" },
+  ];
+  return { claude, codex };
+}
+
+/** `Work 61% · Personal 88%`. Empty when there is nothing extra to say. */
+function renderAccountSummary(state: UsageState, cellWidth: number): string | undefined {
+  const stamps = state.lastUsedAt ?? {};
+  const groups = [...new Set(state.rows.filter(isClaudeAccount).map((row) => row.group))];
+  if (groups.length < 2) return undefined;
+
+  const ordered = groups.sort((a, b) => (stamps[b] ?? 0) - (stamps[a] ?? 0) || a.localeCompare(b));
+  const shown = ordered.slice(0, 2);
+
+  const parts = shown.map((group) => {
+    const row = state.rows.find((candidate) => candidate.group === group && candidate.label === "5h");
+    const name = group.replace(/^Claude /, "");
+    if (!row) return `${name} -`;
+    return `${name} ${Math.round(row.remaining)}%${row.stale ? "*" : ""}`;
+  });
+
+  const hidden = ordered.length - shown.length;
+  const text = parts.join(" · ") + (hidden > 0 ? ` +${hidden}` : "");
+  return text.length > cellWidth * 2 ? text.slice(0, cellWidth * 2) : text;
+}
+
+function renderCell(theme: any, cell: Cell, labelWidth: number, cellWidth: number): string {
+  const label = cell.label.slice(0, labelWidth).padEnd(labelWidth);
+  const reset = formatShortReset(cell.resetAt);
+  const resetWidth = 4;
+  const barWidth = Math.max(4, cellWidth - labelWidth - 6 - resetWidth - 3);
+
+  if (cell.remaining === undefined) {
+    return `${theme.fg("muted", label)} ${theme.fg("dim", "·".repeat(barWidth))} ${theme.fg("dim", "  n/a")}${" ".repeat(resetWidth + 1)}`;
+  }
+
+  const filled = Math.round((cell.remaining / 100) * barWidth);
+  const percentText = `${cell.partial ? "~" : ""}${Math.round(cell.remaining)}%`.padStart(5);
+  let bar: string;
+  let percent: string;
+
+  if (hasTruecolor()) {
+    // One smooth hue per bar: green when full, amber mid-way, red as it empties.
+    const paint = levelColor(cell.remaining);
+    bar = paint("█".repeat(filled)) + theme.fg("dim", "░".repeat(barWidth - filled));
+    percent = paint(percentText);
+  } else {
+    const color = themeLevel(cell.remaining);
+    bar = theme.fg(color, "█".repeat(filled)) + theme.fg("dim", "░".repeat(barWidth - filled));
+    percent = theme.fg(color, percentText);
+  }
+
+  return `${theme.fg("muted", label)} ${bar} ${percent} ${theme.fg("dim", reset.padEnd(resetWidth))}`;
+}
+
+export function renderUsageLines(state: UsageState, theme: any, width: number, modelId?: string): string[] {
+  if (state.loading) return [theme.fg("dim", "  usage: loading…")];
+  if (state.rows.length === 0) {
+    if (state.errors.length > 0) return state.errors.map((error) => theme.fg("warning", `  ${error}`));
+    return [theme.fg("dim", "  usage: unavailable")];
+  }
+
+  const gap = 3;
+  const cellWidth = Math.max(22, Math.floor((width - 2 - gap) / 2));
+  const labelWidth = 6;
+  const { claude, codex } = buildColumns(state, modelId);
+  const availability = poolAvailability(state.rows, state.accounts, modelId);
+  const status = availability.ready
+    ? `${availability.ready}/${availability.total} ready`
+    : availability.unknown ? "unknown/stale" : "exhausted";
+  const partial = claude.some((cell) => cell.partial);
+  const claudeTitle = `Claude Σ${state.accounts} · ${status}${partial ? " · partial" : ""}`;
+  const codexTitle = state.codexPlan ? `Codex · ${state.codexPlan}` : "Codex";
+  const lines = [`  ${theme.fg("accent", claudeTitle.padEnd(cellWidth))}${" ".repeat(gap)}${theme.fg("accent", codexTitle)}`];
+
+  for (let index = 0; index < Math.max(claude.length, codex.length); index += 1) {
+    const left = claude[index] ? renderCell(theme, claude[index], labelWidth, cellWidth) : " ".repeat(cellWidth);
+    const right = codex[index] ? renderCell(theme, codex[index], labelWidth, cellWidth) : "";
+    lines.push(`  ${left}${" ".repeat(gap)}${right}`);
+  }
+
+  // Per-account detail. With more than two accounts only the two most recently
+  // used are shown, so the footer stays two lines regardless of pool size.
+  const accountLine = renderAccountSummary(state, cellWidth);
+  if (accountLine) lines.push(`  ${theme.fg("dim", accountLine)}`);
+
+  for (const error of state.errors) lines.push(theme.fg("warning", `  ${error}`));
+  return lines.map((line) => truncateToWidth(line, width, ""));
+}
+
+export function usageSummaryText(state: UsageState): string {
+  const combined = ["5h", "7d", ...scopedLabels(state.rows)].map((label) => {
+    const pool = combinedWindow(state.rows, label, state.accounts, Date.now(), true);
+    return `Claude combined ${label}: ${pool
+      ? `${pool.partial ? "~" : ""}${Math.round(pool.remaining)}% left${pool.partial ? " (partial: reporting accounts only)" : ""} ${formatReset(pool.resetAt)}`
+      : "unknown/stale"}`;
+  });
+  const summary = [...combined, ...state.rows.map(
+    (row: UsageRow) => `${row.group} ${row.label}: ${Math.round(row.remaining)}% left ${formatReset(row.resetAt)}${row.stale ? " (stale)" : ""}`.trim(),
+  )];
+  return [...summary, ...state.errors].join("\n") || "No usage data";
+}

package/src/vendor/anthropic.ts

@@ -0,0 +1,109 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+/**
+ * The single import point for `@cortexkit/anthropic-auth-core`.
+ *
+ * Nothing else in this repo may reach into the pi-managed npm tree. The old
+ * code hardcoded `../npm/node_modules/@cortexkit/...` relative to the
+ * extension file, which broke whenever an extension moved directory depth.
+ * Resolving from the agent dir at runtime makes placement irrelevant.
+ */
+
+function agentDir(): string {
+  return process.env.PI_AGENT_DIR ?? join(homedir(), ".pi", "agent");
+}
+
+function coreEntry(): string {
+  return pathToFileURL(
+    join(agentDir(), "npm", "node_modules", "@cortexkit", "anthropic-auth-core", "dist", "index.js"),
+  ).href;
+}
+
+export interface AnthropicAccount {
+  id: string;
+  label?: string;
+  type: string;
+  enabled?: boolean;
+  access?: string;
+  refresh?: string;
+  expires?: number;
+  addedAt?: number;
+  lastRefreshedAt?: number;
+  authLineageId?: string;
+}
+
+export interface AccountStorage {
+  accounts: AnthropicAccount[];
+}
+
+interface AnthropicCore {
+  addAccountPersistent(account: AnthropicAccount, path: string): Promise<void>;
+  loadAccounts(path: string): Promise<AccountStorage | undefined>;
+  authorize(mode: string): Promise<{ url: string; verifier: string; redirectUri: string; state: string }>;
+  exchange(
+    callback: string,
+    verifier: string,
+    redirectUri: string,
+    state: string,
+  ): Promise<{ type: string; access: string; refresh: string; expires: number }>;
+  refreshClaudeOAuthToken(options: {
+    refreshToken: string;
+    maxRetries?: number;
+    fetchImpl?: typeof fetch;
+  }): Promise<{ access: string; refresh: string; expires: number }>;
+  getRoutingMode(storage: unknown): string;
+  setRoutingMode(mode: string, path: string): Promise<unknown>;
+}
+
+let cached: Promise<AnthropicCore> | undefined;
+
+/** Lazily loads and memoizes the vendor core module. */
+export function core(): Promise<AnthropicCore> {
+  cached ??= import(coreEntry()).then((module) => module as unknown as AnthropicCore).catch((error) => {
+    cached = undefined;
+    throw new Error(
+      `@cortexkit/anthropic-auth-core is unavailable (${error instanceof Error ? error.message : String(error)}). `
+      + "Reinstall with: pi package add @cortexkit/pi-anthropic-auth",
+    );
+  });
+  return cached;
+}
+
+/** Where the multi-account OAuth store lives. */
+export function accountStoragePath(): string {
+  return process.env.PI_ANTHROPIC_AUTH_FILE ?? join(agentDir(), "anthropic-auth.json");
+}
+
+export async function loadAccounts(): Promise<AccountStorage | undefined> {
+  return (await core()).loadAccounts(accountStoragePath());
+}
+
+export async function saveAccount(account: AnthropicAccount): Promise<void> {
+  return (await core()).addAccountPersistent(account, accountStoragePath());
+}
+
+export async function refreshToken(
+  refreshTokenValue: string,
+  options: { maxRetries?: number; timeoutMs?: number } = {},
+): Promise<{ access: string; refresh: string; expires: number }> {
+  const { refreshClaudeOAuthToken } = await core();
+  return refreshClaudeOAuthToken({
+    refreshToken: refreshTokenValue,
+    maxRetries: options.maxRetries,
+    fetchImpl: options.timeoutMs
+      ? (input, init) => fetch(input, { ...init, signal: AbortSignal.timeout(options.timeoutMs!) })
+      : undefined,
+  });
+}
+
+export async function routingMode(): Promise<string> {
+  const { getRoutingMode } = await core();
+  return getRoutingMode(await loadAccounts());
+}
+
+export async function setRoutingMode(mode: "sticky-balanced" | "main-first"): Promise<string> {
+  const { setRoutingMode: apply, getRoutingMode } = await core();
+  return getRoutingMode(await apply(mode, accountStoragePath()));
+}