@scrylog/cli 0.1.0

package/src/usage/clients/opencode-go-usage.ts

@@ -0,0 +1,441 @@
+import type { UsageClient } from "../client";
+import type { OpenCodeGoUsageSnapshot } from "../types";
+import { InvalidCredentialsError } from "../clients/anthropic-web-usage";
+import { ParseError } from "../clients/anthropic-oauth-usage";
+
+function randomUuid(): string {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === "x" ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+function isSignedOut(text: string): boolean {
+  const lower = text.toLowerCase();
+  const indicators = ["login", "sign in", "auth/authorize", "not associated with an account", 'actor of type "public"'];
+  return indicators.some((ind) => lower.includes(ind.toLowerCase()));
+}
+
+function extractWorkspaceIds(text: string): string[] {
+  const ids: string[] = [];
+  // Strategy 1: regex
+  const regex = /id\s*:\s*"(wrk_[^"]+)"/g;
+  let m: RegExpExecArray | null;
+  while ((m = regex.exec(text))) {
+    ids.push(m[1]!);
+  }
+  if (ids.length > 0) return ids;
+
+  // Strategy 2: JSON traversal
+  try {
+    const data = JSON.parse(text);
+    function walk(obj: unknown): void {
+      if (typeof obj === "string" && obj.startsWith("wrk_") && obj.length > 4) {
+        ids.push(obj);
+      } else if (Array.isArray(obj)) {
+        for (const item of obj) walk(item);
+      } else if (obj && typeof obj === "object") {
+        for (const v of Object.values(obj)) walk(v);
+      }
+    }
+    walk(data);
+  } catch {
+    // ignore
+  }
+
+  return ids;
+}
+
+function extractWorkspace(text: string): { id: string; name: string | null } | null {
+  // Try to extract id + name from the same object pattern
+  const regex = /id\s*:\s*"(wrk_[^"]+)"(?:\s*,\s*name\s*:\s*"([^"]*)")?/;
+  const m = regex.exec(text);
+  if (m) {
+    return { id: m[1]!, name: m[2] || null };
+  }
+
+  // Fallback to ids only
+  const ids = extractWorkspaceIds(text);
+  if (ids.length > 0) {
+    return { id: ids[0]!, name: null };
+  }
+
+  return null;
+}
+
+interface WindowCandidate {
+  percent: number;
+  resetInSec: number;
+  path: string;
+}
+
+function findCandidates(obj: unknown, path = "", depth = 0): WindowCandidate[] {
+  if (depth > 10 || !obj || typeof obj !== "object") return [];
+  const candidates: WindowCandidate[] = [];
+
+  if (Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      candidates.push(...findCandidates(obj[i], `${path}[${i}]`, depth + 1));
+    }
+    return candidates;
+  }
+
+  const record = obj as Record<string, unknown>;
+  const keys = Object.keys(record);
+
+  // Check if this object is a candidate
+  const percentKeys = [
+    "usagePercent",
+    "usedPercent",
+    "percentUsed",
+    "percent",
+    "usage_percent",
+    "used_percent",
+    "utilization",
+    "utilizationPercent",
+    "utilization_percent",
+    "usage",
+  ];
+  const resetSecKeys = [
+    "resetInSec",
+    "resetInSeconds",
+    "resetSeconds",
+    "reset_sec",
+    "reset_in_sec",
+    "resetsInSec",
+    "resetsInSeconds",
+    "resetIn",
+    "resetSec",
+  ];
+  const resetTsKeys = [
+    "resetAt",
+    "resetsAt",
+    "reset_at",
+    "resets_at",
+    "nextReset",
+    "next_reset",
+    "renewAt",
+    "renew_at",
+  ];
+  const usedKeys = ["used", "usage", "consumed", "count", "usedTokens"];
+  const limitKeys = ["limit", "total", "quota", "max", "cap", "tokenLimit"];
+
+  let percent: number | null = null;
+  let resetInSec = 0;
+
+  for (const key of keys) {
+    const val = record[key];
+    if (percentKeys.includes(key) && (typeof val === "number" || typeof val === "string")) {
+      const n = typeof val === "string" ? Number.parseFloat(val) : val;
+      if (!Number.isNaN(n)) percent = n;
+    }
+    if (resetSecKeys.includes(key) && typeof val === "number") {
+      resetInSec = val;
+    }
+    if (resetTsKeys.includes(key) && (typeof val === "number" || typeof val === "string")) {
+      if (typeof val === "number") {
+        const ts = val > 1_000_000_000_000 ? val / 1000 : val;
+        resetInSec = Math.max(0, Math.round(ts - Date.now() / 1000));
+      } else {
+        const d = new Date(val);
+        if (!Number.isNaN(d.getTime())) {
+          resetInSec = Math.max(0, Math.round(d.getTime() / 1000 - Date.now() / 1000));
+        }
+      }
+    }
+    if (usedKeys.includes(key) && typeof val === "number" && percent === null) {
+      const limitVal = keys.find((k) => limitKeys.includes(k));
+      if (limitVal && typeof record[limitVal] === "number" && record[limitVal]! > 0) {
+        percent = (val / (record[limitVal] as number)) * 100;
+      }
+    }
+  }
+
+  if (percent !== null) {
+    let p = percent <= 1 && percent >= 0 ? percent * 100 : percent;
+    p = Math.max(0, Math.min(100, p));
+    candidates.push({ percent: p, resetInSec, path });
+  }
+
+  // Recurse
+  for (const [key, val] of Object.entries(record)) {
+    candidates.push(...findCandidates(val, path ? `${path}.${key}` : key, depth + 1));
+  }
+
+  return candidates;
+}
+
+function classifyCandidates(candidates: WindowCandidate[]): {
+  rolling: WindowCandidate | null;
+  weekly: WindowCandidate | null;
+  monthly: WindowCandidate | null;
+} {
+  let rolling: WindowCandidate | null = null;
+  let weekly: WindowCandidate | null = null;
+  let monthly: WindowCandidate | null = null;
+  const used = new Set<number>();
+
+  for (let i = 0; i < candidates.length; i++) {
+    if (used.has(i)) continue;
+    const c = candidates[i]!;
+    const lowerPath = c.path.toLowerCase();
+    if (
+      lowerPath.includes("rolling") ||
+      lowerPath.includes("hour") ||
+      lowerPath.includes("5h") ||
+      lowerPath.includes("5-hour")
+    ) {
+      if (!rolling || c.resetInSec < rolling.resetInSec || (c.resetInSec === rolling.resetInSec && c.percent > rolling.percent)) {
+        if (rolling) used.add(candidates.indexOf(rolling));
+        rolling = c;
+        used.add(i);
+      }
+    } else if (lowerPath.includes("weekly") || lowerPath.includes("week")) {
+      if (!weekly || c.resetInSec > weekly.resetInSec || (c.resetInSec === weekly.resetInSec && c.percent > weekly.percent)) {
+        if (weekly) used.add(candidates.indexOf(weekly));
+        weekly = c;
+        used.add(i);
+      }
+    } else if (lowerPath.includes("monthly") || lowerPath.includes("month")) {
+      if (!monthly || c.resetInSec > monthly.resetInSec || (c.resetInSec === monthly.resetInSec && c.percent > monthly.percent)) {
+        if (monthly) used.add(candidates.indexOf(monthly));
+        monthly = c;
+        used.add(i);
+      }
+    }
+  }
+
+  // If still missing, assign remaining candidates by resetInSec heuristic
+  const remaining = candidates.filter((_, i) => !used.has(i));
+  remaining.sort((a, b) => a.resetInSec - b.resetInSec);
+  if (!rolling && remaining.length > 0) {
+    rolling = remaining.shift()!;
+  }
+  if (!weekly && remaining.length > 0) {
+    weekly = remaining.pop()!;
+  }
+  if (!monthly && remaining.length > 0) {
+    monthly = remaining.pop()!;
+  }
+
+  return { rolling, weekly, monthly };
+}
+
+function parseSubscriptionPage(text: string): {
+  rollingPercent: number;
+  weeklyPercent: number;
+  monthlyPercent: number;
+  rollingReset: number;
+  weeklyReset: number;
+  monthlyReset: number;
+  hasMonthly: boolean;
+} {
+  if (isSignedOut(text)) {
+    throw new InvalidCredentialsError("Session is signed out");
+  }
+
+  // Strategy 1: JSON direct lookup
+  let data: unknown;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    data = null;
+  }
+
+  if (data && typeof data === "object") {
+    const record = data as Record<string, unknown>;
+    const nestedKeys = ["data", "result", "usage", "billing", "payload"];
+
+    const rollingKeys = ["rollingUsage", "rolling", "rolling_usage", "rollingWindow", "rolling_window"];
+    const weeklyKeys = ["weeklyUsage", "weekly", "weekly_usage", "weeklyWindow", "weekly_window"];
+    const monthlyKeys = ["monthlyUsage", "monthly", "monthly_usage", "monthlyWindow", "monthly_window"];
+
+    function getVal(root: Record<string, unknown>, keys: string[]): unknown {
+      for (const k of keys) {
+        if (k in root) return root[k];
+      }
+      for (const nk of nestedKeys) {
+        const nested = root[nk];
+        if (nested && typeof nested === "object") {
+          for (const k of keys) {
+            if (k in (nested as Record<string, unknown>)) return (nested as Record<string, unknown>)[k];
+          }
+        }
+      }
+      return undefined;
+    }
+
+    const rollingVal = getVal(record, rollingKeys);
+    const weeklyVal = getVal(record, weeklyKeys);
+    const monthlyVal = getVal(record, monthlyKeys);
+
+    if (rollingVal !== undefined && weeklyVal !== undefined) {
+      function extractPercent(v: unknown): number {
+        if (typeof v === "number") return v <= 1 && v >= 0 ? v * 100 : v;
+        if (typeof v === "object" && v !== null) {
+          const r = v as Record<string, unknown>;
+          for (const k of ["usagePercent", "usedPercent", "percentUsed", "percent", "utilization"]) {
+            if (typeof r[k] === "number") {
+              const n = r[k] as number;
+              return n <= 1 && n >= 0 ? n * 100 : n;
+            }
+          }
+        }
+        return 0;
+      }
+      function extractReset(v: unknown): number {
+        if (typeof v === "number") return v;
+        if (typeof v === "object" && v !== null) {
+          const r = v as Record<string, unknown>;
+          for (const k of ["resetInSec", "resetInSeconds", "resetSeconds"]) {
+            if (typeof r[k] === "number") return r[k] as number;
+          }
+          for (const k of ["resetAt", "resetsAt", "reset_at"]) {
+            if (typeof r[k] === "string") {
+              const d = new Date(r[k] as string);
+              if (!Number.isNaN(d.getTime())) return Math.max(0, Math.round(d.getTime() / 1000 - Date.now() / 1000));
+            }
+          }
+        }
+        return 0;
+      }
+
+      const rollingPercent = extractPercent(rollingVal);
+      const weeklyPercent = extractPercent(weeklyVal);
+      const monthlyPercent = monthlyVal !== undefined ? extractPercent(monthlyVal) : 0;
+      return {
+        rollingPercent: Math.max(0, Math.min(100, rollingPercent)),
+        weeklyPercent: Math.max(0, Math.min(100, weeklyPercent)),
+        monthlyPercent: Math.max(0, Math.min(100, monthlyPercent)),
+        rollingReset: extractReset(rollingVal),
+        weeklyReset: extractReset(weeklyVal),
+        monthlyReset: monthlyVal !== undefined ? extractReset(monthlyVal) : 0,
+        hasMonthly: monthlyVal !== undefined,
+      };
+    }
+
+    // Strategy 1b + 1c: nested search and candidate search
+    const candidates = findCandidates(data);
+    const classified = classifyCandidates(candidates);
+    if (classified.rolling && classified.weekly) {
+      return {
+        rollingPercent: classified.rolling.percent,
+        weeklyPercent: classified.weekly.percent,
+        monthlyPercent: classified.monthly?.percent ?? 0,
+        rollingReset: classified.rolling.resetInSec,
+        weeklyReset: classified.weekly.resetInSec,
+        monthlyReset: classified.monthly?.resetInSec ?? 0,
+        hasMonthly: !!classified.monthly,
+      };
+    }
+  }
+
+  // Strategy 2: Regex fallback
+  const rollingPercentMatch = text.match(/rollingUsage[^}]*?usagePercent\s*:\s*([0-9]+(?:\.[0-9]+)?)/);
+  const rollingResetMatch = text.match(/rollingUsage[^}]*?resetInSec\s*:\s*([0-9]+)/);
+  const weeklyPercentMatch = text.match(/weeklyUsage[^}]*?usagePercent\s*:\s*([0-9]+(?:\.[0-9]+)?)/);
+  const weeklyResetMatch = text.match(/weeklyUsage[^}]*?resetInSec\s*:\s*([0-9]+)/);
+  const monthlyPercentMatch = text.match(/monthlyUsage[^}]*?usagePercent\s*:\s*([0-9]+(?:\.[0-9]+)?)/);
+  const monthlyResetMatch = text.match(/monthlyUsage[^}]*?resetInSec\s*:\s*([0-9]+)/);
+
+  const rollingPercent = rollingPercentMatch ? Number.parseFloat(rollingPercentMatch[1]!) : null;
+  const weeklyPercent = weeklyPercentMatch ? Number.parseFloat(weeklyPercentMatch[1]!) : null;
+
+  if (rollingPercent === null || weeklyPercent === null) {
+    throw new ParseError("Missing usage fields.");
+  }
+
+  return {
+    rollingPercent: Math.max(0, Math.min(100, rollingPercent)),
+    weeklyPercent: Math.max(0, Math.min(100, weeklyPercent)),
+    monthlyPercent: monthlyPercentMatch ? Math.max(0, Math.min(100, Number.parseFloat(monthlyPercentMatch[1]!))) : 0,
+    rollingReset: rollingResetMatch ? Number.parseInt(rollingResetMatch[1]!, 10) : 0,
+    weeklyReset: weeklyResetMatch ? Number.parseInt(weeklyResetMatch[1]!, 10) : 0,
+    monthlyReset: monthlyResetMatch ? Number.parseInt(monthlyResetMatch[1]!, 10) : 0,
+    hasMonthly: monthlyPercentMatch !== null,
+  };
+}
+
+export class OpenCodeGoUsageClient implements UsageClient<{ cookies: string; serverFnId: string }, OpenCodeGoUsageSnapshot> {
+  async fetch(creds: { cookies: string; serverFnId: string }, options?: { signal?: AbortSignal }): Promise<OpenCodeGoUsageSnapshot> {
+    const workspace = await this.resolveWorkspace(creds.cookies, creds.serverFnId, options?.signal);
+    const url = `https://opencode.ai/workspace/${workspace.id}/go`;
+
+    const res = await fetch(url, {
+      signal: options?.signal,
+      headers: {
+        Cookie: creds.cookies,
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+        Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+      },
+    });
+
+    if (res.status === 401 || res.status === 403) {
+      throw new InvalidCredentialsError("OpenCode Go session invalid");
+    }
+
+    const text = await res.text();
+    if (isSignedOut(text)) {
+      throw new InvalidCredentialsError("OpenCode Go session is signed out");
+    }
+
+    const parsed = parseSubscriptionPage(text);
+
+    return {
+      source: "web",
+      hasMonthlyUsage: parsed.hasMonthly,
+      rollingUsagePercent: parsed.rollingPercent,
+      weeklyUsagePercent: parsed.weeklyPercent,
+      monthlyUsagePercent: parsed.monthlyPercent,
+      rollingResetInSec: parsed.rollingReset,
+      weeklyResetInSec: parsed.weeklyReset,
+      monthlyResetInSec: parsed.monthlyReset,
+      updatedAt: new Date(),
+      workspaceId: workspace.id,
+      workspaceName: workspace.name,
+    };
+  }
+
+  private async resolveWorkspace(cookies: string, serverFnId: string, signal?: AbortSignal): Promise<{ id: string; name: string | null }> {
+    const headers: Record<string, string> = {
+      Cookie: cookies,
+      "X-Server-Id": serverFnId,
+      "X-Server-Instance": `server-fn:${randomUuid()}`,
+      "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36",
+      Origin: "https://opencode.ai",
+      Referer: "https://opencode.ai",
+      Accept: "text/javascript, application/json;q=0.9, */*;q=0.8",
+    };
+
+    // GET attempt
+    let res = await fetch(`https://opencode.ai/_server?id=${serverFnId}`, { headers, signal });
+    let text = await res.text();
+
+    if (isSignedOut(text)) {
+      throw new InvalidCredentialsError("OpenCode Go session is signed out");
+    }
+
+    let workspace = extractWorkspace(text);
+    if (!workspace) {
+      // POST fallback
+      res = await fetch("https://opencode.ai/_server", {
+        method: "POST",
+        signal,
+        headers: { ...headers, "Content-Type": "application/json" },
+        body: "[]",
+      });
+      text = await res.text();
+      if (isSignedOut(text)) {
+        throw new InvalidCredentialsError("OpenCode Go session is signed out");
+      }
+      workspace = extractWorkspace(text);
+    }
+
+    if (!workspace) {
+      throw new ParseError("Missing workspace id.");
+    }
+
+    return workspace;
+  }
+}

