omniagent 0.1.8 → 0.1.11

package/dist/claude-C0SMAkM3.js

@@ -0,0 +1,388 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { c as cleanControlOutput, a as compactLines, p as parsePercentUsed, m as makeUsageLimit } from "./cli.js";
+import { r as runPtyScenario, e as enterKey, a as escapeKey } from "./pty-CZBSAJzE.js";
+const execFileAsync = promisify(execFile);
+const CLAUDE_CODE_KEYCHAIN_SERVICE = "Claude Code-credentials";
+const CLAUDE_CODE_CREDENTIALS_PATH = [".claude", ".credentials.json"];
+const CLAUDE_USAGE_API_URL = "https://api.anthropic.com/v1/messages";
+const CLAUDE_USAGE_API_TIMEOUT_MS = 1e4;
+const CLAUDE_USAGE_API_HEADERS = {
+  "anthropic-version": "2023-06-01",
+  "anthropic-beta": "oauth-2025-04-20",
+  "content-type": "application/json",
+  "user-agent": "claude-code/2.1.5"
+};
+const CLAUDE_USAGE_API_BODY = {
+  model: "claude-haiku-4-5-20251001",
+  max_tokens: 1,
+  messages: [{ role: "user", content: "hi" }]
+};
+async function extractClaudeUsage(context) {
+  try {
+    return await extractClaudeUsageFromApi(context);
+  } catch (error) {
+    if (context.signal.aborted) {
+      throw error;
+    }
+    return extractClaudeUsageFromTui(context);
+  }
+}
+async function extractClaudeUsageFromTui(context) {
+  const command = context.command ?? context.launch?.command ?? "claude";
+  const model = context.launch?.cheapModel ?? "haiku";
+  validateClaudeModel(model);
+  const ptyResult = await runPtyScenario({
+    command,
+    args: context.launch?.args ?? ["--model", model],
+    cwd: context.repoRoot,
+    cols: 100,
+    rows: 40,
+    timeoutMs: context.launch?.timeoutMs ?? 6e4,
+    signal: context.signal,
+    debug: context.debug,
+    steps: [
+      { waitFor: /Claude|>|❯/u, waitForSource: "screen", waitForTimeoutMs: 4e3 },
+      { write: enterKey() },
+      { waitFor: /Claude|>|❯/u, waitForSource: "screen", waitForTimeoutMs: 8e3 },
+      { write: `/usage${enterKey()}` },
+      {
+        waitFor: hasClaudeUsageRows,
+        waitForTimeoutMs: 15e3,
+        capture: "usage",
+        captureWaitMs: 500
+      },
+      { write: escapeKey() },
+      { waitMs: 500 },
+      { write: `/exit${enterKey()}` }
+    ]
+  });
+  const usageSnapshot = ptyResult.snapshots.usage ?? ptyResult;
+  const cleanedOutput = cleanControlOutput(usageSnapshot.raw);
+  const parsed = parseClaudeUsage(usageSnapshot.screen, cleanedOutput);
+  const limits = buildClaudeUsageLimits(parsed, context);
+  if (limits.length === 0) {
+    throw new Error("Claude usage output did not include session or weekly usage rows.");
+  }
+  return {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    command,
+    limits,
+    debug: ptyResult.debug.length > 0 ? ptyResult.debug : void 0
+  };
+}
+async function extractClaudeUsageFromApi(context) {
+  const command = context.command ?? context.launch?.command ?? "claude";
+  const token = await readClaudeAccessToken(context);
+  if (token == null) {
+    throw new Error("Claude Code OAuth token was not available.");
+  }
+  const response = await fetchClaudeUsageHeaders(token, context.signal);
+  if (response.status >= 400) {
+    throw new Error(`Claude usage API returned HTTP ${response.status}.`);
+  }
+  const result = buildClaudeApiUsageResult(response.headers, {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    now: context.now,
+    command
+  });
+  if (result.limits.length === 0) {
+    throw new Error("Claude usage API response did not include usage headers.");
+  }
+  return result;
+}
+function buildClaudeApiUsageResult(headers, context) {
+  const sessionUsed = parseUsageHeaderFraction(
+    headers.get("anthropic-ratelimit-unified-5h-utilization")
+  );
+  const weekUsed = parseUsageHeaderFraction(
+    headers.get("anthropic-ratelimit-unified-7d-utilization")
+  );
+  if (sessionUsed == null || weekUsed == null) {
+    throw new Error("Claude usage API response did not include complete usage headers.");
+  }
+  return {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    command: context.command,
+    limits: [
+      makeClaudeApiUsageLimit({
+        targetId: context.targetId,
+        scope: "current_session",
+        window: "session",
+        percentUsed: sessionUsed,
+        resetAt: parseEpochSecondsHeader(headers.get("anthropic-ratelimit-unified-5h-reset")),
+        now: context.now
+      }),
+      makeClaudeApiUsageLimit({
+        targetId: context.targetId,
+        scope: "current_week",
+        window: "weekly",
+        percentUsed: weekUsed,
+        resetAt: parseEpochSecondsHeader(headers.get("anthropic-ratelimit-unified-7d-reset")),
+        now: context.now
+      })
+    ]
+  };
+}
+function extractClaudeAccessToken(blob) {
+  const trimmed = blob.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    const token = findAccessToken(parsed);
+    if (token != null) {
+      return token;
+    }
+  } catch {
+  }
+  const match = /"accessToken"\s*:\s*"([^"]+)"/.exec(trimmed);
+  if (match?.[1]) {
+    return match[1];
+  }
+  if (/^[A-Za-z0-9_\-.~+/=]{20,}$/.test(trimmed)) {
+    return trimmed;
+  }
+  return null;
+}
+async function readClaudeAccessToken(context) {
+  const tokenFromFile = await readClaudeAccessTokenFromFile(context.homeDir);
+  if (tokenFromFile != null) {
+    return tokenFromFile;
+  }
+  if (process.platform !== "darwin") {
+    return null;
+  }
+  return readClaudeAccessTokenFromKeychain(context.signal);
+}
+async function readClaudeAccessTokenFromFile(homeDir) {
+  try {
+    const raw = await readFile(path.join(homeDir, ...CLAUDE_CODE_CREDENTIALS_PATH), "utf8");
+    return extractClaudeAccessToken(raw);
+  } catch {
+    return null;
+  }
+}
+async function readClaudeAccessTokenFromKeychain(signal) {
+  const username = os.userInfo().username;
+  const keychainArgs = [
+    ["find-generic-password", "-s", CLAUDE_CODE_KEYCHAIN_SERVICE, "-a", username, "-w"],
+    ["find-generic-password", "-s", CLAUDE_CODE_KEYCHAIN_SERVICE, "-w"]
+  ];
+  for (const args of keychainArgs) {
+    try {
+      const { stdout } = await execFileAsync("security", args, {
+        timeout: 5e3,
+        signal,
+        maxBuffer: 1024 * 1024
+      });
+      const token = extractClaudeAccessToken(stdout);
+      if (token != null) {
+        return token;
+      }
+    } catch {
+      if (signal.aborted) {
+        throw signal.reason;
+      }
+    }
+  }
+  return null;
+}
+async function fetchClaudeUsageHeaders(token, parentSignal) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort(new Error("Claude usage API request timed out."));
+  }, CLAUDE_USAGE_API_TIMEOUT_MS);
+  const abortFromParent = () => {
+    controller.abort(parentSignal.reason);
+  };
+  parentSignal.addEventListener("abort", abortFromParent, { once: true });
+  try {
+    const response = await fetch(CLAUDE_USAGE_API_URL, {
+      method: "POST",
+      headers: {
+        ...CLAUDE_USAGE_API_HEADERS,
+        authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(CLAUDE_USAGE_API_BODY),
+      signal: controller.signal
+    });
+    return {
+      status: response.status,
+      headers: response.headers
+    };
+  } finally {
+    clearTimeout(timeout);
+    parentSignal.removeEventListener("abort", abortFromParent);
+  }
+}
+function findAccessToken(value) {
+  if (value == null || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  if (typeof record.accessToken === "string") {
+    return record.accessToken;
+  }
+  for (const child of Object.values(record)) {
+    const token = findAccessToken(child);
+    if (token != null) {
+      return token;
+    }
+  }
+  return null;
+}
+function makeClaudeApiUsageLimit(options) {
+  const percentUsed = clampPercent(options.percentUsed);
+  const resetText = options.resetAt == null ? null : `resets ${options.resetAt}`;
+  const raw = `${formatPercent(percentUsed)} used${resetText == null ? "" : ` (${resetText})`}`;
+  const limit = makeUsageLimit({
+    targetId: options.targetId,
+    scope: options.scope,
+    window: options.window,
+    percentUsed,
+    percentRemaining: 100 - percentUsed,
+    resetText,
+    raw,
+    now: options.now
+  });
+  return {
+    ...limit,
+    resetAt: options.resetAt
+  };
+}
+function parseUsageHeaderFraction(value) {
+  if (value == null || !value.trim()) {
+    return null;
+  }
+  const fraction = Number(value);
+  if (!Number.isFinite(fraction)) {
+    return null;
+  }
+  return fraction * 100;
+}
+function parseEpochSecondsHeader(value) {
+  if (value == null || !value.trim()) {
+    return null;
+  }
+  const seconds = Number(value);
+  if (!Number.isFinite(seconds) || seconds <= 0) {
+    return null;
+  }
+  return new Date(seconds * 1e3).toISOString();
+}
+function clampPercent(value) {
+  return Math.max(0, Math.min(100, value));
+}
+function formatPercent(value) {
+  return Number.isInteger(value) ? `${value}%` : `${Number(value.toFixed(2))}%`;
+}
+function hasClaudeUsageRows(snapshot) {
+  const parsed = parseClaudeUsage(snapshot.screen, cleanControlOutput(snapshot.raw));
+  return Boolean(parsed.currentSessionUsed || parsed.currentWeekUsed);
+}
+function buildClaudeUsageLimits(parsed, context) {
+  const sessionUsed = parsePercentUsed(parsed.currentSessionUsed);
+  const weekUsed = parsePercentUsed(parsed.currentWeekUsed);
+  const limits = [];
+  if (parsed.currentSessionUsed.trim()) {
+    limits.push(
+      makeUsageLimit({
+        targetId: context.targetId,
+        scope: "current_session",
+        window: "session",
+        percentUsed: sessionUsed,
+        percentRemaining: sessionUsed == null ? null : 100 - sessionUsed,
+        resetText: parsed.currentSessionResets,
+        raw: formatRaw(parsed.currentSessionUsed, parsed.currentSessionResets),
+        now: context.now
+      })
+    );
+  }
+  if (parsed.currentWeekUsed.trim()) {
+    limits.push(
+      makeUsageLimit({
+        targetId: context.targetId,
+        scope: "current_week",
+        window: "weekly",
+        percentUsed: weekUsed,
+        percentRemaining: weekUsed == null ? null : 100 - weekUsed,
+        resetText: parsed.currentWeekResets,
+        raw: formatRaw(parsed.currentWeekUsed, parsed.currentWeekResets),
+        now: context.now
+      })
+    );
+  }
+  return limits;
+}
+function parseClaudeUsage(screen, cleanedOutput = "") {
+  const fromScreen = parseClaudeLines(compactLines(screen));
+  if (fromScreen.currentSessionUsed || fromScreen.currentWeekUsed) {
+    return fromScreen;
+  }
+  return parseClaudeLines(compactLines(cleanedOutput));
+}
+function parseClaudeLines(lines) {
+  const values = {
+    currentSessionUsed: "",
+    currentSessionResets: "",
+    currentWeekUsed: "",
+    currentWeekResets: ""
+  };
+  let section = "";
+  for (const line of lines) {
+    if (line === "Current session") {
+      section = "currentSession";
+      continue;
+    }
+    if (line.startsWith("Current week")) {
+      section = "currentWeek";
+      continue;
+    }
+    if (!section) {
+      continue;
+    }
+    const usedMatch = /(\d+(?:\.\d+)?% used)/i.exec(line);
+    if (usedMatch != null) {
+      if (section === "currentSession") {
+        values.currentSessionUsed = usedMatch[1];
+      } else {
+        values.currentWeekUsed = usedMatch[1];
+      }
+      continue;
+    }
+    if (line.startsWith("Resets ")) {
+      if (section === "currentSession") {
+        values.currentSessionResets = line.slice("Resets ".length).trim();
+      } else {
+        values.currentWeekResets = line.slice("Resets ".length).trim();
+      }
+    }
+  }
+  return values;
+}
+function formatRaw(used, resets) {
+  if (!used) {
+    return "";
+  }
+  return resets ? `${used} (resets ${resets})` : used;
+}
+function validateClaudeModel(model) {
+  if (!/^[A-Za-z0-9._:-]+$/.test(model)) {
+    throw new Error(`Unsupported Claude usage model value: ${model}`);
+  }
+}
+export {
+  buildClaudeApiUsageResult,
+  buildClaudeUsageLimits,
+  extractClaudeAccessToken,
+  extractClaudeUsage,
+  parseClaudeUsage
+};

package/dist/cli.js

@@ -1322,7 +1322,7 @@ const claudeTarget = {
       timeoutMs: 6e4
     },
     extract: async (context) => {
-      const { extractClaudeUsage } = await import("./claude-Dmv_YFKX.js");
+      const { extractClaudeUsage } = await import("./claude-C0SMAkM3.js");
       return extractClaudeUsage(context);
     }
   }
