omniagent 0.1.9 → 0.1.11

package/dist/gemini-BVRg6OMO.js

@@ -0,0 +1,437 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+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"]
+]);
+const GEMINI_OAUTH_PATH = [".gemini", "oauth_creds.json"];
+const GEMINI_CODE_ASSIST_ENDPOINT = "https://cloudcode-pa.googleapis.com";
+const GEMINI_CODE_ASSIST_API_VERSION = "v1internal";
+const GEMINI_CODE_ASSIST_TIMEOUT_MS = 1e4;
+const GEMINI_OAUTH_EXPIRY_SKEW_MS = 6e4;
+const GEMINI_MODEL_TIERS = /* @__PURE__ */ new Map([
+  ["gemini-2.5-flash", "flash"],
+  ["gemini-2.5-flash-lite", "flash-lite"],
+  ["gemini-2.5-pro", "pro"],
+  ["gemini-3-flash-preview", "flash"],
+  ["gemini-3-pro-preview", "pro"],
+  ["gemini-3.1-flash-lite-preview", "flash-lite"],
+  ["gemini-3.1-pro-preview", "pro"]
+]);
+const GEMINI_TIER_DISPLAY_NAMES = /* @__PURE__ */ new Map([
+  ["flash", "Flash"],
+  ["flash-lite", "Flash Lite"],
+  ["pro", "Pro"]
+]);
+async function extractGeminiUsage(context) {
+  try {
+    return await extractGeminiUsageFromApi(context);
+  } catch (error) {
+    if (context.signal.aborted) {
+      throw error;
+    }
+    return extractGeminiUsageFromTui(context);
+  }
+}
+async function extractGeminiUsageFromTui(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
+  };
+}
+async function extractGeminiUsageFromApi(context) {
+  const command = context.command ?? context.launch?.command ?? "gemini";
+  const auth = await readGeminiOAuthCredentials(context.homeDir);
+  if (auth == null) {
+    throw new Error("Gemini OAuth credentials were not available.");
+  }
+  const accessToken = resolveGeminiAccessToken(auth);
+  const projectResponse = await fetchGeminiCodeAssistJson(
+    "loadCodeAssist",
+    accessToken,
+    buildGeminiLoadCodeAssistRequest(),
+    context.signal
+  );
+  if (projectResponse.status >= 400) {
+    throw new Error(`Gemini Code Assist load API returned HTTP ${projectResponse.status}.`);
+  }
+  const project = extractGeminiCodeAssistProject(projectResponse.body);
+  if (project == null) {
+    throw new Error("Gemini Code Assist load API did not return a project.");
+  }
+  const quotaResponse = await fetchGeminiCodeAssistJson(
+    "retrieveUserQuota",
+    accessToken,
+    { project },
+    context.signal
+  );
+  if (quotaResponse.status >= 400) {
+    throw new Error(`Gemini Code Assist quota API returned HTTP ${quotaResponse.status}.`);
+  }
+  return buildGeminiApiUsageResult(quotaResponse.body, {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    now: context.now,
+    command
+  });
+}
+function buildGeminiApiUsageResult(payload, context) {
+  const usage = isRecord(payload) ? payload : {};
+  const limits = buildGeminiApiUsageLimits(usage.buckets, context);
+  if (limits.length === 0) {
+    throw new Error("Gemini Code Assist quota API response did not include model quota buckets.");
+  }
+  return {
+    targetId: context.targetId,
+    displayName: context.displayName,
+    command: context.command,
+    limits
+  };
+}
+function extractGeminiOAuthCredentials(blob) {
+  let parsed;
+  try {
+    parsed = JSON.parse(blob);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed)) {
+    return null;
+  }
+  const accessToken = typeof parsed.access_token === "string" && parsed.access_token.trim() ? parsed.access_token : void 0;
+  const refreshToken = typeof parsed.refresh_token === "string" && parsed.refresh_token.trim() ? parsed.refresh_token : void 0;
+  const expiryDate = parseApiNumber(parsed.expiry_date) ?? void 0;
+  if (!accessToken && !refreshToken) {
+    return null;
+  }
+  return { accessToken, refreshToken, expiryDate };
+}
+async function readGeminiOAuthCredentials(homeDir) {
+  try {
+    const raw = await readFile(path.join(homeDir, ...GEMINI_OAUTH_PATH), "utf8");
+    return extractGeminiOAuthCredentials(raw);
+  } catch {
+    return null;
+  }
+}
+function resolveGeminiAccessToken(auth) {
+  if (auth.accessToken && (auth.expiryDate == null || auth.expiryDate - Date.now() > GEMINI_OAUTH_EXPIRY_SKEW_MS)) {
+    return auth.accessToken;
+  }
+  throw new Error("Gemini cached access token was not available or expired.");
+}
+async function fetchGeminiCodeAssistJson(method, accessToken, body, parentSignal) {
+  const endpoint = process.env.CODE_ASSIST_ENDPOINT ?? GEMINI_CODE_ASSIST_ENDPOINT;
+  const version = process.env.CODE_ASSIST_API_VERSION ?? GEMINI_CODE_ASSIST_API_VERSION;
+  const response = await fetchWithTimeout(
+    `${endpoint}/${version}:${method}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`
+      },
+      body: JSON.stringify(body)
+    },
+    parentSignal
+  );
+  return {
+    status: response.status,
+    body: await response.json()
+  };
+}
+async function fetchWithTimeout(input, init, parentSignal) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => {
+    controller.abort(new Error("Gemini Code Assist API request timed out."));
+  }, GEMINI_CODE_ASSIST_TIMEOUT_MS);
+  const abortFromParent = () => {
+    controller.abort(parentSignal.reason);
+  };
+  parentSignal.addEventListener("abort", abortFromParent, { once: true });
+  try {
+    return await fetch(input, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timeout);
+    parentSignal.removeEventListener("abort", abortFromParent);
+  }
+}
+function buildGeminiLoadCodeAssistRequest() {
+  const project = process.env.GOOGLE_CLOUD_PROJECT ?? process.env.GOOGLE_CLOUD_PROJECT_ID;
+  const metadata = {
+    ideType: "IDE_UNSPECIFIED",
+    platform: "PLATFORM_UNSPECIFIED",
+    pluginType: "GEMINI"
+  };
+  if (project) {
+    metadata.duetProject = project;
+  }
+  return {
+    ...project ? { cloudaicompanionProject: project } : {},
+    metadata
+  };
+}
+function extractGeminiCodeAssistProject(payload) {
+  if (!isRecord(payload)) {
+    return null;
+  }
+  const project = payload.cloudaicompanionProject;
+  if (typeof project === "string" && project.trim()) {
+    return project;
+  }
+  if (isRecord(project) && typeof project.id === "string" && project.id.trim()) {
+    return project.id;
+  }
+  return null;
+}
+function buildGeminiApiUsageLimits(buckets, context) {
+  if (!Array.isArray(buckets)) {
+    return [];
+  }
+  return selectGeminiQuotaRows(buckets).map(
+    (row) => makeGeminiApiUsageLimit({
+      targetId: context.targetId,
+      now: context.now,
+      row
+    })
+  );
+}
+function selectGeminiQuotaRows(buckets) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const bucket of buckets) {
+    if (!isRecord(bucket) || typeof bucket.modelId !== "string") {
+      continue;
+    }
+    const remainingFraction = parseApiNumber(bucket.remainingFraction);
+    if (remainingFraction == null) {
+      continue;
+    }
+    const modelId = bucket.modelId;
+    const tier = GEMINI_MODEL_TIERS.get(modelId);
+    const groupId = tier ?? modelId;
+    const label = tier == null ? formatGeminiModelLabel(modelId) : GEMINI_TIER_DISPLAY_NAMES.get(tier) ?? tier;
+    const row = {
+      modelId: groupId,
+      label,
+      remainingFraction: clampFraction(remainingFraction),
+      resetAt: parseGeminiResetTime(bucket.resetTime)
+    };
+    const existing = grouped.get(groupId);
+    if (existing == null || row.remainingFraction < existing.remainingFraction) {
+      grouped.set(groupId, row);
+    }
+  }
+  return [...grouped.values()];
+}
+function makeGeminiApiUsageLimit(options) {
+  const percentUsed = Math.round((1 - options.row.remainingFraction) * 100);
+  const percentRemaining = 100 - percentUsed;
+  const resetText = options.row.resetAt == null ? null : `resets ${options.row.resetAt}`;
+  const raw = `${options.row.label} ${percentUsed}% used${resetText == null ? "" : ` (${resetText})`}`;
+  const limit = makeUsageLimit({
+    targetId: options.targetId,
+    scope: modelScope(options.row.modelId),
+    window: "model",
+    label: options.row.label,
+    modelId: options.row.modelId,
+    modelLabel: options.row.label,
+    percentUsed,
+    percentRemaining,
+    resetText,
+    raw,
+    now: options.now
+  });
+  return {
+    ...limit,
+    resetAt: options.row.resetAt
+  };
+}
+function formatGeminiModelLabel(modelId) {
+  return modelId.length > 12 ? `${modelId.slice(0, 11)}…` : modelId;
+}
+function parseGeminiResetTime(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const reset = new Date(value);
+  if (Number.isNaN(reset.getTime()) || reset.getUTCFullYear() < 2e3) {
+    return null;
+  }
+  return reset.toISOString();
+}
+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 clampFraction(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function isRecord(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+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 {
+  buildGeminiApiUsageResult,
+  extractGeminiOAuthCredentials,
+  extractGeminiUsage,
+  parseGeminiModelDialog
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omniagent",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Unified agent configuration CLI that compiles canonical agent configs to multiple runtimes.",
   "type": "module",
   "bin": {

package/dist/claude-Dmv_YFKX.js

@@ -1,146 +0,0 @@
-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";
-async function extractClaudeUsage(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
-  };
-}
-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 {
-  buildClaudeUsageLimits,
-  extractClaudeUsage,
-  parseClaudeUsage
-};