@jameslovespancakes/pi-plus 1.0.11 → 1.0.13

package/src/core/anthropic/client-identity.ts

@@ -2,43 +2,15 @@ import { createHash, randomUUID } from "node:crypto";
 import { xxhash64 } from "./xxhash64.ts";
 
 /**
- * Claude Code client identity headers.
- *
- * ---------------------------------------------------------------------------
- * READ THIS BEFORE CHANGING ANYTHING HERE
- *
- * These headers make a request indistinguishable from Anthropic's official
- * Claude Code CLI. Without them Anthropic classifies the caller as a
- * third-party app and answers:
- *
- *   "Third-party apps now draw from your extra usage, not your plan limits."
- *
- * So the purpose of this file is to bill against plan limits rather than extra
- * usage. That is plausibly contrary to Anthropic's intent as stated in that
- * message, and the exposure falls on the account owner.
- *
- * It is isolated in one file, and referenced from exactly one place, so it can
- * be deleted or replaced without touching the rest of the provider. Removing it
- * does not break anything: requests keep working and bill to extra usage.
- *
- * Ported from @cortexkit/anthropic-auth-core during extraction.
- * ---------------------------------------------------------------------------
+ * Emulates Claude Code so OAuth requests use plan limits instead of extra usage.
+ * This may conflict with Anthropic's stated intent; remove this identity from
+ * the provider to opt out. Adapted from @cortexkit/anthropic-auth-core.
  */
 
 /** Pinned to the Claude Code release being imitated. */
 export const CLAUDE_CODE_VERSION = "2.1.258";
 
-/**
- * Anti-tamper checksum, replicated from the official client.
- *
- * The real CLI signs the serialised request body with xxHash64 under a fixed
- * seed and writes the low 20 bits into a `cch=` placeholder. Anthropic added
- * this so a client cannot simply assert it is Claude Code in a header: it has
- * to prove it by producing a value derived from the request itself.
- *
- * The salt and sample positions are constants in the official bundle, not
- * derivable from anything, and they will change when the CLI is updated.
- */
+/** Claude Code checksum constants. They can change between CLI releases. */
 const CCH_SEED = 0x4d659218e32a3268n;
 const CCH_SALT = "59cf53e54c78";
 const CCH_POSITIONS = [4, 7, 20];
@@ -147,15 +119,7 @@ function hasFullAgentShape(body: any): boolean {
     && !!body?.thinking && typeof body.thinking === "object";
 }
 
-/**
- * Paragraphs containing this anchor cannot sit in the top-level `system` array.
- *
- * Two lines of pi's documentation paragraph are each independently sufficient to
- * make Anthropic answer 400 "Third-party apps now draw from your extra usage".
- * The same text is accepted inside `messages`, so it is moved there. Confirmed
- * by bisection: the identical payload returns 200 with the paragraph removed and
- * 400 with it present, and entry count and payload size are not the factors.
- */
+/** Documentation paragraphs must move from `system` into `messages`. */
 const DOCS_ANCHOR = "Pi documentation";
 
 /** Lone surrogates are invalid UTF-8 and are rejected outright. */
@@ -163,14 +127,7 @@ function sanitizePrompt(text: string): string {
   return text.replace(/[\uD800-\uDFFF]/gu, "\uFFFD");
 }
 
-/**
- * Splits pi's system prompt into what may stay in `system` and what must move
- * into the first user message.
- *
- * An unrecognised prompt shape (no docs paragraph found) is moved whole, the
- * same conservative fallback the vendor uses: better to shift the entire prompt
- * into messages than to guess and trigger the 400.
- */
+/** Splits the system prompt, moving unknown shapes conservatively. */
 export function splitSystemPrompt(prompt: string): { systemText?: string; messageText: string } {
   const paragraphs = sanitizePrompt(prompt).split(/\n\n+/);
   const docs = paragraphs.filter((p) => p.includes(DOCS_ANCHOR));
@@ -183,15 +140,7 @@ export function splitSystemPrompt(prompt: string): { systemText?: string; messag
   };
 }
 