package/src/usage/index.ts

@@ -0,0 +1,19 @@
+export * from "./types";
+export * from "./resolver";
+export * from "./client";
+export * from "./planner";
+export { UsageApi } from "./api";
+export { mapClaudeToEntry, mapOpenCodeGoToEntry, mapCodexToEntry, buildClaudeAccountId, buildCodexAccountId } from "./mappers";
+export { ClaudeUsageProvider } from "./providers/claude";
+export { CodexUsageProvider } from "./providers/codex";
+export { OpenCodeGoUsageProvider } from "./providers/opencode-go";
+export { ClaudeAuthResolver } from "./resolvers/claude-auth";
+export { ClaudeWebResolver } from "./resolvers/claude-web";
+export { ClaudeCliResolver } from "./resolvers/claude-cli";
+export { CodexAuthResolver } from "./resolvers/codex-auth";
+export { OpenCodeGoWebResolver } from "./resolvers/opencode-go-web";
+export { extractCookies, buildCookieHeader } from "./resolvers/browser-cookies";
+export { AnthropicOAuthUsageClient } from "./clients/anthropic-oauth-usage";
+export { AnthropicWebUsageClient } from "./clients/anthropic-web-usage";
+export { CodexOAuthUsageClient } from "./clients/codex-oauth-usage";
+export { OpenCodeGoUsageClient } from "./clients/opencode-go-usage";