@ai-devkit/agent-manager 0.36.0 → 0.38.0

package/src/capacity/claude.ts

@@ -1,313 +0,0 @@
-import { execFile } from "node:child_process";
-import { readFile } from "node:fs/promises";
-import { homedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
-import { promisify } from "node:util";
-import type { Availability, CapacityReport, CapacityWindow } from "./types.js";
-
-const execFileAsync = promisify(execFile);
-
-export type ClaudeCapacityOptions = {
-  env?: NodeJS.ProcessEnv;
-  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
-  fetch?: typeof globalThis.fetch;
-  timeoutMs?: number;
-  now?: () => Date;
-  cwd?: string;
-  platform?: NodeJS.Platform;
-  keychainRead?: (service: string) => Promise<string | null>;
-};
-
-export type ClaudeProbeOptions = ClaudeCapacityOptions & {
-  checkedAt: string;
-};
-
-const CLAUDE_USAGE_URL = "https://api.anthropic.com/api/oauth/usage";
-const CLAUDE_KEYCHAIN_SERVICE = "Claude Code-credentials";
-const SESSION_DURATION_MINUTES = 5 * 60;
-const WEEK_DURATION_MINUTES = 7 * 24 * 60;
-
-type Credential = { token: string | null; expired: boolean };
-
-function record(value: unknown): Record<string, unknown> | null {
-  return value !== null && typeof value === "object" && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : null;
-}
-
-function percent(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 100
-    ? value
-    : null;
-}
-
-function nonEmptyText(value: unknown): string | null {
-  return typeof value === "string" && value.trim() ? value.trim() : null;
-}
-
-function credentialsPath(options: ClaudeProbeOptions): string {
-  const env = options.env ?? process.env;
-  const configured = nonEmptyText(env.CLAUDE_CONFIG_DIR);
-  if (configured) {
-    const profileRoot = isAbsolute(configured)
-      ? configured
-      : resolve(options.cwd ?? process.cwd(), configured);
-    return join(profileRoot, ".credentials.json");
-  }
-  return join(env.HOME || homedir(), ".claude", ".credentials.json");
-}
-
-function credentialFromPayload(payload: string | null, now: Date): Credential {
-  if (!payload) return { token: null, expired: false };
-  try {
-    return credentialFromRoot(record(JSON.parse(payload)), now);
-  } catch {
-    return { token: null, expired: false };
-  }
-}
-
-async function readProfileCredential(options: ClaudeProbeOptions, now: Date): Promise<Credential> {
-  try {
-    const payload = await (options.readFile ?? readFile)(credentialsPath(options), "utf8");
-    return credentialFromPayload(payload, now);
-  } catch {
-    return { token: null, expired: false };
-  }
-}
-
-async function readKeychainCredential(options: ClaudeProbeOptions, now: Date): Promise<Credential> {
-  const env = options.env ?? process.env;
-  const usesDefaultProfile = !nonEmptyText(env.CLAUDE_CONFIG_DIR);
-  if (!usesDefaultProfile || (options.platform ?? process.platform) !== "darwin") {
-    return { token: null, expired: false };
-  }
-  try {
-    const payload = await (options.keychainRead ?? readClaudeKeychain)(CLAUDE_KEYCHAIN_SERVICE);
-    return credentialFromPayload(payload, now);
-  } catch {
-    return { token: null, expired: false };
-  }
-}
-
-async function resolveToken(options: ClaudeProbeOptions): Promise<string> {
-  const env = options.env ?? process.env;
-  const environmentToken = nonEmptyText(env.CLAUDE_CODE_OAUTH_TOKEN);
-  if (environmentToken) return environmentToken;
-
-  const now = options.now?.() ?? new Date();
-  const profileCredential = await readProfileCredential(options, now);
-  if (profileCredential.token) return profileCredential.token;
-
-  const keychainCredential = await readKeychainCredential(options, now);
-  if (keychainCredential.token) return keychainCredential.token;
-  if (profileCredential.expired || keychainCredential.expired) {
-    throw new Error("Claude OAuth credentials expired");
-  }
-  throw new Error("Claude OAuth credentials not found or malformed");
-}
-
-function credentialFromRoot(root: Record<string, unknown> | null, now: Date): Credential {
-  const oauth = record(root?.claudeAiOauth);
-  const token = nonEmptyText(oauth?.accessToken);
-  if (!token) return { token: null, expired: false };
-  const expired =
-    typeof oauth?.expiresAt === "number" &&
-    Number.isFinite(oauth.expiresAt) &&
-    oauth.expiresAt <= now.getTime();
-  return { token: expired ? null : token, expired };
-}
-
-async function readClaudeKeychain(service: string): Promise<string | null> {
-  try {
-    const { stdout } = await execFileAsync(
-      "/usr/bin/security",
-      ["find-generic-password", "-s", service, "-w"],
-      { encoding: "utf8", timeout: 1500, maxBuffer: 1024 * 1024 },
-    );
-    return nonEmptyText(stdout);
-  } catch {
-    return null;
-  }
-}
-
-function resetTime(value: unknown): string | null {
-  if (typeof value !== "string") return null;
-  const milliseconds = Date.parse(value);
-  return Number.isNaN(milliseconds) ? null : new Date(milliseconds).toISOString();
-}
-
-function usageWindow(
-  value: unknown,
-  id: string,
-  label: string,
-  durationMinutes: number,
-): CapacityWindow | null {
-  const input = record(value);
-  if (!input) return null;
-  return {
-    id,
-    label,
-    durationMinutes,
-    usedPercent: percent(input.utilization),
-    resetsAt: resetTime(input.resets_at),
-  };
-}
-
-function slug(value: string): string {
-  return value
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-|-$/g, "");
-}
-
-function scopedWindows(value: unknown): CapacityWindow[] {
-  if (!Array.isArray(value)) return [];
-  const seen = new Set<string>();
-  const windows: CapacityWindow[] = [];
-  for (const entry of value) {
-    const limit = record(entry);
-    const model = record(record(limit?.scope)?.model);
-    const name = nonEmptyText(model?.display_name);
-    const identity = nonEmptyText(model?.id) ?? name;
-    if (limit?.kind !== "weekly_scoped" || limit.group !== "weekly" || !name || !identity) {
-      continue;
-    }
-    const modelSlug = slug(identity);
-    if (!modelSlug || modelSlug === "all-models" || modelSlug.endsWith("-all-models")) {
-      continue;
-    }
-    const id = `claude:weekly:${modelSlug}`;
-    if (seen.has(id)) continue;
-    seen.add(id);
-    windows.push({
-      id,
-      label: `${name} weekly`,
-      durationMinutes: WEEK_DURATION_MINUTES,
-      usedPercent: percent(limit.percent),
-      resetsAt: resetTime(limit.resets_at),
-    });
-  }
-  return windows;
-}
-
-function finiteNumber(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-
-function extraUsageWindow(value: unknown): CapacityWindow | null {
-  const extra = record(value);
-  if (!extra || extra.is_enabled !== true) return null;
-  const limitMinor = finiteNumber(extra.monthly_limit);
-  const usedMinor = finiteNumber(extra.used_credits);
-  if (limitMinor === null || usedMinor === null) return null;
-  const total = limitMinor / 100;
-  const current = usedMinor / 100;
-  const currency = nonEmptyText(extra.currency)?.toUpperCase() ?? "USD";
-  return {
-    id: "claude:extra-usage",
-    label: `Extra usage · ${currency}`,
-    limitType: "CREDIT_LIMIT",
-    durationMinutes: null,
-    usedPercent:
-      percent(extra.utilization) ??
-      (total > 0 ? Math.max(0, Math.min(100, (current / total) * 100)) : null),
-    resetsAt: null,
-    total,
-    current,
-    remaining: Math.max(0, total - current),
-  };
-}
-
-function availability(windows: CapacityWindow[]): Availability {
-  const known = windows.flatMap((window) =>
-    window.usedPercent === null ? [] : [window.usedPercent],
-  );
-  if (known.length === 0) return "unknown";
-  return known.some((used) => used < 100) ? "yes" : "no";
-}
-
-function retryAfterTime(response: Response, now: Date): string | null {
-  const raw = response.headers.get("Retry-After")?.trim();
-  if (!raw) return null;
-  const seconds = Number(raw);
-  if (Number.isFinite(seconds) && seconds >= 0) {
-    return new Date(now.getTime() + seconds * 1000).toISOString();
-  }
-  const milliseconds = Date.parse(raw);
-  return Number.isNaN(milliseconds) ? null : new Date(milliseconds).toISOString();
-}
-
-export function parseClaudeUsage(raw: unknown, checkedAt: string): CapacityReport {
-  const input = record(raw);
-  if (!input) throw new Error("Claude usage response is malformed");
-  const windows = [
-    usageWindow(input.five_hour, "session", "Session", SESSION_DURATION_MINUTES),
-    usageWindow(input.seven_day, "weekly", "Weekly", WEEK_DURATION_MINUTES),
-    usageWindow(
-      input.seven_day_sonnet,
-      "claude:sonnet:weekly",
-      "Sonnet weekly",
-      WEEK_DURATION_MINUTES,
-    ),
-    usageWindow(input.seven_day_opus, "claude:opus:weekly", "Opus weekly", WEEK_DURATION_MINUTES),
-    ...scopedWindows(input.limits),
-    extraUsageWindow(input.extra_usage),
-  ].filter((window): window is CapacityWindow => window !== null);
-  return {
-    harness: "claude",
-    provider: "anthropic",
-    generatedAt: checkedAt,
-    authenticated: true,
-    available: availability(windows),
-    windows,
-    creditsRemaining: null,
-  };
-}
-
-export async function probeClaudeCapacity(options: ClaudeProbeOptions): Promise<CapacityReport> {
-  const token = await resolveToken(options);
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), options.timeoutMs ?? 5000);
-  let response: Response;
-  try {
-    response = await (options.fetch ?? globalThis.fetch)(CLAUDE_USAGE_URL, {
-      method: "GET",
-      headers: {
-        Accept: "application/json",
-        Authorization: `Bearer ${token}`,
-        "Content-Type": "application/json",
-        "User-Agent": "claude-code/2.1.0",
-        "anthropic-beta": "oauth-2025-04-20",
-      },
-      signal: controller.signal,
-    });
-  } catch {
-    throw new Error("Claude OAuth usage request failed");
-  } finally {
-    clearTimeout(timer);
-  }
-  if (response.status === 401) {
-    throw new Error("Claude OAuth request unauthorized (HTTP 401)");
-  }
-  if (response.status === 403) {
-    throw new Error("Claude OAuth request forbidden (HTTP 403)");
-  }
-  if (response.status === 429) {
-    const retryAt = retryAfterTime(response, options.now?.() ?? new Date());
-    throw new Error(
-      retryAt
-        ? `Claude OAuth usage rate limited until ${retryAt}`
-        : "Claude OAuth usage rate limited (HTTP 429)",
-    );
-  }
-  if (!response.ok) {
-    throw new Error(`Claude OAuth usage request failed (HTTP ${response.status})`);
-  }
-  let raw: unknown;
-  try {
-    raw = await response.json();
-  } catch {
-    throw new Error("Claude usage response is malformed");
-  }
-  return parseClaudeUsage(raw, options.checkedAt);
-}

