@scrylog/cli 0.1.0

package/src/usage/mappers.ts

@@ -0,0 +1,273 @@
+import type {
+  UsageProviderEntry,
+  UsageWindow,
+  ProviderCostSnapshot,
+  ClaudeUsageSnapshot,
+  CodexUsageSnapshot,
+  OpenCodeGoUsageSnapshot,
+  RateWindowLegacy,
+  ClaudeOAuthCredentials,
+  CodexOAuthCredentials,
+} from "./types";
+
+
+function toIsoString(d: Date | null): string | null {
+  return d && !Number.isNaN(d.getTime()) ? d.toISOString() : null;
+}
+
+function computeResetInSec(resetsAt: string | null | undefined): number | undefined {
+  if (!resetsAt) return undefined;
+  const d = new Date(resetsAt);
+  if (Number.isNaN(d.getTime())) return undefined;
+  return Math.max(0, Math.round(d.getTime() / 1000 - Date.now() / 1000));
+}
+
+function computeResetsAt(resetInSec: number | undefined): string | undefined {
+  if (resetInSec === undefined || resetInSec < 0) return undefined;
+  return new Date(Date.now() + resetInSec * 1000).toISOString();
+}
+
+function mapRateWindowLegacyToWindow(id: string, title: string, rw: RateWindowLegacy | null): UsageWindow | undefined {
+  if (!rw) return undefined;
+  const resetsAt = toIsoString(rw.resetsAt);
+  return {
+    id,
+    title,
+    usedPercent: rw.usedPercent,
+    windowMinutes: rw.windowMinutes,
+    resetsAt,
+    resetInSec: computeResetInSec(resetsAt),
+  };
+}
+
+function simpleHash(input: string): string {
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    const char = input.charCodeAt(i);
+    hash = ((hash << 5) - hash + char) | 0;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+
+export function buildClaudeAccountId(
+  snapshot: ClaudeUsageSnapshot | null,
+  oauthCreds: ClaudeOAuthCredentials | null,
+): string | null {
+  // Best source: email from Web API
+  if (snapshot?.accountEmail) {
+    return snapshot.accountEmail;
+  }
+  // Second best: org UUID from Web API (not in snapshot currently, but we can add if needed)
+  // For now, use Keychain metadata as fallback
+  if (oauthCreds?.subscriptionType || oauthCreds?.rateLimitTier) {
+    const parts = ["claude"];
+    if (oauthCreds.subscriptionType) parts.push(oauthCreds.subscriptionType);
+    if (oauthCreds.rateLimitTier) parts.push(oauthCreds.rateLimitTier);
+    if (oauthCreds.scopes && oauthCreds.scopes.length > 0) {
+      // Add a short hash of scopes to distinguish accounts with same tier
+      const scopesHash = simpleHash(oauthCreds.scopes.join(","));
+      parts.push(scopesHash);
+    }
+    return parts.join("-");
+  }
+  return null;
+}
+
+export function mapClaudeToEntry(
+  snapshot: ClaudeUsageSnapshot | null,
+  errors: string[] = [],
+  available: boolean,
+  oauthCreds: ClaudeOAuthCredentials | null,
+): UsageProviderEntry {
+  const base: UsageProviderEntry = {
+    provider: "claude",
+    accountId: buildClaudeAccountId(snapshot, oauthCreds),
+    available,
+    status: snapshot ? (errors.length > 0 ? "error" : "ok") : available ? "error" : "unavailable",
+  };
+
+  if (!snapshot) {
+    if (errors.length > 0) {
+      base.errors = errors;
+    }
+    return base;
+  }
+
+  const windows: UsageWindow[] = [];
+
+  const primary = mapRateWindowLegacyToWindow("session", "Current Session", snapshot.primary);
+  if (primary) windows.push(primary);
+
+  const secondary = mapRateWindowLegacyToWindow("weekly", "Weekly", snapshot.secondary);
+  if (secondary) windows.push(secondary);
+
+  const opus = mapRateWindowLegacyToWindow("opus", "Opus", snapshot.opus);
+  if (opus) windows.push(opus);
+
+  for (const extra of snapshot.extraRateWindows) {
+    const w = mapRateWindowLegacyToWindow(extra.id, extra.title, extra.window);
+    if (w) windows.push(w);
+  }
+
+  let cost: ProviderCostSnapshot | null = null;
+  if (snapshot.providerCost) {
+    cost = {
+      used: snapshot.providerCost.used,
+      limit: snapshot.providerCost.limit,
+      currency: snapshot.providerCost.currencyCode,
+      period: snapshot.providerCost.period,
+      resetsAt: toIsoString(snapshot.providerCost.resetsAt),
+      updatedAt: toIsoString(snapshot.providerCost.updatedAt) ?? new Date().toISOString(),
+    };
+  }
+
+  base.metadata = {
+    dataSource: snapshot.source,
+    accountEmail: snapshot.accountEmail,
+    accountOrganization: snapshot.accountOrganization,
+    subscriptionType: snapshot.subscriptionType,
+    rateLimitTier: snapshot.rateLimitTier,
+  };
+
+  if (errors.length > 0) {
+    base.errors = errors;
+  }
+
+  base.windows = windows;
+  base.cost = cost;
+  base.updatedAt = toIsoString(snapshot.updatedAt) ?? new Date().toISOString();
+
+  return base;
+}
+
+export function buildCodexAccountId(
+  snapshot: CodexUsageSnapshot | null,
+  oauthCreds: CodexOAuthCredentials | null,
+): string | null {
+  if (oauthCreds?.accountEmail) {
+    return oauthCreds.accountEmail;
+  }
+  if (oauthCreds?.accountId) {
+    return oauthCreds.accountId;
+  }
+  if (snapshot?.accountEmail) {
+    return snapshot.accountEmail;
+  }
+  if (snapshot?.planType) {
+    return `codex-${snapshot.planType}`;
+  }
+  return null;
+}
+
+export function mapCodexToEntry(
+  snapshot: CodexUsageSnapshot | null,
+  errors: string[] = [],
+  available: boolean,
+  oauthCreds: CodexOAuthCredentials | null,
+): UsageProviderEntry {
+  const base: UsageProviderEntry = {
+    provider: "codex",
+    accountId: buildCodexAccountId(snapshot, oauthCreds),
+    available,
+    status: snapshot ? (errors.length > 0 ? "error" : "ok") : available ? "error" : "unavailable",
+  };
+
+  if (!snapshot) {
+    if (errors.length > 0) {
+      base.errors = errors;
+    }
+    return base;
+  }
+
+  const windows: UsageWindow[] = [];
+
+  const primary = mapRateWindowLegacyToWindow("session", "Current Session", snapshot.primaryWindow);
+  if (primary) windows.push(primary);
+
+  const secondary = mapRateWindowLegacyToWindow("weekly", "Weekly", snapshot.secondaryWindow);
+  if (secondary) windows.push(secondary);
+
+  // Codex usage API provides rate windows (percentages) and credits (balance/remaining).
+  // It does not expose separate "used" vs "limit" absolute amounts, so a
+  // ProviderCostSnapshot cannot be accurately constructed.  Only rate windows are
+  // mapped; credit balance is surfaced via metadata instead of cost.
+  const cost: ProviderCostSnapshot | null = null;
+
+  base.metadata = {
+    dataSource: snapshot.source,
+    accountEmail: snapshot.accountEmail ?? oauthCreds?.accountEmail,
+    subscriptionType: snapshot.planType,
+  };
+
+  if (errors.length > 0) {
+    base.errors = errors;
+  }
+
+  base.windows = windows;
+  base.cost = cost;
+  base.updatedAt = toIsoString(snapshot.updatedAt) ?? new Date().toISOString();
+
+  return base;
+}
+
+export function mapOpenCodeGoToEntry(
+  snapshot: OpenCodeGoUsageSnapshot | null,
+  errors: string[] = [],
+  available: boolean,
+): UsageProviderEntry {
+  const base: UsageProviderEntry = {
+    provider: "opencode-go",
+    accountId: snapshot?.workspaceId ?? null,
+    available,
+    status: snapshot ? (errors.length > 0 ? "error" : "ok") : available ? "error" : "unavailable",
+  };
+
+  if (!snapshot) {
+    if (errors.length > 0) {
+      base.errors = errors;
+    }
+    return base;
+  }
+
+  const windows: UsageWindow[] = [
+    {
+      id: "session",
+      title: "Rolling",
+      usedPercent: snapshot.rollingUsagePercent,
+      resetInSec: snapshot.rollingResetInSec,
+      resetsAt: computeResetsAt(snapshot.rollingResetInSec),
+    },
+    {
+      id: "weekly",
+      title: "Weekly",
+      usedPercent: snapshot.weeklyUsagePercent,
+      resetInSec: snapshot.weeklyResetInSec,
+      resetsAt: computeResetsAt(snapshot.weeklyResetInSec),
+    },
+  ];
+
+  if (snapshot.hasMonthlyUsage) {
+    windows.push({
+      id: "monthly",
+      title: "Monthly",
+      usedPercent: snapshot.monthlyUsagePercent,
+      resetInSec: snapshot.monthlyResetInSec,
+      resetsAt: computeResetsAt(snapshot.monthlyResetInSec),
+    });
+  }
+
+  base.metadata = {
+    dataSource: snapshot.source,
+    workspaceId: snapshot.workspaceId,
+    workspaceName: snapshot.workspaceName,
+  };
+
+  if (errors.length > 0) {
+    base.errors = errors;
+  }
+
+  base.windows = windows;
+  base.updatedAt = toIsoString(snapshot.updatedAt) ?? new Date().toISOString();
+
+  return base;
+}

package/src/usage/planner.ts

@@ -0,0 +1,54 @@
+import type { TokenResolver } from "./resolver";
+import type { ClaudePlannerDecision, ClaudeDataSource, ClaudeOAuthCredentials, ClaudeWebSession } from "./types";
+
+export interface ClaudeSourcePlannerConfig {
+  dataSource: ClaudeDataSource;
+  webExtrasEnabled: boolean;
+}
+
+export class ClaudeSourcePlanner {
+  constructor(
+    private readonly config: ClaudeSourcePlannerConfig,
+    private readonly oauthResolver: TokenResolver<ClaudeOAuthCredentials>,
+    private readonly webResolver: TokenResolver<ClaudeWebSession>,
+    private readonly cliResolver: TokenResolver<string>,
+  ) {}
+
+  async decide(): Promise<ClaudePlannerDecision> {
+    const [hasOAuth, hasWeb, hasCli] = await Promise.all([
+      this.oauthResolver.isAvailable(),
+      this.webResolver.isAvailable(),
+      this.cliResolver.isAvailable(),
+    ]);
+
+    const selected = this.config.dataSource;
+    const webExtras = this.config.webExtrasEnabled;
+
+    if (selected === "oauth") {
+      return { primary: "oauth", fallback: [], webExtras };
+    }
+    if (selected === "web") {
+      return { primary: "web", fallback: [], webExtras };
+    }
+    if (selected === "cli") {
+      return { primary: "cli", fallback: [], webExtras };
+    }
+
+    // Auto mode
+    const fallback: ClaudeDataSource[] = [];
+    if (hasOAuth) {
+      if (hasWeb) fallback.push("web");
+      if (hasCli) fallback.push("cli");
+      return { primary: "oauth", fallback, webExtras };
+    }
+    if (hasWeb) {
+      if (hasCli) fallback.push("cli");
+      return { primary: "web", fallback, webExtras };
+    }
+    if (hasCli) {
+      return { primary: "cli", fallback: [], webExtras };
+    }
+
+    return { primary: "auto", fallback: [], webExtras };
+  }
+}

package/src/usage/providers/claude.ts

@@ -0,0 +1,113 @@
+import type { UsageClient } from "../client";
+import type { ClaudeOAuthCredentials, ClaudeUsageSnapshot, ClaudeWebSession, UsageProviderEntry } from "../types";
+import { ClaudeSourcePlanner } from "../planner";
+import { AnthropicOAuthUsageClient, AuthenticationError, ScopeError } from "../clients/anthropic-oauth-usage";
+import { AnthropicWebUsageClient, InvalidCredentialsError } from "../clients/anthropic-web-usage";
+import { ClaudeCliProbeClient } from "../clients/claude-cli-probe";
+import type { TokenResolver } from "../resolver";
+import { mapClaudeToEntry } from "../mappers";
+
+export class ClaudeUsageProvider {
+  private readonly oauthClient: UsageClient<ClaudeOAuthCredentials, ClaudeUsageSnapshot>;
+  private readonly webClient: UsageClient<ClaudeWebSession, ClaudeUsageSnapshot>;
+  private readonly cliClient: UsageClient<string, ClaudeUsageSnapshot>;
+
+  constructor(
+    private readonly planner: ClaudeSourcePlanner,
+    private readonly oauthResolver: TokenResolver<ClaudeOAuthCredentials>,
+    private readonly webResolver: TokenResolver<ClaudeWebSession>,
+    private readonly cliResolver: TokenResolver<string>,
+  ) {
+    this.oauthClient = new AnthropicOAuthUsageClient();
+    this.webClient = new AnthropicWebUsageClient();
+    this.cliClient = new ClaudeCliProbeClient();
+  }
+
+  async fetch(options?: { signal?: AbortSignal }): Promise<{ entry: UsageProviderEntry; snapshot: ClaudeUsageSnapshot | null }> {
+    const decision = await this.planner.decide();
+    const errors: string[] = [];
+
+    if (decision.primary === "auto") {
+      // No credentials available on this machine
+      return { entry: mapClaudeToEntry(null, [], false, null), snapshot: null };
+    }
+
+    // Resolve all credentials upfront for both fetch and accountId generation
+    const [oauthCreds, webCreds, cliCreds] = await Promise.all([
+      this.oauthResolver.resolve(),
+      this.webResolver.resolve(),
+      this.cliResolver.resolve(),
+    ]);
+
+    const sources: Array<{ type: "oauth" | "web" | "cli"; creds: unknown }> = [];
+
+    // Primary
+    if (decision.primary === "oauth" && oauthCreds) {
+      sources.push({ type: "oauth", creds: oauthCreds });
+    } else if (decision.primary === "web" && webCreds) {
+      sources.push({ type: "web", creds: webCreds });
+    } else if (decision.primary === "cli" && cliCreds) {
+      sources.push({ type: "cli", creds: cliCreds });
+    }
+
+    // Fallbacks
+    for (const fb of decision.fallback) {
+      if (fb === "oauth" && oauthCreds) {
+        sources.push({ type: "oauth", creds: oauthCreds });
+      } else if (fb === "web" && webCreds) {
+        sources.push({ type: "web", creds: webCreds });
+      } else if (fb === "cli" && cliCreds) {
+        sources.push({ type: "cli", creds: cliCreds });
+      }
+    }
+
+    let snapshot: ClaudeUsageSnapshot | null = null;
+
+    for (const source of sources) {
+      try {
+        if (source.type === "oauth") {
+          snapshot = await this.oauthClient.fetch(source.creds as ClaudeOAuthCredentials, options);
+        } else if (source.type === "web") {
+          snapshot = await this.webClient.fetch(source.creds as ClaudeWebSession, options);
+        } else if (source.type === "cli") {
+          snapshot = await this.cliClient.fetch(source.creds as string, options);
+        }
+        break;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        errors.push(`${source.type}: ${message}`);
+        if (err instanceof InvalidCredentialsError || err instanceof AuthenticationError || err instanceof ScopeError) {
+          continue;
+        }
+        // Continue to fallback for other errors too
+      }
+    }
+
+    // Merge OAuth credential metadata into snapshot for accountId generation
+    if (snapshot && oauthCreds) {
+      if (snapshot.subscriptionType === null && oauthCreds.subscriptionType) {
+        snapshot = { ...snapshot, subscriptionType: oauthCreds.subscriptionType };
+      }
+      if (snapshot.rateLimitTier === null && oauthCreds.rateLimitTier) {
+        snapshot = { ...snapshot, rateLimitTier: oauthCreds.rateLimitTier };
+      }
+    }
+
+    // Web extras merge
+    if (snapshot && decision.webExtras && snapshot.source !== "web" && webCreds) {
+      try {
+        const webSnapshot = await this.webClient.fetch(webCreds, options);
+        if (snapshot.extraRateWindows.length === 0 && webSnapshot.extraRateWindows.length > 0) {
+          snapshot = { ...snapshot, extraRateWindows: webSnapshot.extraRateWindows };
+        }
+        if (!snapshot.providerCost && webSnapshot.providerCost) {
+          snapshot = { ...snapshot, providerCost: webSnapshot.providerCost };
+        }
+      } catch {
+        // Ignore web extras failures
+      }
+    }
+
+    return { entry: mapClaudeToEntry(snapshot, errors, true, oauthCreds), snapshot };
+  }
+}

package/src/usage/providers/codex.ts

@@ -0,0 +1,34 @@
+import type { UsageClient } from "../client";
+import type { CodexOAuthCredentials, CodexUsageSnapshot, UsageProviderEntry } from "../types";
+import type { TokenResolver } from "../resolver";
+import { CodexOAuthUsageClient } from "../clients/codex-oauth-usage";
+import { mapCodexToEntry } from "../mappers";
+
+export class CodexUsageProvider {
+  private readonly oauthClient: UsageClient<CodexOAuthCredentials, CodexUsageSnapshot>;
+
+  constructor(
+    private readonly oauthResolver: TokenResolver<CodexOAuthCredentials>,
+  ) {
+    this.oauthClient = new CodexOAuthUsageClient();
+  }
+
+  async fetch(options?: { signal?: AbortSignal }): Promise<{ entry: UsageProviderEntry; snapshot: CodexUsageSnapshot | null }> {
+    const errors: string[] = [];
+    const oauthCreds = await this.oauthResolver.resolve();
+
+    if (!oauthCreds) {
+      return { entry: mapCodexToEntry(null, [], false, null), snapshot: null };
+    }
+
+    let snapshot: CodexUsageSnapshot | null = null;
+    try {
+      snapshot = await this.oauthClient.fetch(oauthCreds, options);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      errors.push(`oauth: ${message}`);
+    }
+
+    return { entry: mapCodexToEntry(snapshot, errors, true, oauthCreds), snapshot };
+  }
+}

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

@@ -0,0 +1,37 @@
+import type { TokenResolver } from "../resolver";
+import type { OpenCodeGoUsageSnapshot } from "../types";
+import type { UsageProviderEntry } from "../types";
+import { OpenCodeGoUsageClient } from "../clients/opencode-go-usage";
+import { mapOpenCodeGoToEntry } from "../mappers";
+
+export class OpenCodeGoUsageProvider {
+  private readonly client = new OpenCodeGoUsageClient();
+
+  constructor(
+    private readonly resolver: TokenResolver<{ cookies: string }>,
+    private readonly serverFnId: string,
+  ) {}
+
+  async fetch(options?: { signal?: AbortSignal }): Promise<{ entry: UsageProviderEntry; snapshot: OpenCodeGoUsageSnapshot | null }> {
+    const errors: string[] = [];
+    const available = await this.resolver.isAvailable();
+    if (!available) {
+      return { entry: mapOpenCodeGoToEntry(null, [], false), snapshot: null };
+    }
+
+    const creds = await this.resolver.resolve();
+    if (!creds) {
+      // Should not happen if isAvailable() is correct
+      return { entry: mapOpenCodeGoToEntry(null, [], false), snapshot: null };
+    }
+
+    try {
+      const snapshot = await this.client.fetch({ cookies: creds.cookies, serverFnId: this.serverFnId }, options);
+      return { entry: mapOpenCodeGoToEntry(snapshot, errors, true), snapshot };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      errors.push(`OpenCode Go: ${message}`);
+      return { entry: mapOpenCodeGoToEntry(null, errors, true), snapshot: null };
+    }
+  }
+}

package/src/usage/resolver.ts

@@ -0,0 +1,4 @@
+export interface TokenResolver<T> {
+  resolve(): Promise<T | null>;
+  isAvailable(): Promise<boolean>;
+}