omniagent 0.1.6 → 0.1.8

package/dist/codex-Cl1dWwMk.js

@@ -0,0 +1,274 @@
+import { c as cleanControlOutput, b as parsePercentRemaining, m as makeUsageLimit, d as parseResetText } from "./cli.js";
+import { r as runPtyScenario, t as typeTextSteps, e as enterKey } from "./pty-CZBSAJzE.js";
+const CODEX_WINDOWS = [
+  ["main", "5h", "main5hLimit"],
+  ["main", "weekly", "mainWeeklyLimit"],
+  ["spark", "5h", "spark5hLimit"],
+  ["spark", "weekly", "sparkWeeklyLimit"]
+];
+const CLEAR_LINE = "";
+async function extractCodexUsage(context) {
+  const command = context.command ?? context.launch?.command ?? "codex";
+  const ptyResult = await runPtyScenario({
+    command,
+    args: context.launch?.args ?? ["--no-alt-screen"],
+    cwd: context.repoRoot,
+    cols: 100,
+    rows: 40,
+    timeoutMs: context.launch?.timeoutMs ?? 6e4,
+    signal: context.signal,
+    debug: context.debug,
+    steps: [
+      { 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
+  };
+}
+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 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 {
+  buildCodexUsageLimits,
+  buildCodexUsageResult,
+  extractCodexUsage,
+  parseCodexStatus
+};

package/dist/gemini-CskI3Qjp.js

@@ -0,0 +1,168 @@
+import { c as cleanControlOutput, m as makeUsageLimit, a as compactLines } from "./cli.js";
+import { r as runPtyScenario, t as typeTextSteps, e as enterKey, a as escapeKey } from "./pty-CZBSAJzE.js";
+const TIER_MODEL_IDS = /* @__PURE__ */ new Map([
+  ["Flash", "flash"],
+  ["Flash Lite", "flash-lite"],
+  ["Pro", "pro"]
+]);
+async function extractGeminiUsage(context) {
+  const command = context.command ?? context.launch?.command ?? "gemini";
+  const ptyResult = await runPtyScenario({
+    command,
+    args: context.launch?.args ?? ["--skip-trust"],
+    cwd: context.repoRoot,
+    cols: 110,
+    rows: 42,
+    timeoutMs: context.launch?.timeoutMs ?? 7e4,
+    signal: context.signal,
+    debug: context.debug,
+    steps: [
+      { waitFor: isGeminiPromptReady, waitForTimeoutMs: 12e3 },
+      ...typeTextSteps("/model", 20),
+      { waitMs: 150, write: enterKey() },
+      {
+        waitFor: hasGeminiModelUsage,
+        waitForTimeoutMs: 15e3,
+        capture: "model",
+        captureWaitMs: 500
+      },
+      { write: escapeKey() },
+      { waitMs: 500 },
+      ...typeTextSteps("/quit", 20),
+      { waitMs: 150, write: enterKey() },
+      { waitMs: 500 }
+    ]
+  });
+  const modelSnapshot = ptyResult.snapshots.model ?? ptyResult;
+  const cleanedOutput = cleanControlOutput(modelSnapshot.raw);
+  const parsed = parseGeminiModelDialog(modelSnapshot.screen, cleanedOutput);
+  if (parsed.usage.length === 0) {
+    throw new Error("Gemini usage output did not include model usage rows.");
+  }
+  return {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    command,
+    limits: parsed.usage.map((row) => {
+      const modelId = resolveModelId(row.name, parsed.availableModels);
+      return makeUsageLimit({
+        targetId: context.targetId,
+        scope: modelScope(modelId),
+        window: "model",
+        label: row.name,
+        modelId,
+        modelLabel: row.name,
+        percentUsed: row.percentUsed,
+        percentRemaining: 100 - row.percentUsed,
+        resetText: row.resetText,
+        raw: row.raw,
+        now: context.now
+      });
+    }),
+    debug: ptyResult.debug.length > 0 ? ptyResult.debug : void 0
+  };
+}
+function isGeminiPromptReady(snapshot) {
+  const screen = snapshot.screen || cleanControlOutput(snapshot.raw);
+  return /Type your message|quota/i.test(screen);
+}
+function hasGeminiModelUsage(snapshot) {
+  const parsed = parseGeminiModelDialog(snapshot.screen, cleanControlOutput(snapshot.raw));
+  return parsed.usage.length > 0;
+}
+function parseGeminiModelDialog(screen, cleanedOutput = "") {
+  const fromScreen = parseGeminiLines(compactLines(screen));
+  if (fromScreen.usage.length > 0) {
+    return fromScreen;
+  }
+  return parseGeminiLines(compactLines(cleanedOutput));
+}
+function parseGeminiLines(lines) {
+  const availableModels = [];
+  const usage = [];
+  let selectedModel = "";
+  let inUsage = false;
+  for (const line of lines) {
+    const content = stripGeminiFrame(line);
+    if (!content) {
+      continue;
+    }
+    const model = parseAvailableModel(content);
+    if (model != null) {
+      availableModels.push(model.id);
+      if (model.selected) {
+        selectedModel = model.id;
+      }
+      continue;
+    }
+    if (content === "Model usage") {
+      inUsage = true;
+      continue;
+    }
+    if (!inUsage) {
+      continue;
+    }
+    if (content.startsWith("(")) {
+      break;
+    }
+    const row = parseUsageRow(content);
+    if (row != null) {
+      usage.push(row);
+    }
+  }
+  return {
+    selectedModel,
+    availableModels,
+    usage
+  };
+}
+function parseAvailableModel(line) {
+  const match = /^(\u25cf)?\s*(\d+)\.\s+(\S+)$/u.exec(line);
+  if (match == null) {
+    return null;
+  }
+  return {
+    selected: match[1] != null,
+    index: Number(match[2]),
+    id: match[3]
+  };
+}
+function parseUsageRow(line) {
+  const match = /^(.*?)\s+(\d{1,3})%\s*(?:Resets:\s*(.*?))?$/u.exec(line);
+  if (match == null) {
+    return null;
+  }
+  return {
+    name: stripUsageBar(match[1]),
+    percentUsed: Number(match[2]),
+    resetText: (match[3] ?? "").trim(),
+    raw: line
+  };
+}
+function stripUsageBar(value) {
+  return value.replace(/[\s#=\-_\u2500-\u257F\u2580-\u259F\u25AC]+$/giu, "").trim();
+}
+function resolveModelId(name, availableModels) {
+  const tierModelId = TIER_MODEL_IDS.get(name);
+  if (tierModelId != null) {
+    return tierModelId;
+  }
+  const truncatedPrefix = name.endsWith("...") ? name.slice(0, -3) : name.endsWith("…") ? name.slice(0, -1) : null;
+  if (truncatedPrefix) {
+    const match = availableModels.find((model) => model.startsWith(truncatedPrefix));
+    if (match != null) {
+      return match;
+    }
+  }
+  return name;
+}
+function modelScope(modelId) {
+  return modelId.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+}
+function stripGeminiFrame(line) {
+  return line.replace(/^\s*\u2502\s?/u, "").replace(/\s*\u2502\s*$/u, "").trim();
+}
+export {
+  extractGeminiUsage,
+  parseGeminiModelDialog
+};