omniagent 0.1.9 → 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-D1RuzsY6.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);
     }
   }

package/dist/{codex-D1RuzsY6.js → codex-0b2YLh_8.js}

@@ -1,3 +1,5 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
 import { c as cleanControlOutput, b as parsePercentRemaining, m as makeUsageLimit, d as parseResetText } from "./cli.js";
 import { r as runPtyScenario, e as enterKey, t as typeTextSteps } from "./pty-CZBSAJzE.js";
 const CODEX_WINDOWS = [
@@ -7,7 +9,21 @@ const CODEX_WINDOWS = [
   ["spark", "weekly", "sparkWeeklyLimit"]
 ];
 const CLEAR_LINE = "";
+const CODEX_AUTH_PATH = [".codex", "auth.json"];
+const CODEX_INSTALLATION_ID_PATH = [".codex", "installation_id"];
+const CODEX_USAGE_API_URL = "https://chatgpt.com/backend-api/wham/usage";
+const CODEX_USAGE_API_TIMEOUT_MS = 1e4;
 async function extractCodexUsage(context) {
+  try {
+    return await extractCodexUsageFromApi(context);
+  } catch (error) {
+    if (context.signal.aborted) {
+      throw error;
+    }
+    return extractCodexUsageFromTui(context);
+  }
+}
+async function extractCodexUsageFromTui(context) {
   const command = context.command ?? context.launch?.command ?? "codex";
   const ptyResult = await runPtyScenario({
     command,
@@ -56,6 +72,244 @@ async function extractCodexUsage(context) {
     debug: ptyResult.debug.length > 0 ? ptyResult.debug : void 0
   };
 }
+async function extractCodexUsageFromApi(context) {
+  const command = context.command ?? context.launch?.command ?? "codex";
+  const auth = await readCodexBackendAuth(context.homeDir);
+  if (auth == null) {
+    throw new Error("Codex ChatGPT backend auth was not available.");
+  }
+  const installationId = await readCodexInstallationId(context.homeDir);
+  const response = await fetchCodexUsage(auth, installationId, context.signal);
+  if (response.status >= 400) {
+    throw new Error(`Codex usage API returned HTTP ${response.status}.`);
+  }
+  const body = await response.json();
+  return buildCodexApiUsageResult(body, {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    now: context.now,
+    command
+  });
+}
+function buildCodexApiUsageResult(payload, context) {
+  const usage = isRecord(payload) ? payload : {};
+  const limits = [
+    ...buildCodexApiRateLimitUsageLimits({
+      targetId: context.targetId,
+      scope: "main",
+      rateLimit: usage.rate_limit,
+      now: context.now,
+      requireBothWindows: true
+    }),
+    ...buildCodexApiAdditionalUsageLimits(usage.additional_rate_limits, context)
+  ];
+  const hasMainHourly = limits.some((limit) => limit.scope === "main" && limit.window === "hourly");
+  const hasMainWeekly = limits.some((limit) => limit.scope === "main" && limit.window === "weekly");
+  if (!hasMainHourly || !hasMainWeekly) {
+    throw new Error("Codex usage API response did not include complete main rate-limit windows.");
+  }
+  return {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    command: context.command,
+    limits
+  };
+}
+function extractCodexBackendAuth(blob) {
+  let parsed;
+  try {
+    parsed = JSON.parse(blob);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed) || !isRecord(parsed.tokens)) {
+    return null;
+  }
+  const accessToken = parsed.tokens.access_token;
+  const accountId = parsed.tokens.account_id;
+  if (typeof accessToken !== "string" || typeof accountId !== "string") {
+    return null;
+  }
+  if (!accessToken.trim() || !accountId.trim()) {
+    return null;
+  }
+  return {
+    accessToken,
+    accountId
+  };
+}
+async function readCodexBackendAuth(homeDir) {
+  try {
+    const raw = await readFile(path.join(homeDir, ...CODEX_AUTH_PATH), "utf8");
+    return extractCodexBackendAuth(raw);
+  } catch {
+    return null;
+  }
+}
+async function readCodexInstallationId(homeDir) {
+  try {
+    const installationId = await readFile(
+      path.join(homeDir, ...CODEX_INSTALLATION_ID_PATH),
+      "utf8"
+    );
+    const trimmed = installationId.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
+async function fetchCodexUsage(auth, installationId, parentSignal) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort(new Error("Codex usage API request timed out."));
+  }, CODEX_USAGE_API_TIMEOUT_MS);
+  const abortFromParent = () => {
+    controller.abort(parentSignal.reason);
+  };
+  parentSignal.addEventListener("abort", abortFromParent, { once: true });
+  try {
+    const headers = {
+      accept: "application/json",
+      authorization: `Bearer ${auth.accessToken}`,
+      "chatgpt-account-id": auth.accountId,
+      "user-agent": "codex-cli"
+    };
+    if (installationId != null) {
+      headers["x-codex-installation-id"] = installationId;
+    }
+    return await fetch(CODEX_USAGE_API_URL, {
+      method: "GET",
+      headers,
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timeout);
+    parentSignal.removeEventListener("abort", abortFromParent);
+  }
+}
+function buildCodexApiAdditionalUsageLimits(additionalRateLimits, context) {
+  if (!Array.isArray(additionalRateLimits)) {
+    return [];
+  }
+  return additionalRateLimits.flatMap((entry) => {
+    if (!isRecord(entry)) {
+      return [];
+    }
+    const limitName = typeof entry.limit_name === "string" ? entry.limit_name : "";
+    const meteredFeature = typeof entry.metered_feature === "string" ? entry.metered_feature : "";
+    const scope = codexAdditionalLimitScope(limitName, meteredFeature);
+    return buildCodexApiRateLimitUsageLimits({
+      targetId: context.targetId,
+      scope,
+      rateLimit: entry.rate_limit,
+      now: context.now,
+      labelPrefix: scope === "spark" ? void 0 : limitName || meteredFeature || scope,
+      requireBothWindows: false
+    });
+  });
+}
+function buildCodexApiRateLimitUsageLimits(options) {
+  if (!isRecord(options.rateLimit)) {
+    return [];
+  }
+  const windows = [
+    ["primary", options.rateLimit.primary_window],
+    ["secondary", options.rateLimit.secondary_window]
+  ];
+  const limits = windows.flatMap(([kind, window]) => {
+    const limit = makeCodexApiUsageLimit({
+      targetId: options.targetId,
+      scope: options.scope,
+      windowKind: kind,
+      window,
+      now: options.now,
+      labelPrefix: options.labelPrefix
+    });
+    return limit == null ? [] : [limit];
+  });
+  if (options.requireBothWindows && limits.length !== 2) {
+    return [];
+  }
+  return limits;
+}
+function makeCodexApiUsageLimit(options) {
+  if (!isRecord(options.window)) {
+    return null;
+  }
+  const percentUsed = parseApiNumber(options.window.used_percent);
+  if (percentUsed == null) {
+    return null;
+  }
+  const resetAt = parseApiEpochSeconds(options.window.reset_at);
+  const window = codexApiWindowName(options.window, options.windowKind);
+  const percentUsedClamped = clampPercent(percentUsed);
+  const percentRemaining = 100 - percentUsedClamped;
+  const resetText = resetAt == null ? null : `resets ${resetAt}`;
+  const label = options.labelPrefix == null ? void 0 : `${options.labelPrefix} ${formatWindowLabel(window)}`;
+  const raw = `${formatPercent(percentRemaining)} left${resetText == null ? "" : ` (${resetText})`}`;
+  const limit = makeUsageLimit({
+    targetId: options.targetId,
+    scope: options.scope,
+    window,
+    label,
+    percentUsed: percentUsedClamped,
+    percentRemaining,
+    resetText,
+    raw,
+    now: options.now
+  });
+  return {
+    ...limit,
+    resetAt
+  };
+}
+function codexAdditionalLimitScope(limitName, meteredFeature) {
+  if (/\bspark\b/i.test(limitName) || /\bbengalfox\b/i.test(meteredFeature)) {
+    return "spark";
+  }
+  const source = limitName || meteredFeature || "additional";
+  const normalized = source.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized || "additional";
+}
+function codexApiWindowName(window, kind) {
+  const seconds = parseApiNumber(window.limit_window_seconds);
+  if (seconds === 18e3) {
+    return "5h";
+  }
+  if (seconds === 604800) {
+    return "weekly";
+  }
+  return kind === "primary" ? "5h" : "weekly";
+}
+function formatWindowLabel(window) {
+  return window === "weekly" ? "Weekly" : window === "5h" ? "5h" : window;
+}
+function parseApiNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function parseApiEpochSeconds(value) {
+  const seconds = parseApiNumber(value);
+  if (seconds == null || 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 isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
 function selectCodexStatus(result) {
   const snapshots = [
     result.snapshots.statusRetry,
@@ -277,8 +531,10 @@ function sanitizeCodexValue(value) {
   return limitMatch?.[1].trim() ?? sanitized;
 }
 export {
+  buildCodexApiUsageResult,
   buildCodexUsageLimits,
   buildCodexUsageResult,
+  extractCodexBackendAuth,
   extractCodexUsage,
   parseCodexStatus
 };