@scrylog/cli 0.1.0

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

@@ -0,0 +1,245 @@
+import type { UsageClient } from "../client";
+import type { ClaudeUsageSnapshot, NamedRateWindowLegacy, ProviderCostSnapshotLegacy, RateWindowLegacy, ClaudeWebSession } from "../types";
+
+export class InvalidCredentialsError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidCredentialsError";
+  }
+}
+
+interface Org {
+  uuid: string;
+  name?: string;
+  capabilities?: string[];
+}
+
+interface UsageResponse {
+  five_hour?: { utilization?: number | null; resets_at?: string | null } | null;
+  seven_day?: { utilization?: number | null; resets_at?: string | null } | null;
+  seven_day_sonnet?: { utilization?: number | null; resets_at?: string | null } | null;
+  seven_day_opus?: { utilization?: number | null; resets_at?: string | null } | null;
+  seven_day_design?: { utilization?: number | null; resets_at?: string | null } | null;
+  seven_day_routines?: { utilization?: number | null; resets_at?: string | null } | null;
+  [key: string]: unknown;
+}
+
+interface OverageResponse {
+  monthly_credit_limit?: number;
+  currency?: string;
+  used_credits?: number;
+  is_enabled?: boolean;
+}
+
+interface AccountResponse {
+  email_address?: string;
+  memberships?: Array<{
+    organization?: {
+      uuid: string;
+      name?: string;
+      rate_limit_tier?: string;
+      billing_type?: string;
+    };
+  }>;
+}
+
+const DESIGN_ALTERNATES = [
+  "seven_day_design",
+  "seven_day_claude_design",
+  "claude_design",
+  "design",
+  "seven_day_omelette",
+  "omelette",
+  "omelette_promotional",
+];
+
+const ROUTINES_ALTERNATES = [
+  "seven_day_routines",
+  "seven_day_claude_routines",
+  "claude_routines",
+  "routines",
+  "routine",
+  "seven_day_cowork",
+  "cowork",
+];
+
+function pickWindow(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) {
+      return val as { utilization?: number | null; resets_at?: string | null };
+    }
+  }
+  return null;
+}
+
+function toRateWindow(
+  utilization: number | null | undefined,
+  resetsAt: string | null | undefined,
+  windowMinutes: number,
+): RateWindowLegacy {
+  const usedPercent = typeof utilization === "number" ? Math.max(0, Math.min(100, utilization)) : 0;
+  const resetsAtDate = resetsAt ? new Date(resetsAt) : null;
+  const resetDescription = resetsAtDate && !Number.isNaN(resetsAtDate.getTime())
+    ? resetsAtDate.toLocaleString()
+    : null;
+  return {
+    usedPercent,
+    windowMinutes,
+    resetsAt: resetsAtDate && !Number.isNaN(resetsAtDate.getTime()) ? resetsAtDate : null,
+    resetDescription,
+  };
+}
+
+export class AnthropicWebUsageClient implements UsageClient<ClaudeWebSession, ClaudeUsageSnapshot> {
+  async fetch(creds: ClaudeWebSession, options?: { signal?: AbortSignal }): Promise<ClaudeUsageSnapshot> {
+    // 1. Fetch organizations
+    const orgRes = await fetch("https://claude.ai/api/organizations", {
+      signal: options?.signal,
+      headers: {
+        Cookie: creds.cookieHeader,
+        Accept: "application/json",
+      },
+    });
+
+    if (orgRes.status === 401 || orgRes.status === 403) {
+      throw new InvalidCredentialsError("Session cookie invalid or expired");
+    }
+    if (!orgRes.ok) {
+      throw new Error(`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");
+    }
+
+    // Select org
+    let org = orgs.find((o) => o.capabilities?.includes("chat"));
+    if (!org) {
+      org = orgs.find((o) => JSON.stringify(o.capabilities) !== '["api"]');
+    }
+    if (!org) {
+      org = orgs[0];
+    }
+
+    // 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",
+      },
+    });
+
+    if (usageRes.status === 401 || usageRes.status === 403) {
+      throw new InvalidCredentialsError("Session cookie invalid or expired");
+    }
+    if (!usageRes.ok) {
+      throw new Error(`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");
+    }
+
+    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)
+      : null;
+
+    const opusWindow = pickWindow(data, ["seven_day_sonnet", "seven_day_opus"]);
+    const opus = opusWindow ? toRateWindow(opusWindow.utilization, opusWindow.resets_at, 10080) : null;
+
+    const extraRateWindows: NamedRateWindowLegacy[] = [];
+    const designWindow = pickWindow(data, DESIGN_ALTERNATES);
+    if (designWindow && typeof designWindow.utilization === "number") {
+      extraRateWindows.push({
+        id: "claude-design",
+        title: "Designs",
+        window: toRateWindow(designWindow.utilization, designWindow.resets_at, 10080),
+      });
+    }
+    const routinesWindow = pickWindow(data, ROUTINES_ALTERNATES);
+    if (routinesWindow && typeof routinesWindow.utilization === "number") {
+      extraRateWindows.push({
+        id: "claude-routines",
+        title: "Daily Routines",
+        window: toRateWindow(routinesWindow.utilization, routinesWindow.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",
+        },
+      });
+      if (overageRes.ok) {
+        const overage = (await overageRes.json()) as OverageResponse;
+        if (overage.is_enabled) {
+          providerCost = {
+            used: (overage.used_credits ?? 0) / 100,
+            limit: (overage.monthly_credit_limit ?? 0) / 100,
+            currencyCode: (overage.currency || "USD").trim() || "USD",
+            period: "Monthly",
+            resetsAt: null,
+            updatedAt: new Date(),
+          };
+        }
+      }
+    } catch {
+      // Ignore best-effort failure
+    }
+
+    // 4. Best-effort account info
+    let accountEmail: string | null = null;
+    let accountOrganization: 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",
+        },
+      });
+      if (accountRes.ok) {
+        const account = (await accountRes.json()) as AccountResponse;
+        if (account.email_address) {
+          accountEmail = account.email_address.trim();
+        }
+        const membership = account.memberships?.find((m) => m.organization?.uuid === org.uuid);
+        if (membership?.organization?.name) {
+          accountOrganization = membership.organization.name;
+          if (membership.organization.rate_limit_tier) {
+            loginMethod = membership.organization.rate_limit_tier;
+          }
+        }
+      }
+    } catch {
+      // Ignore best-effort failure
+    }
+
+    return {
+      source: "web",
+      primary,
+      secondary,
+      opus,
+      extraRateWindows,
+      providerCost,
+      updatedAt: new Date(),
+      accountEmail,
+      accountOrganization,
+      loginMethod,
+      subscriptionType: null,
+      rateLimitTier: null,
+    };
+  }
+}