@@ -1402,7 +1402,7 @@ const codexTarget = {
       timeoutMs: 6e4
     },
     extract: async (context) => {
-      const { extractCodexUsage } = await import("./codex-Cl1dWwMk.js");
+      const { extractCodexUsage } = await import("./codex-0b2YLh_8.js");
       return extractCodexUsage(context);
     }
   }
@@ -1606,7 +1606,7 @@ const geminiTarget = {
       timeoutMs: 7e4
     },
     extract: async (context) => {
-      const { extractGeminiUsage } = await import("./gemini-CskI3Qjp.js");
+      const { extractGeminiUsage } = await import("./gemini-BVRg6OMO.js");
       return extractGeminiUsage(context);
     }
   }
@@ -8376,7 +8376,7 @@ function getTargetCliCommands(target) {
   add(target.cli?.modes?.oneShot?.command);
   return commands;
 }
-async function checkCliOnPath(command) {
+async function checkCliOnPath(command, options = {}) {
   const normalized = normalizeCommand(command);
   if (!normalized) {
     return { command: command ?? "", result: "unavailable" };
@@ -8387,7 +8387,7 @@ async function checkCliOnPath(command) {
   if (hasPathSeparator(normalized)) {
     for (const candidate of candidates) {
       const check = await checkExecutable(candidate);
-      if (check.status === "available") {
+      if (check.status === "available" && await isValidCandidate(check.resolvedPath, options.validateCandidate)) {
         return { command: normalized, result: "available", resolvedPath: check.resolvedPath };
       }
       if (check.status === "inconclusive") {
@@ -8415,7 +8415,7 @@ async function checkCliOnPath(command) {
     for (const candidate of candidates) {
       const fullPath = path.join(entry2, candidate);
       const check = await checkExecutable(fullPath);
-      if (check.status === "available") {
+      if (check.status === "available" && await isValidCandidate(check.resolvedPath, options.validateCandidate)) {
         return { command: normalized, result: "available", resolvedPath: check.resolvedPath };
       }
       if (check.status === "inconclusive") {
@@ -8432,6 +8432,16 @@ async function checkCliOnPath(command) {
   }
   return { command: normalized, result: "unavailable" };
 }
+async function isValidCandidate(resolvedPath, validateCandidate) {
+  if (!validateCandidate) {
+    return true;
+  }
+  try {
+    return await validateCandidate(resolvedPath);
+  } catch {
+    return false;
+  }
+}
 async function checkTargetAvailability(target) {
   const commands = getTargetCliCommands(target);
   if (commands.length === 0) {
@@ -10666,7 +10676,9 @@ async function checkUsageCommandAvailability(target) {
       warnings: []
     };
   }
-  const check = await checkCliOnPath(command);
+  const check = await checkCliOnPath(command, {
+    validateCandidate: target.id === "codex" && command === "codex" ? validateCodexCommand : void 0
+  });
   if (check.result === "available") {
     return {
       status: "available",
@@ -10688,6 +10700,29 @@ async function checkUsageCommandAvailability(target) {
     warnings: []
   };
 }
+function validateCodexCommand(candidate) {
+  return new Promise((resolve) => {
+    const child = spawn(candidate, ["--version"], {
+      stdio: "ignore"
+    });
+    let settled = false;
+    let timeout;
+    const finish = (valid) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeout);
+      resolve(valid);
+    };
+    timeout = setTimeout(() => {
+      child.kill();
+      finish(false);
+    }, 2e3);
+    child.on("error", () => finish(false));
+    child.on("exit", (code) => finish(code === 0));
+  });
+}
 function buildContext(options) {
   const windows = uniqueNormalizedWindows(options.target.usage?.windows ?? []);
   const launch = {
@@ -10988,16 +11023,20 @@ function formatWindowLabel(window) {
   }
   return window;
 }
+function formatUsageAgentName(targetId, displayName) {
+  return targetId === "codex" && displayName === "OpenAI Codex" ? "Codex CLI" : displayName;
+}
 function formatUsageTable(envelope, sortKey) {
   const useColor = shouldUseColor();
   const generatedAt = parseDate(envelope.generatedAt) ?? /* @__PURE__ */ new Date();
   const rows = [];
   for (const target of envelope.targets) {
     const limitLabels = formatLimitLabels(target.limits);
+    const agentName = formatUsageAgentName(target.targetId, target.displayName);
     target.limits.forEach((limit, index) => {
       rows.push({
         status: "ok",
-        agent: sortKey == null && index > 0 ? "" : target.displayName,
+        agent: sortKey == null && index > 0 ? "" : agentName,
         limitLabel: limitLabels[index] ?? formatLimitLabel(limit),
         reset: formatResetValue(limit, generatedAt),
         limit
@@ -11007,7 +11046,7 @@ function formatUsageTable(envelope, sortKey) {
   for (const error of envelope.errors) {
     rows.push({
       status: "error",
-      agent: error.displayName,
+      agent: formatUsageAgentName(error.targetId, error.displayName),
       limitLabel: "error",
       message: error.message
     });
@@ -11262,16 +11301,7 @@ async function runUsageCommand(argv) {
     return null;
   }
   const startDir = process.cwd();
-  const repoRoot = await findRepoRoot(startDir);
-  if (!repoRoot) {
-    printError({
-      json: jsonOutput,
-      code: "repo_not_found",
-      message: `Repository root not found starting from ${startDir}. Looked for .git or package.json.`,
-      exitCode: 1
-    });
-    return null;
-  }
+  const repoRoot = await findRepoRoot(startDir) ?? startDir;
   const agentsDirResolution = resolveAgentsDir(repoRoot, argv.agentsDir);
   if (agentsDirResolution.source === "override") {
     const validation2 = await validateAgentsDir(repoRoot, argv.agentsDir, { requireWrite: false });
@@ -11535,7 +11565,7 @@ const usageCommand = {
     describe: "Per-agent extraction timeout. Bare numbers are seconds; units include ms, s, and m."
   }).option("agentsDir", {
     type: "string",
-    describe: "Override the agents directory (relative paths resolve from the project root)",
+    describe: "Override the agents directory (relative paths resolve from the project root, or the current directory outside a repo)",
     defaultDescription: DEFAULT_AGENTS_DIR,
     coerce: (value) => {
       if (typeof value !== "string") {