-/**
- * Inserts text as its own cache-controlled block ahead of the first user
- * message.
- *
- * A separate block rather than merged text, so the cache prefix ends before the
- * user's own words and a new conversation with a different first message still
- * reads this from cache. `cache_control` is explicit because the message-level
- * breakpoint elsewhere only covers the last user message.
- */
+/** Prepends a cache-controlled block to the first user message. */
 export function prependPromptBlock(messages: any[], text: string): void {
   const firstUser = (messages ?? []).find((m) => m?.role === "user");
   if (!firstUser || !text) return;
@@ -213,16 +162,12 @@ export function selectBetas(body: unknown, extra: string[] = []): string {
   return [...new Set(selected)].join(",");
 }
 
-/**
- * Headers presenting this client as Claude Code.
- * Merged over whatever pi already set.
- */
+/** Headers presenting this client as Claude Code. */
 export function clientIdentityHeaders(body?: unknown, existingBetas?: string): Record<string, string> {
   const incoming = (existingBetas ?? "").split(",").map((b) => b.trim()).filter(Boolean);
   return {
     "user-agent": USER_AGENT,
-    // Required: pi's Anthropic client reads this header to decide which betas
-    // to send, then puts them in the body's `betas` field.
+    // Pi copies this header into the request body's betas field.
     "anthropic-beta": selectBetas(body, incoming),
     "anthropic-version": "2023-06-01",
     "anthropic-dangerous-direct-browser-access": "true",

package/src/core/anthropic/identity.ts

@@ -0,0 +1,54 @@
+import { createHash } from "node:crypto";
+import { CLAUDE_CODE_VERSION } from "./client-identity.ts";
+
+/** Resolves the stable Claude account UUID exposed by the CLI bootstrap API. */
+
+const resolved = new Map<string, string>();
+const pending = new Map<string, Promise<string | undefined>>();
+
+function tokenKey(accessToken: string): string {
+  return createHash("sha256").update(accessToken).digest("hex");
+}
+
+/** Synchronous lookup for request routing; never starts network I/O. */
+export function cachedAnthropicAccountIdentity(accessToken: string): string | undefined {
+  return resolved.get(tokenKey(accessToken));
+}
+
+export async function anthropicAccountIdentity(
+  accessToken: string,
+  fetchImpl: typeof fetch = fetch,
+): Promise<string | undefined> {
+  if (!accessToken.startsWith("sk-ant-oat")) return undefined;
+
+  const key = tokenKey(accessToken);
+  const cached = resolved.get(key);
+  if (cached) return cached;
+  const active = pending.get(key);
+  if (active) return active;
+
+  const request = (async () => {
+    try {
+      const response = await fetchImpl("https://api.anthropic.com/api/claude_cli/bootstrap?entrypoint=cli", {
+        headers: {
+          Accept: "application/json",
+          Authorization: `Bearer ${accessToken}`,
+          "anthropic-beta": "oauth-2025-04-20",
+          "user-agent": `claude-cli/${CLAUDE_CODE_VERSION} (external, cli)`,
+        },
+        signal: AbortSignal.timeout(5_000),
+      });
+      if (!response.ok) return undefined;
+      const body = await response.json() as any;
+      const identity = body?.oauth_account?.account_uuid;
+      if (typeof identity !== "string" || !identity) return undefined;
+      resolved.set(key, identity);
+      return identity;
+    } catch {
+      return undefined;
+    }
+  })().finally(() => pending.delete(key));
+
+  pending.set(key, request);
+  return request;
+}

package/src/core/anthropic/oauth.ts

@@ -149,6 +149,8 @@ export interface RefreshOptions {
   baseDelayMs?: number;
   fetchImpl?: typeof fetch;
   now?: () => number;
+  /** Bounds the entire refresh, including retries. */
+  signal?: AbortSignal;
 }
 
 /**
@@ -172,6 +174,7 @@ export async function refreshToken(options: RefreshOptions): Promise<TokenSet> {
       const response = await doFetch(TOKEN_URL, {
         method: "POST",
         headers: TOKEN_HEADERS,
+        signal: options.signal,
         body: JSON.stringify({
           grant_type: "refresh_token",
           refresh_token: options.refreshToken,

package/src/core/anthropic/quota.ts

@@ -1,33 +1,28 @@
-import { loadAccounts, saveAccount, type Account, type QuotaSnapshot } from "./store.ts";
-import { refreshToken } from "./oauth.ts";
+import { createHash, randomUUID } from "node:crypto";
+import { closeSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { refreshAbortSignal } from "../accounts/routing.ts";
+import {
+  configPath as defaultConfigPath,
+  loadAccounts,
+  saveAccount,
+  statePath,
+  type Account,
+  type QuotaSnapshot,
+} from "./store.ts";
+import { refreshToken, type RefreshOptions, type TokenSet } from "./oauth.ts";
 
-/**
- * Quota tracking.
- *
- * There are two sources, and the cheap one is strongly preferred:
- *
- *   1. Response headers. Every `/v1/messages` reply carries the same numbers
- *      as the usage endpoint, so the account actually serving traffic keeps
- *      its snapshot current at no request cost at all.
- *   2. The usage endpoint. Only needed for accounts that are NOT serving
- *      traffic, since routing compares accounts and an idle one would
- *      otherwise never update.
- *
- * Polling used to run on a 5 minute timer regardless of activity. That is what
- * the backoff below exists for: the endpoint rate limits, it answers 429 with
- * `retry-after: 0`, and `pollQuota` reports failure as `undefined`, so the
- * throttling was invisible and simply left routing on stale data.
- */
+/** Uses free response headers first, polling only stale idle accounts. */
 
 const QUOTA_URL = "https://api.anthropic.com/api/oauth/usage";
 const TIMEOUT_MS = 10_000;
-/**
- * Selection tolerates a snapshot this old before it is worth re-polling.
- *
- * This doubles as the poll rate limiter. Polling is triggered by sending a
- * message, so this is the floor between polls however fast you type: send a
- * message after the window and it polls, send ten inside it and it polls once.
- */
+/** Refresh early enough to absorb transient OAuth rate limits before expiry. */
+export const ACCESS_REFRESH_WINDOW_MS = 4 * 60 * 60_000;
+/** Background refresh cadence; each process adds a small startup jitter. */
+export const ACCESS_REFRESH_INTERVAL_MS = 5 * 60_000;
+const REFRESH_LOCK_TTL_MS = 60_000;
+const REFRESH_JOIN_WAIT_MS = 16_000;
+/** Snapshot lifetime and minimum interval between polls. */
 export const QUOTA_FRESH_MS = 10 * 60_000;
 /** After a 429, wait at least this long before touching the endpoint again. */
 export const QUOTA_BACKOFF_MS = 15 * 60_000;
@@ -95,15 +90,8 @@ export function isFresh(quota: QuotaSnapshot | undefined, now = Date.now()): boo
 }
 
 /**
- * Reads a quota snapshot out of `/v1/messages` response headers.
- *
- * Anthropic reports utilisation here as a FRACTION (`0.16`), while the usage
- * endpoint reports a PERCENT (`16`). Verified against the same account at the
- * same moment, including matching reset timestamps. Scaling by 100 is what
- * makes the two sources comparable, so do not drop it.
- *
- * Returns undefined when the headers are absent, which is normal: they do not
- * appear on 4xx replies, and non-Anthropic transports may not expose them.
+ * Parses response quota headers. Header utilization is a fraction, while the
+ * usage endpoint returns a percentage, so header values are scaled by 100.
  */
 export function parseQuotaHeaders(
   headers: Record<string, unknown> | undefined,
@@ -145,12 +133,7 @@ export function parseQuotaHeaders(
   return { five_hour, seven_day, checkedAt: now, source: "headers" };
 }
 
-/**
- * Merges a header-derived snapshot into an account.
- *
- * Scoped per-model limits only come from the usage endpoint, so they are
- * carried over from the previous snapshot rather than dropped.
- */
+/** Merges header quota while preserving polled model limits. */
 export function applyQuotaHeaders(
   accountId: string,
   headers: Record<string, unknown> | undefined,
@@ -163,10 +146,7 @@ export function applyQuotaHeaders(
   const account = storage?.accounts.find((a) => a.id === accountId);
   if (!account) return false;
 
-  // Headers arrive on every response, but utilisation moves in whole percent
-  // steps over windows of hours. Rewriting two credential files per request to
-  // store an unchanged number is pure write amplification, and on Windows each
-  // rewrite is another chance for the rename to collide with a file lock.
+  // Skip unchanged values to avoid credential writes on every response.
   const previous = account.quota;
   const unchanged =
     previous?.five_hour?.usedPercent === fresh.five_hour?.usedPercent
@@ -177,12 +157,7 @@ export function applyQuotaHeaders(
   return true;
 }
 
-/**
- * Polls one account. Returns undefined rather than throwing on failure.
- *
- * Pass `accountId` so a 429 registers backoff; without it the caller can
- * hammer a throttled endpoint and silently keep stale quota.
- */
+/** Polls one account and records rate-limit backoff. */
 export async function pollQuota(
   accessToken: string,
   accountId?: string,
@@ -212,34 +187,208 @@ export async function pollQuota(
   }
 }
 
-/** A token good for at least a minute, refreshing and persisting if needed. */
-export async function ensureAccessToken(account: Account): Promise<string | undefined> {
-  if (account.access && typeof account.expires === "number" && Date.now() + 60_000 < account.expires) {
-    return account.access;
+export function accessTokenNeedsRefresh(account: Account, now = Date.now()): boolean {
+  return !account.access
+    || typeof account.expires !== "number"
+    || account.expires - now <= ACCESS_REFRESH_WINDOW_MS;
+}
+
+type RefreshTokenFn = (options: RefreshOptions) => Promise<TokenSet>;
+
+export interface EnsureAccessTokenOptions {
+  config?: string;
+  now?: () => number;
+  refresh?: RefreshTokenFn;
+}
+
+export interface RefreshAllQuotaOptions extends EnsureAccessTokenOptions {
+  poll?: typeof pollQuota;
+}
+
+interface RefreshLock {
+  release(): void;
+}
+
+const refreshes = new Map<string, Promise<string | undefined>>();
+
+function refreshLockPath(accountId: string, config: string): string {
+  const id = createHash("sha256").update(accountId).digest("hex").slice(0, 16);
+  return `${statePath(config)}.refresh-${id}.lock`;
+}
+
+/** Cross-process exclusion for Anthropic's rotating refresh tokens. */
+function acquireRefreshLock(accountId: string, config: string, now: number): RefreshLock | undefined {
+  const path = refreshLockPath(accountId, config);
+  const owner = randomUUID();
+  mkdirSync(dirname(path), { recursive: true });
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = openSync(path, "wx", 0o600);
+      try {
+        writeFileSync(fd, JSON.stringify({ owner, expiresAt: now + REFRESH_LOCK_TTL_MS }), "utf8");
+      } finally {
+        closeSync(fd);
+      }
+      return {
+        release() {
+          try {
+            const current = JSON.parse(readFileSync(path, "utf8"));
+            if (current?.owner === owner) rmSync(path, { force: true });
+          } catch {
+            // A stale or externally removed lock needs no cleanup.
+          }
+        },
+      };
+    } catch (error: any) {
+      if (error?.code !== "EEXIST") throw error;
+      try {
+        const current = JSON.parse(readFileSync(path, "utf8"));
+        if (Number(current?.expiresAt) > now) return undefined;
+        rmSync(path, { force: true });
+      } catch {
+        // A malformed lock is stale; remove it and retry once.
+        try { rmSync(path, { force: true }); } catch { /* best effort */ }
+      }
+    }
   }
-  if (!account.refresh) return account.access;
-
-  const refreshed = await refreshToken({ refreshToken: account.refresh, maxRetries: 0 });
-  // Persist immediately: Anthropic may rotate the refresh token, and losing the
-  // new one would invalidate the account.
-  saveAccount({
-    ...account,
-    access: refreshed.access,
-    refresh: refreshed.refresh,
-    expires: refreshed.expires,
-    lastRefreshedAt: Date.now(),
-  });
-  return refreshed.access;
+  return undefined;
 }
 
-/**
- * Refreshes stale quota for every usable account, in parallel.
- * Best-effort: a failure leaves the previous snapshot in place.
- */
-export async function refreshAllQuota(force = false): Promise<number> {
-  const storage = loadAccounts();
+function storedAccount(accountId: string, config: string): Account | undefined {
+  return loadAccounts(config)?.accounts.find((candidate) => candidate.id === accountId);
+}
+
+function usableAccess(account: Account | undefined, now: number): string | undefined {
+  return account?.access && typeof account.expires === "number" && account.expires > now
+    ? account.access
+    : undefined;
+}
+
+async function joinConcurrentRefresh(
+  account: Account,
+  config: string,
+  now: () => number,
+): Promise<string | undefined> {
+  const deadline = now() + REFRESH_JOIN_WAIT_MS;
+  while (now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    const latest = storedAccount(account.id, config);
+    const changed = latest && (
+      latest.access !== account.access
+      || latest.refresh !== account.refresh
+      || (latest.expires ?? 0) > (account.expires ?? 0) + 60_000
+    );
+    if (changed && !accessTokenNeedsRefresh(latest, now())) return latest.access;
+  }
+  return usableAccess(storedAccount(account.id, config) ?? account, now());
+}
+
+function refreshErrorMessage(error: unknown): string {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.replace(/sk-ant-[A-Za-z0-9_-]+/g, "[redacted]").slice(0, 500);
+}
+
+async function refreshAccountNow(
+  account: Account,
+  options: EnsureAccessTokenOptions,
+): Promise<string | undefined> {
+  const config = options.config ?? defaultConfigPath();
+  const now = options.now ?? Date.now;
+  const refresh = options.refresh ?? refreshToken;
+  let latest = storedAccount(account.id, config) ?? account;
+  if (!accessTokenNeedsRefresh(latest, now())) return latest.access;
+  if (!latest.refresh) return usableAccess(latest, now());
+
+  const lock = acquireRefreshLock(account.id, config, now());
+  if (!lock) return joinConcurrentRefresh(latest, config, now);
+
+  try {
+    // The lock winner re-reads so it never spends a refresh token rotated by a
+    // different process immediately before the lock was acquired.
+    latest = storedAccount(account.id, config) ?? latest;
+    if (!accessTokenNeedsRefresh(latest, now())) return latest.access;
+    if (!latest.refresh) return usableAccess(latest, now());
+
+    const sourceRefresh = latest.refresh;
+    try {
+      const refreshed = await refresh({
+        refreshToken: sourceRefresh,
+        signal: refreshAbortSignal(),
+      });
+      const current = storedAccount(account.id, config) ?? latest;
+      // A changed refresh token is a stronger, newer write. Never overwrite it
+      // with the result of an older token family.
+      if (current.refresh !== sourceRefresh) return usableAccess(current, now());
+      saveAccount({
+        ...current,
+        access: refreshed.access,
+        refresh: refreshed.refresh,
+        expires: refreshed.expires,
+        lastRefreshedAt: now(),
+        lastRefreshError: undefined,
+      }, config);
+      return refreshed.access;
+    } catch (error) {
+      const current = storedAccount(account.id, config) ?? latest;
+      if (current.refresh === sourceRefresh) {
+        saveAccount({ ...current, lastRefreshError: refreshErrorMessage(error) }, config);
+      }
+      throw error;
+    }
+  } finally {
+    lock.release();
+  }
+}
+
+/** Returns a usable token, proactively rotating it well before expiry. */
+export async function ensureAccessToken(
+  account: Account,
+  options: EnsureAccessTokenOptions = {},
+): Promise<string | undefined> {
+  const config = options.config ?? defaultConfigPath();
+  const now = options.now ?? Date.now;
+  if (!accessTokenNeedsRefresh(account, now())) return account.access;
+  if (!account.refresh) return usableAccess(account, now());
+
+  const key = `${config}\0${account.id}`;
+  const active = refreshes.get(key);
+  if (active) return active;
+  const pending = refreshAccountNow(account, options).finally(() => refreshes.delete(key));
+  refreshes.set(key, pending);
+  return pending;
+}
+
+/** Rotates every due sidecar token independently of quota freshness. */
+export async function refreshDueAccessTokens(
+  config = defaultConfigPath(),
+  options: EnsureAccessTokenOptions = {},
+): Promise<number> {
+  const now = options.now ?? Date.now;
+  const accounts = (loadAccounts(config)?.accounts ?? []).filter(
+    (account) => account.enabled !== false && account.type === "oauth" && accessTokenNeedsRefresh(account, now()),
+  );
+  const results = await Promise.all(accounts.map(async (account) => {
+    try {
+      return Boolean(await ensureAccessToken(account, { ...options, config }));
+    } catch {
+      return false;
+    }
+  }));
+  return results.filter(Boolean).length;
+}
+
+/** Refreshes due access tokens, then polls only stale quota snapshots. */
+export async function refreshAllQuota(
+  force = false,
+  config = defaultConfigPath(),
+  options: RefreshAllQuotaOptions = {},
+): Promise<number> {
+  await refreshDueAccessTokens(config, options);
+  const storage = loadAccounts(config);
   if (!storage) return 0;
-  const now = Date.now();
+  const now = options.now?.() ?? Date.now();
+  const poll = options.poll ?? pollQuota;
 
   const stale = storage.accounts.filter(
     (a) => a.enabled !== false && a.type === "oauth"
@@ -248,11 +397,16 @@ export async function refreshAllQuota(force = false): Promise<number> {
 
   const results = await Promise.all(stale.map(async (account) => {
     try {
-      const token = await ensureAccessToken(account);
+      const token = await ensureAccessToken(account, { ...options, config });
       if (!token) return false;
-      const quota = await pollQuota(token, account.id);
+      const quota = await poll(token, account.id);
       if (!quota) return false;
-      saveAccount({ ...account, quota });
+      // Do not restore the pre-refresh account snapshot here. That used to
+      // overwrite a freshly rotated access/refresh pair with the now-invalid
+      // old pair immediately after a successful quota poll.
+      const current = storedAccount(account.id, config);
+      if (!current || current.access !== token) return false;
+      saveAccount({ ...current, quota }, config);
       return true;
     } catch {
       return false;