package/src/usage/clients/claude-cli-probe.ts

@@ -0,0 +1,187 @@
+import { spawn } from "node:child_process";
+import type { UsageClient } from "../client";
+import type { ClaudeUsageSnapshot, RateWindowLegacy } from "../types";
+
+export class TimeoutError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+}
+
+function parseResetDate(text: string): Date | null {
+  // Patterns:
+  // "Resets at 8:00PM PDT"
+  // "Resets at 8:00 PM PDT"
+  // "Resets at Apr 28 at 8:00PM PDT"
+  // "Resets at Apr 28 at 8:00 PM PDT"
+  const match = text.match(/Resets at (.+?)(?:\s*\(([^)]+)\))?$/i);
+  if (!match) return null;
+  const datePart = match[1]!.trim();
+  const tz = match[2] || undefined;
+  try {
+    const d = new Date(datePart);
+    if (!Number.isNaN(d.getTime())) return d;
+    // Fallback: try appending current year if no year present
+    const withYear = `${datePart} ${new Date().getFullYear()}`;
+    const d2 = new Date(withYear);
+    if (!Number.isNaN(d2.getTime())) return d2;
+  } catch {
+    // ignore
+  }
+  return null;
+}
+
+function parsePercent(line: string): number | null {
+  const match = line.match(/(\d{1,3}(?:\.\d+)?)\s*%/);
+  if (!match) return null;
+  const val = Number.parseFloat(match[1]!);
+  return Number.isNaN(val) ? null : val;
+}
+
+function toRateWindow(usedPercent: number, resetText: string | null, windowMinutes: number): RateWindowLegacy {
+  const resetsAt = resetText ? parseResetDate(resetText) : null;
+  return {
+    usedPercent: Math.max(0, Math.min(100, usedPercent)),
+    windowMinutes,
+    resetsAt,
+    resetDescription: resetText,
+  };
+}
+
+function probeCli(binaryPath: string, timeoutMs: number): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let output = "";
+    let killed = false;
+
+    // Use `script` for PTY on macOS; fallback to direct spawn
+    const useScript = process.platform === "darwin";
+    const child = useScript
+      ? spawn("script", ["-q", "/dev/null", binaryPath], {
+          env: process.env,
+          stdio: ["pipe", "pipe", "pipe"],
+        })
+      : spawn(binaryPath, [], {
+          env: process.env,
+          stdio: ["pipe", "pipe", "pipe"],
+        });
+
+    const timer = setTimeout(() => {
+      killed = true;
+      child.kill("SIGTERM");
+      reject(new TimeoutError(`CLI probe timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+
+    child.stdout.on("data", (data: Buffer) => {
+      output += data.toString("utf8");
+    });
+
+    child.stderr.on("data", (data: Buffer) => {
+      output += data.toString("utf8");
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      if (!killed) reject(err);
+    });
+
+    child.on("close", () => {
+      clearTimeout(timer);
+      if (!killed) resolve(output);
+    });
+
+    // Send commands
+    child.stdin.write("/usage\n");
+    setTimeout(() => {
+      child.stdin.write("/status\n");
+      setTimeout(() => {
+        child.stdin.end();
+      }, 500);
+    }, 500);
+  });
+}
+
+export class ClaudeCliProbeClient implements UsageClient<string, ClaudeUsageSnapshot> {
+  async fetch(binaryPath: string): Promise<ClaudeUsageSnapshot> {
+    let output: string;
+    try {
+      output = await probeCli(binaryPath, 10_000);
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        // Retry with longer timeout
+        output = await probeCli(binaryPath, 24_000);
+      } else {
+        throw err;
+      }
+    }
+
+    const lines = output.split(/\r?\n/);
+
+    let primary: RateWindowLegacy | null = null;
+    let secondary: RateWindowLegacy | null = null;
+    let opus: RateWindowLegacy | null = null;
+    let accountEmail: string | null = null;
+    let accountOrganization: string | null = null;
+    let loginMethod: string | null = null;
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i]!;
+      const lower = line.toLowerCase();
+
+      if (lower.includes("account_email")) {
+        const m = line.match(/account_email[:=]\s*(.+)/i);
+        if (m) accountEmail = m[1]!.trim();
+      }
+      if (lower.includes("account_org")) {
+        const m = line.match(/account_org[:=]\s*(.+)/i);
+        if (m) accountOrganization = m[1]!.trim();
+      }
+      if (lower.includes("login_method")) {
+        const m = line.match(/login_method[:=]\s*(.+)/i);
+        if (m) loginMethod = m[1]!.trim();
+      }
+
+      if (lower.includes("current session")) {
+        const percent = parsePercent(line);
+        if (percent !== null) {
+          const used = Math.max(0, Math.min(100, 100 - percent));
+          const resetLine = lines[i + 1] || "";
+          primary = toRateWindow(used, resetLine.includes("Resets") ? resetLine.trim() : null, 300);
+        }
+      }
+
+      if (lower.includes("current week")) {
+        const percent = parsePercent(line);
+        if (percent !== null) {
+          const used = Math.max(0, Math.min(100, 100 - percent));
+          const resetLine = lines[i + 1] || "";
+          const resetText = resetLine.includes("Resets") ? resetLine.trim() : null;
+          if (lower.includes("(all models)") || lower.includes("all models")) {
+            secondary = toRateWindow(used, resetText, 10080);
+          } else if (lower.includes("opus") || lower.includes("sonnet only")) {
+            opus = toRateWindow(used, resetText, 10080);
+          }
+        }
+      }
+    }
+
+    if (!primary) {
+      throw new Error("Could not parse primary usage window from CLI output");
+    }
+
+    return {
+      source: "cli",
+      primary,
+      secondary,
+      opus,
+      extraRateWindows: [],
+      providerCost: null,
+      updatedAt: new Date(),
+      accountEmail,
+      accountOrganization,
+      loginMethod,
+      subscriptionType: null,
+      rateLimitTier: null,
+    };
+  }
+}

package/src/usage/clients/codex-oauth-usage.ts

@@ -0,0 +1,113 @@
+import type { UsageClient } from "../client";
+import type { CodexOAuthCredentials, CodexUsageSnapshot, RateWindowLegacy } from "../types";
+import { AuthenticationError, ScopeError } from "./anthropic-oauth-usage";
+
+export { AuthenticationError, ScopeError };
+
+export class ParseError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ParseError";
+  }
+}
+
+export class CodexOAuthUsageClient implements UsageClient<CodexOAuthCredentials, CodexUsageSnapshot> {
+  async fetch(creds: CodexOAuthCredentials, options?: { signal?: AbortSignal }): Promise<CodexUsageSnapshot> {
+    const baseUrl = creds.chatgptBaseUrl ?? "https://chatgpt.com";
+    const url = `${baseUrl}/backend-api/wham/usage`;
+
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${creds.accessToken}`,
+      "Content-Type": "application/json",
+    };
+    if (creds.accountId) {
+      headers["ChatGPT-Account-Id"] = creds.accountId;
+    }
+
+    const res = await fetch(url, {
+      method: "GET",
+      headers,
+      signal: options?.signal,
+    });
+
+    if (res.status === 401) {
+      throw new AuthenticationError("Codex OAuth token expired or invalid");
+    }
+    if (res.status === 403) {
+      const body = await res.text();
+      if (/scope|permission|access denied/i.test(body)) {
+        throw new ScopeError("Codex OAuth access forbidden: missing scope");
+      }
+      throw new ScopeError("Codex OAuth access forbidden");
+    }
+    if (!res.ok) {
+      throw new Error(`Codex usage server error: ${res.status}`);
+    }
+
+    const body = (await res.json()) as Record<string, unknown>;
+
+    const planType = typeof body["plan_type"] === "string" ? body["plan_type"] : null;
+
+    // Handle both rate_limit and rate_limits key names
+    const rateLimitKey = typeof body["rate_limit"] === "object" && body["rate_limit"] !== null
+      ? "rate_limit"
+      : typeof body["rate_limits"] === "object" && body["rate_limits"] !== null
+      ? "rate_limits"
+      : null;
+    const rateLimit = rateLimitKey ? (body[rateLimitKey] as Record<string, unknown> | null) : null;
+
+    if (!rateLimit) {
+      throw new ParseError("Codex usage response missing rate_limit or rate_limits");
+    }
+
+    const primaryWindow = parseWindow(rateLimit?.["primary_window"] as Record<string, unknown> | undefined);
+    const secondaryWindow = parseWindow(rateLimit?.["secondary_window"] as Record<string, unknown> | undefined);
+
+    let credits: CodexUsageSnapshot["credits"] = null;
+    if (typeof body["credits"] === "object" && body["credits"] !== null) {
+      const c = body["credits"] as Record<string, unknown>;
+      credits = {
+        hasCredits: c["has_credits"] === true,
+        unlimited: c["unlimited"] === true,
+        balance: typeof c["balance"] === "number" ? c["balance"] : null,
+      };
+    }
+
+    return {
+      source: "oauth",
+      planType,
+      primaryWindow,
+      secondaryWindow,
+      credits,
+      updatedAt: new Date(),
+      accountEmail: creds.accountEmail ?? null,
+      accountId: creds.accountId ?? null,
+    };
+  }
+}
+
+function parseWindow(raw: Record<string, unknown> | undefined): RateWindowLegacy | null {
+  if (!raw) return null;
+  const usedPercent = typeof raw["used_percent"] === "number" ? raw["used_percent"] : 0;
+  const limitWindowSeconds = typeof raw["limit_window_seconds"] === "number" ? raw["limit_window_seconds"] : undefined;
+  const resetAtRaw = typeof raw["reset_at"] === "number" ? raw["reset_at"] : typeof raw["resets_at"] === "number" ? raw["resets_at"] : undefined;
+  const resetsAt = resetAtRaw ? new Date(resetAtRaw * 1000) : null;
+  const windowMinutes = limitWindowSeconds ? Math.round(limitWindowSeconds / 60) : 300;
+  const resetDescription = resetsAt ? formatDuration(Math.max(0, resetsAt.getTime() - Date.now())) : null;
+
+  return {
+    usedPercent,
+    windowMinutes,
+    resetsAt,
+    resetDescription,
+  };
+}
+
+function formatDuration(ms: number): string {
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  if (hours > 0) return `${hours}h ${minutes % 60}m`;
+  if (minutes > 0) return `${minutes}m ${seconds % 60}s`;
+  return `${seconds}s`;
+}