omniagent 0.1.8 → 0.1.11

package/dist/codex-0b2YLh_8.js

@@ -0,0 +1,540 @@
+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 = [
+  ["main", "5h", "main5hLimit"],
+  ["main", "weekly", "mainWeeklyLimit"],
+  ["spark", "5h", "spark5hLimit"],
+  ["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,
+    args: context.launch?.args ?? ["--no-alt-screen"],
+    cwd: context.homeDir,
+    cols: 100,
+    rows: 40,
+    timeoutMs: context.launch?.timeoutMs ?? 6e4,
+    signal: context.signal,
+    debug: context.debug,
+    steps: [
+      { waitFor: isCodexPromptReadyOrTrustPrompt, waitForTimeoutMs: 1e4 },
+      { write: enterKey(), skipIf: isCodexPromptReady },
+      { waitFor: isCodexPromptReady, waitForTimeoutMs: 1e4 },
+      ...typeTextSteps("/status", 20),
+      { write: enterKey() },
+      {
+        waitFor: hasCodexStatusResponse,
+        waitForTimeoutMs: 15e3,
+        capture: "status",
+        captureWaitMs: 500
+      },
+      { waitMs: 5e3, skipIf: hasCodexStatusLimits },
+      { write: `${CLEAR_LINE}/status${enterKey()}`, skipIf: hasCodexStatusLimits },
+      {
+        waitFor: hasCodexStatusLimits,
+        waitForTimeoutMs: 15e3,
+        skipIf: hasCodexStatusLimits,
+        optional: true,
+        capture: "statusRetry",
+        captureWaitMs: 500
+      },
+      { write: `${CLEAR_LINE}/exit${enterKey()}` },
+      { waitMs: 500 }
+    ]
+  });
+  const parsed = selectCodexStatus(ptyResult);
+  const result = buildCodexUsageResult(parsed, {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    now: context.now,
+    command
+  });
+  return {
+    ...result,
+    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,
+    result,
+    result.snapshots.status
+  ];
+  for (const snapshot of snapshots) {
+    if (snapshot == null) {
+      continue;
+    }
+    for (const content of [`${snapshot.screen}
+${snapshot.raw}`, snapshot.screen, snapshot.raw]) {
+      const parsed = parseCodexStatus(cleanControlOutput(content));
+      if (parsed.main5hLimit || parsed.mainWeeklyLimit) {
+        return parsed;
+      }
+    }
+  }
+  const fallback = result.snapshots.statusRetry ?? result.snapshots.status ?? result;
+  return parseCodexStatus(cleanControlOutput(`${fallback.screen}
+${fallback.raw}`));
+}
+function isCodexPromptReady(snapshot) {
+  const cleanedOutput = cleanControlOutput(`${snapshot.screen}
+${snapshot.raw}`);
+  return /(?:\u203a|>)\s/.test(cleanedOutput) && /\bContext\b/i.test(cleanedOutput);
+}
+function isCodexPromptReadyOrTrustPrompt(snapshot) {
+  return isCodexPromptReady(snapshot) || isCodexTrustPrompt(snapshot);
+}
+function isCodexTrustPrompt(snapshot) {
+  const cleanedOutput = cleanControlOutput(`${snapshot.screen}
+${snapshot.raw}`);
+  return /do you trust the contents of this directory/i.test(cleanedOutput);
+}
+function hasCodexStatusLimits(snapshot) {
+  const cleanedOutput = cleanControlOutput(`${snapshot.screen}
+${snapshot.raw}`);
+  const parsed = parseCodexStatus(cleanedOutput);
+  return Boolean(parsed.main5hLimit && parsed.mainWeeklyLimit);
+}
+function hasCodexStatusResponse(snapshot) {
+  const cleanedOutput = cleanControlOutput(`${snapshot.screen}
+${snapshot.raw}`);
+  const parsed = parseCodexStatus(cleanedOutput);
+  return Boolean(parsed.main5hLimit || parsed.mainWeeklyLimit) || /refresh requested/i.test(cleanedOutput);
+}
+function buildCodexUsageResult(parsed, context) {
+  assertAnyRequiredCodexLimit(parsed);
+  const errors = buildCodexUsageErrors(parsed, context);
+  return {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    command: context.command,
+    limits: buildCodexUsageLimits(parsed, context),
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+function buildCodexUsageLimits(parsed, context) {
+  return CODEX_WINDOWS.flatMap(([scope, window, key]) => {
+    const raw = parsed[key]?.trim() ?? "";
+    if (!raw) {
+      return [];
+    }
+    const percentRemaining = parsePercentRemaining(raw);
+    return [
+      makeUsageLimit({
+        targetId: context.targetId,
+        scope,
+        window,
+        percentUsed: percentRemaining == null ? null : 100 - percentRemaining,
+        percentRemaining,
+        resetText: parseResetText(raw),
+        raw,
+        now: context.now
+      })
+    ];
+  });
+}
+function parseCodexStatus(cleanedOutput) {
+  const values = {};
+  let inStatus = false;
+  let section = "main";
+  let key = "";
+  for (const rawLine of cleanedOutput.split(/\n/)) {
+    const normalizedLine = normalizeCodexLine(rawLine);
+    if (!inStatus) {
+      if (normalizedLine === "Model:" || normalizedLine.startsWith("Model: ")) {
+        inStatus = true;
+        key = "model";
+        setValue(values, key, normalizedLine.slice("Model:".length).trim());
+      }
+      continue;
+    }
+    if (normalizedLine.includes("/exit exit Codex")) {
+      break;
+    }
+    if (normalizedLine.startsWith("› ")) {
+      key = "";
+      continue;
+    }
+    let line = normalizedLine;
+    if (!line || line === "[" || line === "]") {
+      continue;
+    }
+    line = line.replace(/^\]\s*/, "").trim();
+    if (!line) {
+      continue;
+    }
+    const labelMatch = /^([-A-Za-z0-9_. ]+):\s*(.*)$/.exec(line);
+    if (labelMatch != null) {
+      const label = labelMatch[1].trim();
+      const inlineValue = labelMatch[2].trim();
+      if (isCodexSparkLimitLabel(label)) {
+        section = "spark";
+        key = "";
+        continue;
+      }
+      key = labelToCodexKey(label, section);
+      if (key && inlineValue) {
+        setValue(values, key, inlineValue);
+      }
+      continue;
+    }
+    if (key && isCodexContinuationLine(line, values[key])) {
+      appendValue(values, key, line);
+    }
+  }
+  return {
+    model: values.model ?? "",
+    directory: values.directory ?? "",
+    permissions: values.permissions ?? "",
+    agentsMd: values.agentsMd ?? "",
+    account: values.account ?? "",
+    collaborationMode: values.collaborationMode ?? "",
+    session: values.session ?? "",
+    main5hLimit: values.main5hLimit ?? "",
+    mainWeeklyLimit: values.mainWeeklyLimit ?? "",
+    spark5hLimit: values.spark5hLimit ?? "",
+    sparkWeeklyLimit: values.sparkWeeklyLimit ?? ""
+  };
+}
+function assertAnyRequiredCodexLimit(parsed) {
+  if (parsed.main5hLimit || parsed.mainWeeklyLimit) {
+    return;
+  }
+  throw new Error("Codex usage output did not include the required 5h and weekly limit rows.");
+}
+function buildCodexUsageErrors(parsed, context) {
+  const missing = [];
+  if (!parsed.main5hLimit) {
+    missing.push("5h");
+  }
+  if (!parsed.mainWeeklyLimit) {
+    missing.push("weekly");
+  }
+  if (missing.length === 0) {
+    return [];
+  }
+  return [
+    {
+      targetId: context.targetId,
+      displayName: context.displayName,
+      code: "partial_parse",
+      message: `Codex usage output did not include the ${missing.join(" and ")} limit row.`
+    }
+  ];
+}
+function isCodexSparkLimitLabel(label) {
+  return /\bspark\b/i.test(label) && /\blimit\b/i.test(label);
+}
+function labelToCodexKey(label, section) {
+  if (label === "Model") return "model";
+  if (label === "Directory") return "directory";
+  if (label === "Permissions") return "permissions";
+  if (label === "Agents.md") return "agentsMd";
+  if (label === "Account") return "account";
+  if (label === "Collaboration mode") return "collaborationMode";
+  if (label === "Session") return "session";
+  if (label === "5h limit") return section === "spark" ? "spark5hLimit" : "main5hLimit";
+  if (label === "Weekly limit") {
+    return section === "spark" ? "sparkWeeklyLimit" : "mainWeeklyLimit";
+  }
+  return "";
+}
+function setValue(values, key, value) {
+  const sanitized = sanitizeCodexValue(value);
+  if (!sanitized) {
+    return;
+  }
+  values[key] = sanitized;
+}
+function appendValue(values, key, value) {
+  const sanitized = sanitizeCodexValue(value);
+  if (!sanitized) {
+    return;
+  }
+  values[key] = values[key] == null || values[key] === "" ? sanitized : `${values[key]} ${sanitized}`;
+}
+function isCodexContinuationLine(line, currentValue) {
+  if (!line) {
+    return false;
+  }
+  const hasPercent = /\d+(?:\.\d+)?\s*%/.test(line);
+  const currentHasPercent = /\d+(?:\.\d+)?\s*%/.test(currentValue ?? "");
+  if (hasPercent) {
+    return !currentHasPercent;
+  }
+  return /\breset/i.test(line);
+}
+function normalizeCodexLine(line) {
+  return line.replace(/[│╭╮╰╯─]/g, " ").replace(/[ \t]+/g, " ").trim();
+}
+function sanitizeCodexValue(value) {
+  const sanitized = value.replace(/›.*$/g, "").trim();
+  const limitMatch = /^(.+?\d+(?:\.\d+)?\s*%\s*(?:left|remaining|used)(?:\s*\([^)]*\))?)/i.exec(
+    sanitized
+  );
+  return limitMatch?.[1].trim() ?? sanitized;
+}
+export {
+  buildCodexApiUsageResult,
+  buildCodexUsageLimits,
+  buildCodexUsageResult,
+  extractCodexBackendAuth,
+  extractCodexUsage,
+  parseCodexStatus
+};