@scrylog/cli 0.3.0 → 0.3.1

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

@@ -1,577 +0,0 @@
-import type { UsageClient } from "../client";
-import type { OpenCodeGoUsageSnapshot } from "../types";
-import { classifyUsageError, UsageError } from "../errors";
-
-const AUTH_COOKIE_NAMES = new Set(["auth", "__Host-auth", "__Host-console_session"]);
-
-export interface OpenCodeGoClientCredentials {
-  cookies: string;
-  serverFnId: string;
-  onCookieRotation?: (cookies: string) => void;
-}
-
-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();
-  return (
-    lower.includes("auth/authorize") ||
-    lower.includes("not associated with an account") ||
-    lower.includes('actor of type "public"') ||
-    /(?:href|action)=["'][^"']*\/(?:login|signin)(?:[?"'])/.test(lower)
-  );
-}
-
-function parseCookieHeader(header: string): Map<string, string> {
-  const cookies = new Map<string, string>();
-  for (const part of header.split(";")) {
-    const separator = part.indexOf("=");
-    if (separator < 1) continue;
-    const name = part.slice(0, separator).trim();
-    if (AUTH_COOKIE_NAMES.has(name)) cookies.set(name, part.slice(separator + 1).trim());
-  }
-  return cookies;
-}
-
-function buildAuthCookieHeader(cookies: ReadonlyMap<string, string>): string {
-  return [...cookies].map(([name, value]) => `${name}=${value}`).join("; ");
-}
-
-function getSetCookieHeaders(headers: Headers): string[] {
-  const values = (headers as Headers & { getSetCookie?: () => string[] }).getSetCookie?.();
-  if (values?.length) return values;
-  const combined = headers.get("set-cookie");
-  return combined ? combined.split(/,\s*(?=(?:auth|__Host-auth)=)/) : [];
-}
-
-function applyAuthCookieRotation(current: string, headers: Headers): string {
-  const cookies = parseCookieHeader(current);
-  for (const setCookie of getSetCookieHeaders(headers)) {
-    const [pair, ...attributes] = setCookie.split(";");
-    const separator = pair!.indexOf("=");
-    if (separator < 1) continue;
-    const name = pair!.slice(0, separator).trim();
-    if (!AUTH_COOKIE_NAMES.has(name)) continue;
-
-    const value = pair!.slice(separator + 1).trim();
-    const expired = attributes.some((attribute) => {
-      const [rawName, rawValue = ""] = attribute.trim().split("=", 2);
-      const attributeName = rawName!.toLowerCase();
-      if (attributeName === "max-age") return Number(rawValue) <= 0;
-      if (attributeName !== "expires") return false;
-      const expiresAt = Date.parse(rawValue);
-      return !Number.isNaN(expiresAt) && expiresAt <= Date.now();
-    });
-    if (!value || expired) cookies.delete(name);
-    else cookies.set(name, value);
-  }
-  return buildAuthCookieHeader(cookies);
-}
-
-function retryAfterMs(response: Response): number | undefined {
-  const value = response.headers.get("retry-after");
-  if (!value) return undefined;
-  const seconds = Number(value);
-  if (Number.isFinite(seconds)) return Math.max(0, seconds * 1000);
-  const date = Date.parse(value);
-  return Number.isNaN(date) ? undefined : Math.max(0, date - Date.now());
-}
-
-function assertResponseStatus(response: Response, context: string): void {
-  if (response.ok) return;
-  if (response.status === 401) throw new UsageError("invalid-credentials", `${context} rejected the session`);
-  if (response.status === 403) throw new UsageError("forbidden", `${context} is forbidden`);
-  if (response.status === 429) {
-    throw new UsageError("rate-limited", `${context} is rate limited`, retryAfterMs(response));
-  }
-  if (response.status >= 500) throw new UsageError("transient", `${context} failed with HTTP ${response.status}`);
-  throw new UsageError("invalid-response", `${context} failed with HTTP ${response.status}`);
-}
-
-function isAuthenticationUrl(url: URL): boolean {
-  const path = url.pathname.toLowerCase().replace(/\/+$/, "");
-  return path === "/login" || path === "/signin" || path === "/console/login" || path === "/auth/authorize";
-}
-
-async function fetchSameHost(url: string, init: RequestInit): Promise<Response> {
-  let currentUrl = new URL(url);
-  let currentInit = init;
-  for (let redirects = 0; redirects <= 5; redirects++) {
-    let response: Response;
-    try {
-      response = await fetch(currentUrl, { ...currentInit, redirect: "manual" });
-    } catch (error) {
-      throw classifyUsageError(error);
-    }
-    if (response.status < 300 || response.status >= 400) return response;
-
-    const location = response.headers.get("location");
-    if (!location) throw new UsageError("invalid-response", "OpenCode Go redirect is missing a location");
-    const nextUrl = new URL(location, currentUrl);
-    if (nextUrl.protocol !== "https:" || nextUrl.hostname !== "opencode.ai") {
-      throw new UsageError("invalid-response", "OpenCode Go refused a cross-origin redirect");
-    }
-    if (isAuthenticationUrl(nextUrl)) {
-      throw new UsageError("invalid-credentials", "OpenCode Go session redirected to sign in");
-    }
-    if (response.status === 303 || ((response.status === 301 || response.status === 302) && currentInit.method === "POST")) {
-      currentInit = { ...currentInit, method: "GET", body: undefined };
-    }
-    currentUrl = nextUrl;
-  }
-  throw new UsageError("invalid-response", "OpenCode Go exceeded the redirect limit");
-}
-
-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 UsageError("invalid-credentials", "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 UsageError("invalid-response", "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<OpenCodeGoClientCredentials, OpenCodeGoUsageSnapshot> {
-  async fetch(creds: OpenCodeGoClientCredentials, options?: { signal?: AbortSignal }): Promise<OpenCodeGoUsageSnapshot> {
-    let cookies = buildAuthCookieHeader(parseCookieHeader(creds.cookies));
-    const request = async (url: string, init: RequestInit = {}): Promise<Response> => {
-      const headers = new Headers(init.headers);
-      headers.set("Cookie", cookies);
-      const response = await fetchSameHost(url, { ...init, headers, signal: options?.signal });
-      const rotated = applyAuthCookieRotation(cookies, response.headers);
-      if (rotated !== cookies) {
-        cookies = rotated;
-        creds.onCookieRotation?.(cookies);
-      }
-      return response;
-    };
-
-    const workspace = await this.resolveWorkspace(creds.serverFnId, request);
-    const url = `https://opencode.ai/workspace/${workspace.id}/go`;
-
-    const res = await request(url, {
-      headers: {
-        "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",
-      },
-    });
-    assertResponseStatus(res, "OpenCode Go subscription request");
-
-    let text: string;
-    try {
-      text = await res.text();
-    } catch (error) {
-      throw classifyUsageError(error);
-    }
-    if (isSignedOut(text)) {
-      throw new UsageError("invalid-credentials", "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(
-    serverFnId: string,
-    request: (url: string, init?: RequestInit) => Promise<Response>,
-  ): Promise<{ id: string; name: string | null }> {
-    const headers: Record<string, string> = {
-      "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 request(`https://opencode.ai/_server?id=${serverFnId}`, { headers });
-    assertResponseStatus(res, "OpenCode Go workspace request");
-    let text: string;
-    try {
-      text = await res.text();
-    } catch (error) {
-      throw classifyUsageError(error);
-    }
-
-    if (isSignedOut(text)) {
-      throw new UsageError("invalid-credentials", "OpenCode Go session is signed out");
-    }
-
-    let workspace = extractWorkspace(text);
-    if (!workspace) {
-      // POST fallback
-      res = await request("https://opencode.ai/_server", {
-        method: "POST",
-        headers: { ...headers, "Content-Type": "application/json" },
-        body: "[]",
-      });
-      assertResponseStatus(res, "OpenCode Go workspace request");
-      try {
-        text = await res.text();
-      } catch (error) {
-        throw classifyUsageError(error);
-      }
-      if (isSignedOut(text)) {
-        throw new UsageError("invalid-credentials", "OpenCode Go session is signed out");
-      }
-      workspace = extractWorkspace(text);
-    }
-
-    if (!workspace) {
-      throw new UsageError("invalid-response", "Missing workspace id.");
-    }
-
-    return workspace;
-  }
-}

package/src/usage/errors.ts

@@ -1,33 +0,0 @@
-export type UsageFailureKind =
-  | "invalid-credentials"
-  | "forbidden"
-  | "rate-limited"
-  | "transient"
-  | "invalid-response"
-  | "cancelled";
-
-export class UsageError extends Error {
-  constructor(
-    public readonly kind: UsageFailureKind,
-    message: string,
-    public readonly retryAfterMs?: number,
-  ) {
-    super(message);
-    this.name = "UsageError";
-  }
-}
-
-export function classifyUsageError(error: unknown): UsageError {
-  if (error instanceof UsageError) return error;
-  if (error instanceof DOMException && error.name === "AbortError") {
-    return new UsageError("cancelled", "Usage request cancelled");
-  }
-  if (error instanceof Error && error.name === "AbortError") {
-    return new UsageError("cancelled", "Usage request cancelled");
-  }
-  return new UsageError("transient", error instanceof Error ? error.message : String(error));
-}
-
-export function isRecoverableAuthenticationError(error: unknown): boolean {
-  return classifyUsageError(error).kind === "invalid-credentials";
-}

package/src/usage/index.ts

@@ -1,20 +0,0 @@
-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 { ClaudeDesktopAuthResolver } from "./resolvers/claude-desktop-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, decryptSafeStorageBlob, getChromiumSafeStorageKey } 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";