package/src/capacity/codex.ts

@@ -1,332 +0,0 @@
-import { spawn } from "node:child_process";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { parseWhamUsage, resetTime, safeIdentifier } from "./wham.js";
-import type { CapacityReport, CapacityWindow } from "./types.js";
-
-export { toRateWindow } from "./wham.js";
-
-type CodexUsageSource = "pat" | "oauth" | "cli";
-type UsageSnapshot = {
-  windows: CapacityWindow[];
-  creditsRemaining: number | null;
-  source: CodexUsageSource;
-};
-
-type UnknownRecord = Record<string, unknown>;
-type RpcMessage = { id?: number; method: string; params?: UnknownRecord };
-type CliResponses = { rateLimits: unknown; account: unknown };
-type CodexRpc = (messages: RpcMessage[]) => Promise<CliResponses>;
-
-export const CODEX_APP_SERVER_ARGS = ["-s", "read-only", "-a", "untrusted", "app-server"] as const;
-
-type CodexProbeOptions = {
-  installed: boolean;
-  checkedAt: string;
-  readFile?: (path: string, encoding: BufferEncoding) => Promise<string>;
-  fetch?: typeof globalThis.fetch;
-  rpc?: CodexRpc;
-  timeoutMs?: number;
-  env?: NodeJS.ProcessEnv;
-  now?: () => Date;
-};
-
-function record(value: unknown): UnknownRecord | null {
-  return value !== null && typeof value === "object" && !Array.isArray(value)
-    ? (value as UnknownRecord)
-    : null;
-}
-
-function finiteNumber(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-
-function nonEmptyText(value: unknown): string | null {
-  return typeof value === "string" && value.length > 0 ? value : null;
-}
-
-export function resolveCodexAuthPath(env: NodeJS.ProcessEnv = process.env): string {
-  const root = env.CODEX_HOME || join(env.HOME || "", ".codex");
-  return join(root, "auth.json");
-}
-
-export function parseUsage(raw: unknown, source: "pat" | "oauth"): UsageSnapshot {
-  const { windows, creditsRemaining } = parseWhamUsage(raw);
-  return { windows, creditsRemaining, source };
-}
-
-function cliWindow(value: unknown, id: string, label: string): CapacityWindow | null {
-  const input = record(value);
-  if (!input) return null;
-  return {
-    id,
-    label,
-    durationMinutes: finiteNumber(input.windowDurationMins),
-    usedPercent: finiteNumber(input.usedPercent),
-    resetsAt: resetTime(input.resetsAt),
-  };
-}
-
-function cliSnapshotWindows(value: unknown, fallbackId: string): CapacityWindow[] {
-  const snapshot = record(value);
-  if (!snapshot) return [];
-  const scope = safeIdentifier(snapshot.limitId) ?? safeIdentifier(fallbackId) ?? "codex";
-  return [
-    cliWindow(snapshot.primary, `${scope}:primary`, `${scope} primary`),
-    cliWindow(snapshot.secondary, `${scope}:secondary`, `${scope} secondary`),
-  ].filter((item): item is CapacityWindow => item !== null);
-}
-
-export function parseCliUsage(raw: unknown): UsageSnapshot {
-  const response = record(raw) ?? {};
-  const primary = record(response.rateLimits);
-  const windows = primary ? cliSnapshotWindows(primary, "codex") : [];
-  const buckets = record(response.rateLimitsByLimitId);
-  if (buckets) {
-    for (const [id, snapshot] of Object.entries(buckets))
-      windows.push(...cliSnapshotWindows(snapshot, id));
-  }
-  const unique = [...new Map(windows.map((window) => [window.id, window])).values()];
-  return { windows: unique, creditsRemaining: null, source: "cli" };
-}
-
-function capacityFromSnapshot(
-  snapshot: UsageSnapshot,
-  context: CodexProbeOptions,
-  raw?: unknown,
-): CapacityReport {
-  const hasUsage = snapshot.windows.some((window) => window.usedPercent !== null);
-  const rateLimits = record(record(raw)?.rateLimits);
-  const reached = nonEmptyText(rateLimits?.rateLimitReachedType);
-  const resetCredits =
-    record(record(raw)?.rateLimitResetCredits) ?? record(record(raw)?.usageLimitResetCredits);
-  return {
-    harness: "codex",
-    provider: "openai",
-    generatedAt: context.checkedAt,
-    authenticated: true,
-    available: reached ? "no" : hasUsage ? "yes" : "unknown",
-    windows: snapshot.windows,
-    creditsRemaining: snapshot.creditsRemaining ?? finiteNumber(resetCredits?.availableCount),
-  };
-}
-
-function jwtExpiry(token: string): number | null {
-  const part = token.split(".")[1];
-  if (!part) return null;
-  try {
-    return finiteNumber(record(JSON.parse(Buffer.from(part, "base64url").toString("utf8")))?.exp);
-  } catch {
-    return null;
-  }
-}
-
-function staleOAuth(tokens: UnknownRecord, token: string, now: Date): boolean {
-  const metadata = tokens.expires_at ?? tokens.expiresAt ?? tokens.expiry;
-  let expiry: number | null = finiteNumber(metadata);
-  if (typeof metadata === "string") {
-    const parsed = Date.parse(metadata);
-    expiry = Number.isNaN(parsed) ? null : parsed / 1000;
-  }
-  expiry ??= jwtExpiry(token);
-  return expiry !== null && expiry <= now.getTime() / 1000;
-}
-
-async function fetchJson(
-  fetcher: typeof globalThis.fetch,
-  url: string,
-  init: RequestInit,
-  timeoutMs: number,
-): Promise<unknown> {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetcher(url, { ...init, signal: controller.signal });
-    if (!response.ok) throw new Error(response.status === 401 ? "unauthorized" : "request failed");
-    return await response.json();
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-async function apiSnapshot(
-  token: string,
-  accountId: string,
-  source: "pat" | "oauth",
-  options: CodexProbeOptions,
-): Promise<UsageSnapshot> {
-  const fetcher = options.fetch ?? globalThis.fetch;
-  const raw = await fetchJson(
-    fetcher,
-    "https://chatgpt.com/backend-api/wham/usage",
-    {
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "ChatGPT-Account-Id": accountId,
-      },
-    },
-    options.timeoutMs ?? 5000,
-  );
-  return parseUsage(raw, source);
-}
-
-function appServerRpc(messages: RpcMessage[], timeoutMs = 5000): Promise<CliResponses> {
-  return new Promise((resolve, reject) => {
-    const child = spawn("codex", CODEX_APP_SERVER_ARGS, {
-      stdio: ["pipe", "pipe", "ignore"],
-    });
-    const results: Partial<CliResponses> = {};
-    let buffer = "";
-    let settled = false;
-    const finish = (error?: Error) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      child.kill();
-      if (error) reject(error);
-      else resolve(results as CliResponses);
-    };
-    const timer = setTimeout(() => finish(new Error("codex probe timed out")), timeoutMs);
-    child.once("error", () => finish(new Error("codex app-server unavailable")));
-    child.once("exit", () => {
-      if (!settled) finish(new Error("codex app-server exited"));
-    });
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk: string) => {
-      buffer += chunk;
-      for (;;) {
-        const newline = buffer.indexOf("\n");
-        if (newline < 0) break;
-        const line = buffer.slice(0, newline).trim();
-        buffer = buffer.slice(newline + 1);
-        if (!line) continue;
-        let message: UnknownRecord;
-        try {
-          message = JSON.parse(line) as UnknownRecord;
-        } catch {
-          continue;
-        }
-        if (message.id === 1) {
-          for (const request of messages.slice(1))
-            child.stdin.write(`${JSON.stringify(request)}\n`);
-        } else if (message.id === 2) {
-          if (message.error) finish(new Error("codex rate-limit method failed"));
-          else results.rateLimits = message.result;
-        } else if (message.id === 3) {
-          if (message.error) finish(new Error("codex account method failed"));
-          else results.account = message.result;
-        }
-        if ("rateLimits" in results && "account" in results) finish();
-      }
-    });
-    child.stdin.write(`${JSON.stringify(messages[0])}\n`);
-  });
-}
-
-export function codexUnavailableReport(checkedAt: string): CapacityReport {
-  return {
-    harness: "codex",
-    provider: "openai",
-    generatedAt: checkedAt,
-    authenticated: null,
-    available: "unknown",
-    windows: [],
-    creditsRemaining: null,
-  };
-}
-
-function unavailable(options: CodexProbeOptions): CapacityReport {
-  return codexUnavailableReport(options.checkedAt);
-}
-
-async function cliFallback(options: CodexProbeOptions): Promise<CapacityReport> {
-  if (!options.installed) return unavailable(options);
-  const messages: RpcMessage[] = [
-    {
-      id: 1,
-      method: "initialize",
-      params: {
-        clientInfo: { name: "ai-devkit", title: null, version: "1" },
-        capabilities: null,
-      },
-    },
-    { method: "initialized" },
-    { id: 2, method: "account/rateLimits/read" },
-    { id: 3, method: "account/read" },
-  ];
-  try {
-    const rpc = options.rpc ?? ((requests) => appServerRpc(requests, options.timeoutMs));
-    const response = await rpc(messages);
-    const result = capacityFromSnapshot(
-      parseCliUsage(response.rateLimits),
-      options,
-      response.rateLimits,
-    );
-    const accountEnvelope = record(response.account);
-    if (
-      accountEnvelope &&
-      Object.hasOwn(accountEnvelope, "account") &&
-      !record(accountEnvelope.account)
-    ) {
-      result.authenticated = false;
-      result.available = "unknown";
-    }
-    return result;
-  } catch {
-    return unavailable(options);
-  }
-}
-
-export async function probeCodexCapacity(options: CodexProbeOptions): Promise<CapacityReport> {
-  let parsed: UnknownRecord | null = null;
-  try {
-    const contents = await (options.readFile ?? readFile)(
-      resolveCodexAuthPath(options.env),
-      "utf8",
-    );
-    parsed = record(JSON.parse(contents));
-  } catch {
-    return cliFallback(options);
-  }
-
-  const auth = parsed ?? {};
-  const pat = nonEmptyText(auth.personal_access_token);
-  if (pat) {
-    try {
-      const fetcher = options.fetch ?? globalThis.fetch;
-      const whoami = record(
-        await fetchJson(
-          fetcher,
-          "https://auth.openai.com/api/accounts/v1/user-auth-credential/whoami",
-          { headers: { Authorization: `Bearer ${pat}` } },
-          options.timeoutMs ?? 5000,
-        ),
-      );
-      const accountId = nonEmptyText(whoami?.chatgpt_account_id);
-      if (!accountId) throw new Error("account unavailable");
-      return capacityFromSnapshot(await apiSnapshot(pat, accountId, "pat", options), options);
-    } catch {
-      // Continue to a separately available OAuth credential before using the CLI.
-    }
-  }
-
-  const tokens = record(auth.tokens);
-  const accessToken = nonEmptyText(tokens?.access_token);
-  const accountId = nonEmptyText(tokens?.account_id);
-  if (
-    tokens &&
-    accessToken &&
-    accountId &&
-    !staleOAuth(tokens, accessToken, (options.now ?? (() => new Date()))())
-  ) {
-    try {
-      return capacityFromSnapshot(
-        await apiSnapshot(accessToken, accountId, "oauth", options),
-        options,
-      );
-    } catch {
-      return cliFallback(options);
-    }
-  }
-  return cliFallback(options);
-}