@scrylog/cli 0.1.4 → 0.3.0

package/src/usage/clients/anthropic-web-usage.ts

@@ -1,9 +1,12 @@
 import type { UsageClient } from "../client";
 import type { ClaudeUsageSnapshot, NamedRateWindowLegacy, ProviderCostSnapshotLegacy, RateWindowLegacy, ClaudeWebSession } from "../types";
+import { classifyUsageError, UsageError } from "../errors";
+import { usageWebSessionCache } from "../web-session-cache";
+import { CLAUDE_WEB_CACHE_KEY } from "../resolvers/claude-web";
 
-export class InvalidCredentialsError extends Error {
+export class InvalidCredentialsError extends UsageError {
   constructor(message: string) {
-    super(message);
+    super("invalid-credentials", message);
     this.name = "InvalidCredentialsError";
   }
 }
@@ -63,10 +66,12 @@ const ROUTINES_ALTERNATES = [
   "cowork",
 ];
 
-function pickWindow(data: UsageResponse, keys: string[]): { utilization?: number | null; resets_at?: string | null } | null {
+const OAUTH_APPS_ALTERNATES = ["seven_day_oauth_apps", "oauth_apps"];
+
+function pickWindowData(data: UsageResponse, keys: string[]): { utilization?: number | null; resets_at?: string | null } | null {
   for (const key of keys) {
     const val = data[key];
-    if (val && typeof val === "object" && "utilization" in val) {
+    if (val && typeof val === "object") {
       return val as { utilization?: number | null; resets_at?: string | null };
     }
   }
@@ -93,25 +98,81 @@ function toRateWindow(
 
 export class AnthropicWebUsageClient implements UsageClient<ClaudeWebSession, ClaudeUsageSnapshot> {
   async fetch(creds: ClaudeWebSession, options?: { signal?: AbortSignal }): Promise<ClaudeUsageSnapshot> {
+    const candidates: string[] = [...new Set(creds.cookieCandidates ?? (creds.cookieHeader ? [creds.cookieHeader] : []))].slice(0, 2);
+    let expectedRevision = creds.cacheRevision ?? usageWebSessionCache.observe(CLAUDE_WEB_CACHE_KEY).revision;
+
+    for (let index = 0; index < candidates.length; index++) {
+      let rotated = false;
+      try {
+        const snapshot = await this.fetchWithCookie(candidates[index]!, options?.signal, (cookieHeader) => {
+          const stored = usageWebSessionCache.store(CLAUDE_WEB_CACHE_KEY, cookieHeader, expectedRevision);
+          if (stored) expectedRevision = stored.revision;
+          rotated = true;
+        });
+        if (!rotated) {
+          const stored = usageWebSessionCache.store(CLAUDE_WEB_CACHE_KEY, candidates[index]!, expectedRevision);
+          if (stored) expectedRevision = stored.revision;
+        }
+        return snapshot;
+      } catch (error) {
+        const failure = classifyUsageError(error);
+        if (failure.kind === "invalid-credentials") {
+          if (usageWebSessionCache.clear(CLAUDE_WEB_CACHE_KEY, expectedRevision)) expectedRevision = 0;
+          if (index + 1 < candidates.length) continue;
+          // Advance the demand-driven cursor at most once per attempt, keeping
+          // the two-candidate bound across imported and rotated candidates.
+          const imported = candidates.length < 2 ? (await creds.importNext?.()) ?? null : null;
+          if (imported && !candidates.includes(imported)) {
+            candidates.push(imported);
+            continue;
+          }
+        }
+        throw failure;
+      }
+    }
+    throw new InvalidCredentialsError("Session cookie invalid or expired");
+  }
+
+  private async fetchWithCookie(
+    initialCookieHeader: string,
+    signal: AbortSignal | undefined,
+    onCookieRotation: (cookieHeader: string) => void,
+  ): Promise<ClaudeUsageSnapshot> {
+    let cookieHeader = initialCookieHeader;
+    const request = async (url: string): Promise<Response> => {
+      let response: Response;
+      try {
+        response = await fetch(url, {
+          signal,
+          headers: { Cookie: cookieHeader, Accept: "application/json" },
+        });
+      } catch (error) {
+        throw classifyUsageError(error);
+      }
+      const rotated = applyClaudeSessionRotation(cookieHeader, response.headers);
+      if (rotated !== cookieHeader) {
+        cookieHeader = rotated;
+        onCookieRotation(cookieHeader);
+      }
+      return response;
+    };
+
     // 1. Fetch organizations
-    const orgRes = await fetch("https://claude.ai/api/organizations", {
-      signal: options?.signal,
-      headers: {
-        Cookie: creds.cookieHeader,
-        Accept: "application/json",
-      },
-    });
+    const orgRes = await request("https://claude.ai/api/organizations");
 
-    if (orgRes.status === 401 || orgRes.status === 403) {
+    if (orgRes.status === 401) {
       throw new InvalidCredentialsError("Session cookie invalid or expired");
     }
+    if (orgRes.status === 403) throw new UsageError("forbidden", "Organizations access forbidden");
+    if (orgRes.status === 429) throw new UsageError("rate-limited", "Organizations fetch rate limited");
+    if (orgRes.status >= 500) throw new UsageError("transient", `Organizations fetch failed: ${orgRes.status}`);
     if (!orgRes.ok) {
-      throw new Error(`Organizations fetch failed: ${orgRes.status}`);
+      throw new UsageError("invalid-response", `Organizations fetch failed: ${orgRes.status}`);
     }
 
     const orgs = (await orgRes.json()) as Org[];
     if (!Array.isArray(orgs) || orgs.length === 0) {
-      throw new Error("No organizations found");
+      throw new UsageError("invalid-response", "No organizations found");
     }
 
     // Select org
@@ -124,37 +185,42 @@ export class AnthropicWebUsageClient implements UsageClient<ClaudeWebSession, Cl
     }
 
     // 2. Fetch usage
-    const usageRes = await fetch(`https://claude.ai/api/organizations/${org.uuid}/usage`, {
-      signal: options?.signal,
-      headers: {
-        Cookie: creds.cookieHeader,
-        Accept: "application/json",
-      },
-    });
+    const usageRes = await request(`https://claude.ai/api/organizations/${org.uuid}/usage`);
 
-    if (usageRes.status === 401 || usageRes.status === 403) {
+    if (usageRes.status === 401) {
       throw new InvalidCredentialsError("Session cookie invalid or expired");
     }
+    if (usageRes.status === 403) throw new UsageError("forbidden", "Usage access forbidden");
+    if (usageRes.status === 429) throw new UsageError("rate-limited", "Usage fetch rate limited");
+    if (usageRes.status >= 500) throw new UsageError("transient", `Usage fetch failed: ${usageRes.status}`);
     if (!usageRes.ok) {
-      throw new Error(`Usage fetch failed: ${usageRes.status}`);
+      throw new UsageError("invalid-response", `Usage fetch failed: ${usageRes.status}`);
     }
 
     const data = (await usageRes.json()) as UsageResponse;
 
-    if (!data.five_hour || typeof data.five_hour.utilization !== "number") {
-      throw new Error("Missing five_hour.utilization");
-    }
+    // Null or missing windows mean "no usage recorded for the period" — a
+    // valid response, presented as an empty window at 0% (matches the
+    // reference implementation's "100% left" presentation).
+    const primaryWindow = pickWindowData(data, ["five_hour"]);
+    const secondaryWindow = pickWindowData(data, ["seven_day"]);
 
-    const primary = toRateWindow(data.five_hour.utilization, data.five_hour.resets_at, 300);
-    const secondary = data.seven_day
-      ? toRateWindow(data.seven_day.utilization, data.seven_day.resets_at, 10080)
+    const primary = toRateWindow(
+      primaryWindow && typeof primaryWindow.utilization === "number" ? primaryWindow.utilization : 0,
+      primaryWindow?.resets_at ?? null,
+      300,
+    );
+    const secondary = secondaryWindow && typeof secondaryWindow.utilization === "number"
+      ? toRateWindow(secondaryWindow.utilization, secondaryWindow.resets_at, 10080)
       : null;
 
-    const opusWindow = pickWindow(data, ["seven_day_sonnet", "seven_day_opus"]);
-    const opus = opusWindow ? toRateWindow(opusWindow.utilization, opusWindow.resets_at, 10080) : null;
+    const opusWindow = pickWindowData(data, ["seven_day_sonnet", "seven_day_opus"]);
+    const opus = opusWindow && typeof opusWindow.utilization === "number"
+      ? toRateWindow(opusWindow.utilization, opusWindow.resets_at, 10080)
+      : null;
 
     const extraRateWindows: NamedRateWindowLegacy[] = [];
-    const designWindow = pickWindow(data, DESIGN_ALTERNATES);
+    const designWindow = pickWindowData(data, DESIGN_ALTERNATES);
     if (designWindow && typeof designWindow.utilization === "number") {
       extraRateWindows.push({
         id: "claude-design",
@@ -162,7 +228,7 @@ export class AnthropicWebUsageClient implements UsageClient<ClaudeWebSession, Cl
         window: toRateWindow(designWindow.utilization, designWindow.resets_at, 10080),
       });
     }
-    const routinesWindow = pickWindow(data, ROUTINES_ALTERNATES);
+    const routinesWindow = pickWindowData(data, ROUTINES_ALTERNATES);
     if (routinesWindow && typeof routinesWindow.utilization === "number") {
       extraRateWindows.push({
         id: "claude-routines",
@@ -170,17 +236,19 @@ export class AnthropicWebUsageClient implements UsageClient<ClaudeWebSession, Cl
         window: toRateWindow(routinesWindow.utilization, routinesWindow.resets_at, 10080),
       });
     }
+    const oauthAppsWindow = pickWindowData(data, OAUTH_APPS_ALTERNATES);
+    if (oauthAppsWindow && typeof oauthAppsWindow.utilization === "number") {
+      extraRateWindows.push({
+        id: "claude-oauth-apps",
+        title: "OAuth Apps",
+        window: toRateWindow(oauthAppsWindow.utilization, oauthAppsWindow.resets_at, 10080),
+      });
+    }
 
     // 3. Best-effort overage
     let providerCost: ProviderCostSnapshotLegacy | null = null;
     try {
-      const overageRes = await fetch(`https://claude.ai/api/organizations/${org.uuid}/overage_spend_limit`, {
-        signal: options?.signal,
-        headers: {
-          Cookie: creds.cookieHeader,
-          Accept: "application/json",
-        },
-      });
+      const overageRes = await request(`https://claude.ai/api/organizations/${org.uuid}/overage_spend_limit`);
       if (overageRes.ok) {
         const overage = (await overageRes.json()) as OverageResponse;
         if (overage.is_enabled) {
@@ -194,22 +262,18 @@ export class AnthropicWebUsageClient implements UsageClient<ClaudeWebSession, Cl
           };
         }
       }
-    } catch {
+    } catch (error) {
+      if (classifyUsageError(error).kind === "cancelled") throw error;
       // Ignore best-effort failure
     }
 
     // 4. Best-effort account info
     let accountEmail: string | null = null;
     let accountOrganization: string | null = null;
+    let accountOrganizationId: string | null = null;
     let loginMethod: string | null = null;
     try {
-      const accountRes = await fetch("https://claude.ai/api/account", {
-        signal: options?.signal,
-        headers: {
-          Cookie: creds.cookieHeader,
-          Accept: "application/json",
-        },
-      });
+      const accountRes = await request("https://claude.ai/api/account");
       if (accountRes.ok) {
         const account = (await accountRes.json()) as AccountResponse;
         if (account.email_address) {
@@ -222,8 +286,10 @@ export class AnthropicWebUsageClient implements UsageClient<ClaudeWebSession, Cl
             loginMethod = membership.organization.rate_limit_tier;
           }
         }
+        accountOrganizationId = org.uuid;
       }
-    } catch {
+    } catch (error) {
+      if (classifyUsageError(error).kind === "cancelled") throw error;
       // Ignore best-effort failure
     }
 
@@ -237,9 +303,27 @@ export class AnthropicWebUsageClient implements UsageClient<ClaudeWebSession, Cl
       updatedAt: new Date(),
       accountEmail,
       accountOrganization,
+      accountOrganizationId,
       loginMethod,
       subscriptionType: null,
       rateLimitTier: null,
     };
   }
 }
+
+function applyClaudeSessionRotation(current: string, headers: Headers): string {
+  const values = (headers as Headers & { getSetCookie?: () => string[] }).getSetCookie?.()
+    ?? (headers.get("set-cookie") ? [headers.get("set-cookie")!] : []);
+  let sessionKey = current.split(";").map((part) => part.trim()).find((part) => part.startsWith("sessionKey="));
+  for (const value of values) {
+    const [pair, ...attributes] = value.split(";");
+    if (!pair?.trim().startsWith("sessionKey=")) continue;
+    const expired = attributes.some((attribute) => {
+      const [name, raw = ""] = attribute.trim().split("=", 2);
+      if (name?.toLowerCase() === "max-age") return Number(raw) <= 0;
+      return name?.toLowerCase() === "expires" && Date.parse(raw) <= Date.now();
+    });
+    sessionKey = expired || pair.trim() === "sessionKey=" ? undefined : pair.trim();
+  }
+  return sessionKey ?? "";
+}