@aaa-sentinel/ai-usage 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,1378 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+// src/launcher.ts
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var LauncherError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "LauncherError";
+  }
+};
+var TASK_HOURLY = "AAA Sentinel AI usage";
+var TASK_LOGON = "AAA Sentinel AI usage logon";
+var UNIT = "aaa-sentinel-ai-usage";
+var LABEL = "com.aaa-sentinel.ai-usage";
+async function run(exec, file, args) {
+  const result = await exec(file, args);
+  if (result.code !== 0) {
+    throw new LauncherError(result.stderr || `${file} sali\xF3 con c\xF3digo ${result.code}`);
+  }
+}
+function xmlEscape(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function formatCommand(args) {
+  return args.map((arg) => /[\s"]/.test(arg) ? `"${arg.replaceAll('"', '\\"')}"` : arg).join(" ");
+}
+function cmdArg(arg) {
+  return `"${arg.replaceAll('"', '""')}"`;
+}
+function createLauncher(options) {
+  const { platform, exec, args, homeDir, scriptDir } = options;
+  const command = formatCommand(args);
+  const uid = options.uid ?? 0;
+  const windowsCmd = join(scriptDir, "run.cmd");
+  return {
+    async install() {
+      if (platform === "win32") {
+        mkdirSync(scriptDir, { recursive: true });
+        const previousCmd = existsSync(windowsCmd) ? readFileSync(windowsCmd, "utf8") : null;
+        writeFileSync(windowsCmd, `@echo off\r
+${args.map(cmdArg).join(" ")}\r
+`);
+        const tr = cmdArg(windowsCmd);
+        let hourlyCreated = false;
+        try {
+          await run(exec, "schtasks", ["/Create", "/F", "/TN", TASK_HOURLY, "/SC", "HOURLY", "/ST", "00:00", "/IT", "/TR", tr]);
+          hourlyCreated = true;
+          await run(exec, "schtasks", ["/Create", "/F", "/TN", TASK_LOGON, "/SC", "ONLOGON", "/IT", "/TR", tr]);
+        } catch (err) {
+          if (previousCmd === null && hourlyCreated) await exec("schtasks", ["/Delete", "/TN", TASK_HOURLY, "/F"]);
+          if (previousCmd === null) rmSync(windowsCmd, { force: true });
+          else writeFileSync(windowsCmd, previousCmd);
+          throw err;
+        }
+        return;
+      }
+      if (platform === "darwin") {
+        const plistPath = join(homeDir, "Library", "LaunchAgents", `${LABEL}.plist`);
+        mkdirSync(join(homeDir, "Library", "LaunchAgents"), { recursive: true });
+        const program = args.map((arg) => `    <string>${xmlEscape(arg)}</string>`).join("\n");
+        const previousPlist = existsSync(plistPath) ? readFileSync(plistPath, "utf8") : null;
+        writeFileSync(
+          plistPath,
+          `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>RunAtLoad</key><true/>
+  <key>StartInterval</key><integer>3600</integer>
+  <key>ProgramArguments</key>
+  <array>
+${program}
+  </array>
+</dict></plist>
+`
+        );
+        const domain = `gui/${uid}`;
+        await exec("launchctl", ["bootout", `${domain}/${LABEL}`]);
+        try {
+          await run(exec, "launchctl", ["bootstrap", domain, plistPath]);
+        } catch (err) {
+          if (previousPlist === null) rmSync(plistPath, { force: true });
+          else {
+            writeFileSync(plistPath, previousPlist);
+            await exec("launchctl", ["bootstrap", domain, plistPath]);
+          }
+          throw err;
+        }
+        return;
+      }
+      if (platform === "linux") {
+        const dir = join(homeDir, ".config", "systemd", "user");
+        mkdirSync(dir, { recursive: true });
+        const servicePath = join(dir, `${UNIT}.service`);
+        const timerPath = join(dir, `${UNIT}.timer`);
+        const previousService = existsSync(servicePath) ? readFileSync(servicePath, "utf8") : null;
+        const previousTimer = existsSync(timerPath) ? readFileSync(timerPath, "utf8") : null;
+        writeFileSync(servicePath, `[Service]
+Type=oneshot
+ExecStart=${command.replaceAll("%", "%%")}
+`);
+        writeFileSync(
+          timerPath,
+          `[Timer]
+OnStartupSec=1min
+OnUnitActiveSec=1h
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+`
+        );
+        try {
+          await run(exec, "systemctl", ["--user", "daemon-reload"]);
+          await run(exec, "systemctl", ["--user", "enable", "--now", `${UNIT}.timer`]);
+        } catch (err) {
+          if (previousService === null) rmSync(servicePath, { force: true });
+          else writeFileSync(servicePath, previousService);
+          if (previousTimer === null) rmSync(timerPath, { force: true });
+          else writeFileSync(timerPath, previousTimer);
+          await exec("systemctl", ["--user", "daemon-reload"]);
+          throw err;
+        }
+        return;
+      }
+      throw new LauncherError(`No hay arranque para ${platform}`);
+    },
+    async uninstall() {
+      if (platform === "win32") {
+        await exec("schtasks", ["/Delete", "/TN", TASK_HOURLY, "/F"]);
+        await exec("schtasks", ["/Delete", "/TN", TASK_LOGON, "/F"]);
+        rmSync(windowsCmd, { force: true });
+        return;
+      }
+      if (platform === "darwin") {
+        await exec("launchctl", ["bootout", `gui/${uid}/${LABEL}`]);
+        rmSync(join(homeDir, "Library", "LaunchAgents", `${LABEL}.plist`), { force: true });
+        return;
+      }
+      if (platform === "linux") {
+        await exec("systemctl", ["--user", "disable", "--now", `${UNIT}.timer`]);
+        const dir = join(homeDir, ".config", "systemd", "user");
+        rmSync(join(dir, `${UNIT}.service`), { force: true });
+        rmSync(join(dir, `${UNIT}.timer`), { force: true });
+        await exec("systemctl", ["--user", "daemon-reload"]);
+        return;
+      }
+    },
+    async installed() {
+      if (platform === "win32") {
+        const hourly = await exec("schtasks", ["/Query", "/TN", TASK_HOURLY]);
+        const logon = await exec("schtasks", ["/Query", "/TN", TASK_LOGON]);
+        return hourly.code === 0 && logon.code === 0;
+      }
+      if (platform === "darwin") {
+        const result = await exec("launchctl", ["print", `gui/${uid}/${LABEL}`]);
+        return result.code === 0;
+      }
+      if (platform === "linux") {
+        const result = await exec("systemctl", ["--user", "is-active", `${UNIT}.timer`]);
+        return result.code === 0;
+      }
+      return false;
+    }
+  };
+}
+
+// src/session.ts
+import { randomBytes } from "node:crypto";
+import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, rmSync as rmSync2, unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname, join as join4 } from "node:path";
+
+// src/cursor.ts
+var MODEL_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+var TOKEN_MAX = 1e12;
+function finiteInt(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > TOKEN_MAX) return void 0;
+  const rounded = Math.round(value);
+  if (rounded > TOKEN_MAX) return void 0;
+  return rounded;
+}
+function readSpoolEvent(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const record = value;
+  if (typeof record["at"] !== "string" || !/^\d{4}-\d{2}-\d{2}T/.test(record["at"])) return null;
+  if (typeof record["tokensKnown"] !== "boolean") return null;
+  const event = { at: record["at"], tokensKnown: record["tokensKnown"] };
+  if (typeof record["model"] === "string" && MODEL_PATTERN.test(record["model"])) event.model = record["model"];
+  if (!event.tokensKnown) return event;
+  const input = finiteInt(record["inputTokens"]);
+  const output = finiteInt(record["outputTokens"]);
+  const cacheRead = finiteInt(record["cacheReadTokens"]);
+  const cacheWrite = finiteInt(record["cacheWriteTokens"]);
+  if (input === void 0 || output === void 0 || cacheRead === void 0 || cacheWrite === void 0) return null;
+  event.inputTokens = input;
+  event.outputTokens = output;
+  event.cacheReadTokens = cacheRead;
+  event.cacheWriteTokens = cacheWrite;
+  return event;
+}
+function aggregateByDay(events) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const day = event.at.slice(0, 10);
+    const key = `${day}
+${event.model ?? ""}`;
+    const list = groups.get(key) ?? [];
+    list.push(event);
+    groups.set(key, list);
+  }
+  const byDay = /* @__PURE__ */ new Map();
+  for (const [key, list] of groups) {
+    const day = key.slice(0, 10);
+    const model = list.find((event) => event.model)?.model;
+    const tokensKnown = list.every((event) => event.tokensKnown);
+    const row = {
+      inputTokens: tokensKnown ? list.reduce((sum, event) => sum + (event.inputTokens ?? 0), 0) : 0,
+      outputTokens: tokensKnown ? list.reduce((sum, event) => sum + (event.outputTokens ?? 0), 0) : 0,
+      cacheReadTokens: tokensKnown ? list.reduce((sum, event) => sum + (event.cacheReadTokens ?? 0), 0) : 0,
+      cacheWriteTokens: tokensKnown ? list.reduce((sum, event) => sum + (event.cacheWriteTokens ?? 0), 0) : 0,
+      turns: list.length,
+      tokensKnown
+    };
+    if (model) row.model = model;
+    const rows = byDay.get(day) ?? [];
+    rows.push(row);
+    byDay.set(day, rows);
+  }
+  for (const rows of byDay.values()) {
+    rows.sort((left, right) => (left.model ?? "").localeCompare(right.model ?? ""));
+  }
+  return byDay;
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  return value;
+}
+function mergeCursorHook(existing, command) {
+  let parsed = {};
+  if (existing.trim()) parsed = JSON.parse(existing);
+  const root = asRecord(parsed) ?? {};
+  const hooks = asRecord(root["hooks"]) ?? {};
+  const stopRaw = hooks["stop"];
+  const stop = Array.isArray(stopRaw) ? stopRaw.filter((entry) => asRecord(entry)?.["command"] !== command) : [];
+  const kept = stop.flatMap((entry) => {
+    const record = asRecord(entry);
+    if (!record || typeof record["command"] !== "string") return [];
+    return [record];
+  });
+  return `${JSON.stringify({ ...root, version: root["version"] ?? 1, hooks: { ...hooks, stop: [...kept, { command }] } }, null, 2)}
+`;
+}
+function removeCursorHook(existing, command) {
+  if (!existing.trim()) return existing;
+  const root = asRecord(JSON.parse(existing));
+  if (!root) return existing;
+  const hooks = asRecord(root["hooks"]);
+  if (!hooks || !Array.isArray(hooks["stop"])) return existing;
+  const stop = hooks["stop"].filter((entry) => asRecord(entry)?.["command"] !== command);
+  if (stop.length === 0) {
+    const rest = {};
+    for (const [key, value] of Object.entries(hooks)) {
+      if (key !== "stop") rest[key] = value;
+    }
+    return `${JSON.stringify({ ...root, hooks: rest }, null, 2)}
+`;
+  }
+  return `${JSON.stringify({ ...root, hooks: { ...hooks, stop } }, null, 2)}
+`;
+}
+
+// src/claude.ts
+import { openSync, readSync, closeSync, readdirSync, statSync } from "node:fs";
+import { join as join2, relative } from "node:path";
+var MODEL_PATTERN2 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+var TOKEN_MAX2 = 1e12;
+var MAX_CHUNK = 2e6;
+function emptyClaudeState(since) {
+  return since ? { since, files: {}, days: {} } : { files: {}, days: {} };
+}
+function finiteInt2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > TOKEN_MAX2) return void 0;
+  const rounded = Math.round(value);
+  if (rounded > TOKEN_MAX2) return void 0;
+  return rounded;
+}
+function presentInt(usage, key) {
+  if (!(key in usage)) return 0;
+  const parsed = finiteInt2(usage[key]);
+  return parsed === void 0 ? null : parsed;
+}
+function readCounters(counters, turns) {
+  const input = finiteInt2(counters["input_tokens"]);
+  const output = finiteInt2(counters["output_tokens"]);
+  const cacheRead = presentInt(counters, "cache_read_input_tokens");
+  const cacheWrite = presentInt(counters, "cache_creation_input_tokens");
+  if (input === void 0 || output === void 0 || cacheRead === null || cacheWrite === null) return null;
+  return { inputTokens: input, outputTokens: output, cacheReadTokens: cacheRead, cacheWriteTokens: cacheWrite, turns };
+}
+function advisorParts(iterations) {
+  if (!Array.isArray(iterations)) return [];
+  return iterations.flatMap((iteration) => {
+    if (!iteration || typeof iteration !== "object" || Array.isArray(iteration)) return [];
+    const record = iteration;
+    if (record["type"] !== "advisor_message") return [];
+    const model = record["model"];
+    const bucket = readCounters(record, 0);
+    if (!bucket) return [];
+    return [{ modelKey: typeof model === "string" && MODEL_PATTERN2.test(model) ? model : "", bucket }];
+  });
+}
+function parseAssistantLine(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const record = parsed;
+  if (record["type"] !== "assistant") return null;
+  const at = record["timestamp"];
+  if (typeof at !== "string" || !/^\d{4}-\d{2}-\d{2}T/.test(at)) return null;
+  const message = record["message"];
+  if (!message || typeof message !== "object" || Array.isArray(message)) return null;
+  const usage = message["usage"];
+  if (!usage || typeof usage !== "object" || Array.isArray(usage)) return null;
+  const counters = usage;
+  const executor = readCounters(counters, 1);
+  if (!executor) return null;
+  const requestId = typeof record["requestId"] === "string" ? record["requestId"] : "";
+  const messageId = typeof message["id"] === "string" ? String(message["id"]) : "";
+  const uuid = typeof record["uuid"] === "string" ? record["uuid"] : "";
+  const id = requestId || messageId || uuid;
+  if (!id) return null;
+  const modelRaw = message["model"];
+  const modelKey = typeof modelRaw === "string" && MODEL_PATTERN2.test(modelRaw) ? modelRaw : "";
+  return { id, day: at.slice(0, 10), parts: [{ modelKey, bucket: executor }, ...advisorParts(counters["iterations"])] };
+}
+function bucketAt(days, day, modelKey) {
+  const models = days[day] ?? {};
+  days[day] = models;
+  const current = models[modelKey] ?? { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, turns: 0 };
+  models[modelKey] = current;
+  return current;
+}
+function addBucket(target, delta, sign) {
+  target.inputTokens += sign * delta.inputTokens;
+  target.outputTokens += sign * delta.outputTokens;
+  target.cacheReadTokens += sign * delta.cacheReadTokens;
+  target.cacheWriteTokens += sign * delta.cacheWriteTokens;
+  target.turns += sign * delta.turns;
+  if (target.inputTokens < 0) target.inputTokens = 0;
+  if (target.outputTokens < 0) target.outputTokens = 0;
+  if (target.cacheReadTokens < 0) target.cacheReadTokens = 0;
+  if (target.cacheWriteTokens < 0) target.cacheWriteTokens = 0;
+  if (target.turns < 0) target.turns = 0;
+}
+function foldClaudeTranscript(days, open, chunk, since) {
+  const dirty = /* @__PURE__ */ new Set();
+  let pending = open;
+  const text = chunk.toString("utf8");
+  let start = 0;
+  while (start < text.length) {
+    const newline = text.indexOf("\n", start);
+    if (newline === -1) break;
+    const line = text.slice(start, newline).replace(/\r$/, "");
+    start = newline + 1;
+    const turn = line ? parseAssistantLine(line) : null;
+    if (!turn || since && turn.day < since) continue;
+    if (pending && pending.id === turn.id) {
+      for (const part of pending.parts) {
+        const previous = days[pending.day]?.[part.modelKey];
+        if (!previous) continue;
+        addBucket(previous, part.bucket, -1);
+        dirty.add(pending.day);
+      }
+    }
+    pending = turn;
+    for (const part of turn.parts) addBucket(bucketAt(days, turn.day, part.modelKey), part.bucket, 1);
+    dirty.add(turn.day);
+  }
+  const consumed = start === 0 ? 0 : Buffer.byteLength(text.slice(0, start));
+  return { open: pending, consumed, dirty: [...dirty] };
+}
+function pruneClaudeDays(state, before) {
+  for (const day of Object.keys(state.days)) {
+    if (day < before) delete state.days[day];
+  }
+}
+function rowsForDay(days, day) {
+  const models = days[day] ?? {};
+  return Object.keys(models).sort().map((modelKey) => {
+    const bucket = models[modelKey];
+    const row = {
+      inputTokens: bucket.inputTokens,
+      outputTokens: bucket.outputTokens,
+      cacheReadTokens: bucket.cacheReadTokens,
+      cacheWriteTokens: bucket.cacheWriteTokens,
+      turns: bucket.turns,
+      tokensKnown: true
+    };
+    if (modelKey) row.model = modelKey;
+    return row;
+  });
+}
+function copyBucket(bucket) {
+  return {
+    inputTokens: bucket.inputTokens,
+    outputTokens: bucket.outputTokens,
+    cacheReadTokens: bucket.cacheReadTokens,
+    cacheWriteTokens: bucket.cacheWriteTokens,
+    turns: bucket.turns
+  };
+}
+function parseOpen(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  const day = record["day"];
+  if (typeof record["id"] !== "string" || typeof day !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(day)) return void 0;
+  if (!Array.isArray(record["parts"])) return void 0;
+  const parts = [];
+  for (const raw of record["parts"]) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+    const part = raw;
+    const modelKey = typeof part["modelKey"] === "string" ? part["modelKey"] : "";
+    if (modelKey && !MODEL_PATTERN2.test(modelKey) || !isBucket(part["bucket"])) return void 0;
+    parts.push({ modelKey, bucket: copyBucket(part["bucket"]) });
+  }
+  return { id: record["id"], day, parts };
+}
+function isBucket(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return ["inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens", "turns"].every((key) => finiteInt2(record[key]) !== void 0);
+}
+function parseClaudeState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return emptyClaudeState();
+  const record = value;
+  const since = record["since"];
+  const state = emptyClaudeState(typeof since === "string" && /^\d{4}-\d{2}-\d{2}$/.test(since) ? since : void 0);
+  const files = record["files"];
+  if (files && typeof files === "object" && !Array.isArray(files)) {
+    for (const [key, mark] of Object.entries(files)) {
+      if (!mark || typeof mark !== "object" || Array.isArray(mark)) continue;
+      const offset = finiteInt2(mark["offset"]);
+      if (offset === void 0) continue;
+      const next = { offset };
+      if (mark["skipLine"] === true) next.skipLine = true;
+      const open = parseOpen(mark["open"]);
+      if (open) next.open = open;
+      state.files[key] = next;
+    }
+  }
+  const days = record["days"];
+  if (days && typeof days === "object" && !Array.isArray(days)) {
+    for (const [day, models] of Object.entries(days)) {
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(day) || !models || typeof models !== "object" || Array.isArray(models)) continue;
+      const parsed = {};
+      for (const [modelKey, bucket] of Object.entries(models)) {
+        if (modelKey && !MODEL_PATTERN2.test(modelKey) || !isBucket(bucket)) continue;
+        parsed[modelKey] = {
+          inputTokens: bucket.inputTokens,
+          outputTokens: bucket.outputTokens,
+          cacheReadTokens: bucket.cacheReadTokens,
+          cacheWriteTokens: bucket.cacheWriteTokens,
+          turns: bucket.turns
+        };
+      }
+      if (Object.keys(parsed).length > 0) state.days[day] = parsed;
+    }
+  }
+  return state;
+}
+function listJsonl(dir) {
+  const found = [];
+  const walk = (current) => {
+    let entries;
+    try {
+      entries = readdirSync(current, { withFileTypes: true, encoding: "utf8" });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      const path = join2(current, entry.name);
+      if (entry.isDirectory()) walk(path);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) found.push(path);
+    }
+  };
+  walk(dir);
+  return found;
+}
+function readChunk(path, offset) {
+  const size = statSync(path).size;
+  const start = Math.min(offset, size);
+  const length = Math.min(size - start, MAX_CHUNK);
+  if (length <= 0) return Buffer.alloc(0);
+  const buffer = Buffer.alloc(length);
+  const fd = openSync(path, "r");
+  try {
+    readSync(fd, buffer, 0, length, start);
+  } finally {
+    closeSync(fd);
+  }
+  return buffer;
+}
+function readClaudeIncrement(dir, previous) {
+  const state = parseClaudeState(JSON.parse(JSON.stringify(previous)));
+  const known = state.files;
+  state.files = {};
+  const dirty = /* @__PURE__ */ new Set();
+  let caughtUp = true;
+  for (const path of listJsonl(dir)) {
+    const key = relative(dir, path).split("\\").join("/");
+    const size = statSync(path).size;
+    const mark = known[key] ?? { offset: 0 };
+    if (mark.offset > size) {
+      state.files[key] = { offset: size };
+      continue;
+    }
+    let buffer = readChunk(path, mark.offset);
+    if (buffer.length === 0) {
+      state.files[key] = mark;
+      continue;
+    }
+    if (mark.skipLine) {
+      const newline = buffer.indexOf(10);
+      if (newline === -1) {
+        mark.offset += buffer.length;
+        state.files[key] = mark;
+        if (mark.offset < size) caughtUp = false;
+        continue;
+      }
+      buffer = buffer.subarray(newline + 1);
+      mark.offset += newline + 1;
+      delete mark.skipLine;
+    }
+    const folded = foldClaudeTranscript(state.days, mark.open, buffer, state.since);
+    for (const day of folded.dirty) dirty.add(day);
+    mark.offset += folded.consumed;
+    if (folded.open) mark.open = folded.open;
+    if (folded.consumed === 0 && buffer.length === MAX_CHUNK) {
+      mark.skipLine = true;
+      mark.offset += buffer.length;
+    }
+    state.files[key] = mark;
+    if (mark.offset < size) caughtUp = false;
+  }
+  return { state, dirtyDays: [...dirty].sort(), caughtUp };
+}
+
+// src/codex.ts
+import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, readSync as readSync2, statSync as statSync2 } from "node:fs";
+import { join as join3, relative as relative2 } from "node:path";
+var MODEL_PATTERN3 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+var TOKEN_MAX3 = 1e12;
+var MAX_CHUNK2 = 2e6;
+function emptyCodexState(since) {
+  return since ? { since, files: {}, days: {} } : { files: {}, days: {} };
+}
+function classifyCodexAuth(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return "unknown";
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "unknown";
+  const record = parsed;
+  const mode = record["auth_mode"];
+  if (mode === "apikey" || mode === "api_key" || mode === "api") return "api_key";
+  const key = record["OPENAI_API_KEY"];
+  if (typeof key === "string" && key.length > 0) return "api_key";
+  const tokens = record["tokens"];
+  if (tokens && typeof tokens === "object" && !Array.isArray(tokens)) return "chatgpt";
+  return "unknown";
+}
+function finiteInt3(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > TOKEN_MAX3) return void 0;
+  return value;
+}
+function bucketAt2(days, day, modelKey) {
+  const models = days[day] ?? (days[day] = {});
+  return models[modelKey] ?? (models[modelKey] = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, turns: 0 });
+}
+function addDelta(bucket, input, output, cacheRead) {
+  bucket.inputTokens += input;
+  bucket.outputTokens += output;
+  bucket.cacheReadTokens += cacheRead;
+  bucket.turns += 1;
+}
+function foldCodexTranscript(days, cursor, chunk, since) {
+  const text = chunk.toString("utf8");
+  const dirty = /* @__PURE__ */ new Set();
+  let modelKey = cursor?.modelKey ?? "";
+  let consumed = 0;
+  let start = 0;
+  while (start < text.length) {
+    const end = text.indexOf("\n", start);
+    if (end === -1) break;
+    const line = text.slice(start, end);
+    start = end + 1;
+    consumed = Buffer.byteLength(text.slice(0, start));
+    if (!line.trim()) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) continue;
+    const record = parsed;
+    const payload = record["payload"];
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) continue;
+    const body = payload;
+    if (record["type"] === "turn_context" && typeof body["model"] === "string" && MODEL_PATTERN3.test(body["model"])) {
+      modelKey = body["model"];
+      continue;
+    }
+    if (record["type"] !== "event_msg" || body["type"] !== "token_count") continue;
+    const at = record["timestamp"];
+    if (typeof at !== "string" || !/^\d{4}-\d{2}-\d{2}T/.test(at)) continue;
+    const day = at.slice(0, 10);
+    const info = body["info"];
+    if (!info || typeof info !== "object" || Array.isArray(info)) continue;
+    const total = info["total_token_usage"];
+    if (!total || typeof total !== "object" || Array.isArray(total)) continue;
+    const counters = total;
+    const input = finiteInt3(counters["input_tokens"]);
+    const output = finiteInt3(counters["output_tokens"]);
+    const cached = finiteInt3(counters["cached_input_tokens"]) ?? 0;
+    if (input === void 0 || output === void 0) continue;
+    const next = {
+      modelKey,
+      day,
+      inputTokens: Math.max(0, input - cached),
+      outputTokens: output,
+      cacheReadTokens: cached
+    };
+    const deltaInput = Math.max(0, next.inputTokens - (cursor?.inputTokens ?? 0));
+    const deltaOutput = Math.max(0, next.outputTokens - (cursor?.outputTokens ?? 0));
+    const deltaCache = Math.max(0, next.cacheReadTokens - (cursor?.cacheReadTokens ?? 0));
+    cursor = next;
+    if (since && day < since) continue;
+    if (deltaInput === 0 && deltaOutput === 0 && deltaCache === 0) continue;
+    addDelta(bucketAt2(days, next.day, next.modelKey), deltaInput, deltaOutput, deltaCache);
+    dirty.add(day);
+  }
+  return cursor ? { cursor, dirty: [...dirty], consumed } : { dirty: [...dirty], consumed };
+}
+function rowsForCodexDay(days, day) {
+  const models = days[day];
+  if (!models) return [];
+  return Object.entries(models).filter(([, bucket]) => bucket.turns > 0 || bucket.inputTokens > 0 || bucket.outputTokens > 0).sort(([left], [right]) => left.localeCompare(right)).map(([modelKey, bucket]) => ({
+    ...modelKey ? { model: modelKey } : {},
+    inputTokens: bucket.inputTokens,
+    outputTokens: bucket.outputTokens,
+    cacheReadTokens: bucket.cacheReadTokens,
+    cacheWriteTokens: bucket.cacheWriteTokens,
+    turns: bucket.turns,
+    tokensKnown: true
+  }));
+}
+function isCursor(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const record = value;
+  return typeof record["day"] === "string" && /^\d{4}-\d{2}-\d{2}$/.test(record["day"]) && typeof record["modelKey"] === "string" && (record["modelKey"] === "" || MODEL_PATTERN3.test(record["modelKey"])) && finiteInt3(record["inputTokens"]) !== void 0 && finiteInt3(record["outputTokens"]) !== void 0 && finiteInt3(record["cacheReadTokens"]) !== void 0;
+}
+function parseCodexState(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return emptyCodexState();
+  const record = value;
+  const since = record["since"];
+  const state = emptyCodexState(typeof since === "string" && /^\d{4}-\d{2}-\d{2}$/.test(since) ? since : void 0);
+  const files = record["files"];
+  if (files && typeof files === "object" && !Array.isArray(files)) {
+    for (const [key, mark] of Object.entries(files)) {
+      if (!mark || typeof mark !== "object" || Array.isArray(mark)) continue;
+      const offset = finiteInt3(mark["offset"]);
+      if (offset === void 0) continue;
+      const next = { offset };
+      if (mark["skipLine"] === true) next.skipLine = true;
+      const cursor = mark["cursor"];
+      if (isCursor(cursor)) {
+        next.cursor = {
+          modelKey: cursor.modelKey,
+          day: cursor.day,
+          inputTokens: cursor.inputTokens,
+          outputTokens: cursor.outputTokens,
+          cacheReadTokens: cursor.cacheReadTokens
+        };
+      }
+      state.files[key] = next;
+    }
+  }
+  const days = record["days"];
+  if (days && typeof days === "object" && !Array.isArray(days)) {
+    for (const [day, models] of Object.entries(days)) {
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(day) || !models || typeof models !== "object" || Array.isArray(models)) continue;
+      const parsed = {};
+      for (const [modelKey, bucket] of Object.entries(models)) {
+        if (modelKey && !MODEL_PATTERN3.test(modelKey) || !bucket || typeof bucket !== "object" || Array.isArray(bucket)) continue;
+        const counters = bucket;
+        const inputTokens = finiteInt3(counters["inputTokens"]);
+        const outputTokens = finiteInt3(counters["outputTokens"]);
+        const cacheReadTokens = finiteInt3(counters["cacheReadTokens"]);
+        const cacheWriteTokens = finiteInt3(counters["cacheWriteTokens"]);
+        const turns = finiteInt3(counters["turns"]);
+        if (inputTokens === void 0 || outputTokens === void 0 || cacheReadTokens === void 0 || cacheWriteTokens === void 0 || turns === void 0) continue;
+        parsed[modelKey] = { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, turns };
+      }
+      if (Object.keys(parsed).length > 0) state.days[day] = parsed;
+    }
+  }
+  return state;
+}
+function listJsonl2(dir) {
+  const found = [];
+  const walk = (current) => {
+    let entries;
+    try {
+      entries = readdirSync2(current, { withFileTypes: true, encoding: "utf8" });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      const path = join3(current, entry.name);
+      if (entry.isDirectory()) walk(path);
+      else if (entry.isFile() && entry.name.endsWith(".jsonl")) found.push(path);
+    }
+  };
+  walk(dir);
+  return found;
+}
+function readChunk2(path, offset) {
+  const size = statSync2(path).size;
+  const start = Math.min(offset, size);
+  const length = Math.min(size - start, MAX_CHUNK2);
+  if (length <= 0) return Buffer.alloc(0);
+  const buffer = Buffer.alloc(length);
+  const fd = openSync2(path, "r");
+  try {
+    readSync2(fd, buffer, 0, length, start);
+  } finally {
+    closeSync2(fd);
+  }
+  return buffer;
+}
+function readCodexAuth(home) {
+  try {
+    return classifyCodexAuth(readFileSync2(join3(home, "auth.json"), "utf8"));
+  } catch {
+    return "unknown";
+  }
+}
+function readCodexIncrement(dir, previous) {
+  const state = parseCodexState(JSON.parse(JSON.stringify(previous)));
+  const known = state.files;
+  state.files = {};
+  const dirty = /* @__PURE__ */ new Set();
+  let caughtUp = true;
+  for (const path of listJsonl2(dir)) {
+    const key = relative2(dir, path).split("\\").join("/");
+    const size = statSync2(path).size;
+    const mark = known[key] ?? { offset: 0 };
+    if (mark.offset > size) {
+      state.files[key] = { offset: size };
+      continue;
+    }
+    let buffer = readChunk2(path, mark.offset);
+    if (buffer.length === 0) {
+      state.files[key] = mark;
+      continue;
+    }
+    if (mark.skipLine) {
+      const newline = buffer.indexOf(10);
+      if (newline === -1) {
+        mark.offset += buffer.length;
+        state.files[key] = mark;
+        if (mark.offset < size) caughtUp = false;
+        continue;
+      }
+      buffer = buffer.subarray(newline + 1);
+      mark.offset += newline + 1;
+      delete mark.skipLine;
+    }
+    const folded = foldCodexTranscript(state.days, mark.cursor, buffer, state.since);
+    for (const day of folded.dirty) dirty.add(day);
+    mark.offset += folded.consumed;
+    if (folded.cursor) mark.cursor = folded.cursor;
+    if (folded.consumed === 0 && buffer.length === MAX_CHUNK2) {
+      mark.skipLine = true;
+      mark.offset += buffer.length;
+    }
+    state.files[key] = mark;
+    if (mark.offset < size) caughtUp = false;
+  }
+  return { state, dirtyDays: [...dirty].sort(), caughtUp };
+}
+
+// src/copilot.ts
+var MODEL_PATTERN4 = /^[A-Za-z0-9][A-Za-z0-9._-]{0,79}$/;
+var API_VERSION = "2026-03-10";
+function authFailure(result) {
+  if (result.code === 0) return false;
+  const text = `${result.stdout}
+${result.stderr}`;
+  if (text.includes("ENOENT")) return false;
+  return /\b401\b/.test(text) || /\b403\b/.test(text) || /must authenticate|authentication required|Forbidden/i.test(text);
+}
+function finiteInt4(value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 1e12) return void 0;
+  return value;
+}
+function quantityOf(item) {
+  return finiteInt4(item["grossQuantity"]) ?? finiteInt4(item["quantity"]) ?? finiteInt4(item["netQuantity"]);
+}
+function copilotModelKey(model) {
+  if (typeof model !== "string") return "";
+  const key = model.trim().toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9._-]/g, "").slice(0, 80);
+  return MODEL_PATTERN4.test(key) ? key : "";
+}
+function rowFromItem(item) {
+  const modelKey = copilotModelKey(item["model"]);
+  const unit = typeof item["unitType"] === "string" ? item["unitType"].toLowerCase() : "";
+  const count = quantityOf(item);
+  if (!unit.includes("request") || count === void 0) return null;
+  return {
+    ...modelKey ? { model: modelKey } : {},
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    cacheWriteTokens: 0,
+    turns: count,
+    tokensKnown: false
+  };
+}
+function addRow(rows, row) {
+  const key = row.model ?? "_";
+  const current = rows.get(key);
+  if (!current) {
+    rows.set(key, row);
+    return;
+  }
+  current.inputTokens += row.inputTokens;
+  current.outputTokens += row.outputTokens;
+  current.cacheReadTokens += row.cacheReadTokens;
+  current.cacheWriteTokens += row.cacheWriteTokens;
+  current.turns += row.turns;
+  current.tokensKnown = current.tokensKnown && row.tokensKnown;
+}
+function rowsFromCopilotUsage(payload, day) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) return [];
+  const items = payload["usageItems"];
+  if (!Array.isArray(items)) return [];
+  const rows = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (!item || typeof item !== "object" || Array.isArray(item)) continue;
+    const record = item;
+    if (typeof record["date"] === "string" && record["date"] !== day) continue;
+    const row = rowFromItem(record);
+    if (row) addRow(rows, row);
+  }
+  return [...rows.values()];
+}
+async function ghJson(gh, path) {
+  const result = await gh([
+    "api",
+    "--hostname",
+    "github.com",
+    "-H",
+    "Accept: application/vnd.github+json",
+    "-H",
+    `X-GitHub-Api-Version: ${API_VERSION}`,
+    path
+  ]);
+  if (authFailure(result)) return { auth: true, payload: null };
+  if (result.code !== 0) return { auth: false, payload: null };
+  try {
+    return { auth: false, payload: JSON.parse(result.stdout) };
+  } catch {
+    return { auth: false, payload: null };
+  }
+}
+async function readCopilotDay(gh, day) {
+  const user = await ghJson(gh, "user");
+  if (user.auth) return { status: "auth" };
+  if (!user.payload) return { status: "unavailable" };
+  const login2 = user.payload && typeof user.payload === "object" && !Array.isArray(user.payload) ? user.payload["login"] : void 0;
+  if (typeof login2 !== "string" || !/^[A-Za-z0-9-]{1,39}$/.test(login2)) return { status: "empty" };
+  const [year, month, date] = day.split("-");
+  const query = `year=${year}&month=${Number(month)}&day=${Number(date)}`;
+  const base = `/users/${login2}/settings/billing`;
+  const premium = await ghJson(gh, `${base}/premium_request/usage?${query}`);
+  if (premium.auth) return { status: "auth" };
+  const rows = rowsFromCopilotUsage(premium.payload, day);
+  return rows.length > 0 ? { status: "rows", rows } : { status: "empty" };
+}
+
+// src/transport.ts
+var USAGE_SOURCES = ["cursor", "claude_code", "github_copilot", "codex"];
+function isUsageSource(value) {
+  return typeof value === "string" && USAGE_SOURCES.includes(value);
+}
+function resolveUsageBaseUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return null;
+  }
+  const loopback = url.hostname === "localhost" || url.hostname === "127.0.0.1";
+  if (url.protocol !== "https:" && !loopback) return null;
+  return raw.replace(/\/+$/, "");
+}
+async function fetchUsageSource(options) {
+  let response;
+  try {
+    response = await options.fetchImpl(`${options.baseUrl.replace(/\/$/, "")}/v1/ai-usage/telemetry`, {
+      method: "GET",
+      redirect: "error",
+      headers: { authorization: `Bearer ${options.token}` }
+    });
+  } catch {
+    return { status: 0 };
+  }
+  try {
+    const body = await response.json();
+    if (response.ok && isUsageSource(body.source)) return { status: response.status, source: body.source };
+  } catch {
+  }
+  return { status: response.status };
+}
+async function postTelemetry(options) {
+  const response = await options.fetchImpl(`${options.baseUrl.replace(/\/$/, "")}/v1/ai-usage/telemetry`, {
+    method: "POST",
+    redirect: "error",
+    headers: {
+      authorization: `Bearer ${options.token}`,
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      day: options.day,
+      source: options.source ?? "cursor",
+      ...options.device ? { device: options.device } : {},
+      rows: options.rows.map((row) => ({
+        inputTokens: row.inputTokens,
+        outputTokens: row.outputTokens,
+        cacheReadTokens: row.cacheReadTokens,
+        cacheWriteTokens: row.cacheWriteTokens,
+        turns: row.turns,
+        tokensKnown: row.tokensKnown,
+        ...row.model ? { model: row.model } : {}
+      }))
+    })
+  });
+  let code;
+  try {
+    const body = await response.json();
+    if (typeof body.code === "string") code = body.code;
+  } catch {
+    code = void 0;
+  }
+  return code === void 0 ? { ok: response.ok, status: response.status } : { ok: response.ok, status: response.status, code };
+}
+
+// src/session.ts
+var EXIT_USAGE = 2;
+var EXIT_LAUNCHER = 3;
+var EXIT_REPORT = 4;
+var EXIT_COPILOT = 5;
+var MAX_ROWS = 40;
+var TOKEN_PATTERN = /^sau_[A-Za-z0-9_-]{20,200}$/;
+var DEVICE_PATTERN = /^[a-f0-9]{16}$/;
+function newDevice() {
+  return randomBytes(8).toString("hex");
+}
+function readJson(path) {
+  if (!existsSync2(path)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return {};
+    const record = parsed;
+    const config = {};
+    if (typeof record["token"] === "string") config.token = record["token"];
+    if (typeof record["device"] === "string" && DEVICE_PATTERN.test(record["device"])) config.device = record["device"];
+    if (typeof record["lastAcceptedDay"] === "string") config.lastAcceptedDay = record["lastAcceptedDay"];
+    if (record["claude"]) config.claude = parseClaudeState(record["claude"]);
+    if (record["codex"]) config.codex = parseCodexState(record["codex"]);
+    if (isUsageSource(record["source"])) config.source = record["source"];
+    return config;
+  } catch {
+    return {};
+  }
+}
+function writeJson(path, value) {
+  mkdirSync2(dirname(path), { recursive: true, mode: 448 });
+  writeFileSync2(path, `${JSON.stringify(value)}
+`, { mode: 384 });
+  chmodSync(path, 384);
+}
+function restoreFile(path, previous) {
+  if (previous === null) {
+    if (existsSync2(path)) unlinkSync(path);
+    return;
+  }
+  writeFileSync2(path, previous);
+}
+function readSpool(dir) {
+  if (!existsSync2(dir)) return [];
+  return readdirSync3(dir).filter((name) => name.endsWith(".json")).map((name) => {
+    const path = join4(dir, name);
+    try {
+      return { path, event: readSpoolEvent(JSON.parse(readFileSync3(path, "utf8"))) };
+    } catch {
+      return { path, event: null };
+    }
+  });
+}
+function utcDay(date) {
+  return date.toISOString().slice(0, 10);
+}
+function clearSpool(dir) {
+  rmSync2(dir, { recursive: true, force: true });
+}
+async function login(options) {
+  const token = options.token.replace(/^\uFEFF/, "").trim();
+  if (!TOKEN_PATTERN.test(token)) {
+    return { code: EXIT_USAGE, message: "El token no tiene el formato de un alta de uso." };
+  }
+  const previousConfig = existsSync2(options.paths.configPath) ? readFileSync3(options.paths.configPath, "utf8") : null;
+  const previousHooks = existsSync2(options.paths.hooksPath) ? readFileSync3(options.paths.hooksPath, "utf8") : null;
+  const config = readJson(options.paths.configPath);
+  const tokenChanged = config.token !== void 0 && config.token !== token;
+  const next = { token, device: config.device ?? newDevice() };
+  if (config.lastAcceptedDay) next.lastAcceptedDay = config.lastAcceptedDay;
+  const since = utcDay(options.now ?? /* @__PURE__ */ new Date());
+  next.claude = config.claude && !tokenChanged ? config.claude : emptyClaudeState(since);
+  next.codex = config.codex && !tokenChanged ? config.codex : emptyCodexState(since);
+  if (config.source && !tokenChanged) next.source = config.source;
+  writeJson(options.paths.configPath, next);
+  try {
+    mkdirSync2(dirname(options.paths.hooksPath), { recursive: true });
+    writeFileSync2(options.paths.hooksPath, mergeCursorHook(previousHooks ?? "", options.hookCommand));
+    await options.launcher.install();
+    if (tokenChanged) clearSpool(options.paths.spoolPath);
+  } catch (err) {
+    restoreFile(options.paths.configPath, previousConfig);
+    restoreFile(options.paths.hooksPath, previousHooks);
+    const launcherFailed = err instanceof LauncherError;
+    return {
+      code: launcherFailed ? EXIT_LAUNCHER : EXIT_USAGE,
+      message: launcherFailed ? `No se pudo registrar el arranque. No se ha dejado el token instalado. ${err.message}` : `No se pudo instalar el hook de Cursor. No se ha dejado el token instalado. ${err.message}`
+    };
+  }
+  return { code: 0, message: "Agente instalado. El arranque subir\xE1 el uso; no hace falta lanzarlo en cada sesi\xF3n." };
+}
+async function logout(options) {
+  let launcherError;
+  try {
+    await options.launcher.uninstall();
+  } catch (err) {
+    launcherError = err;
+  }
+  let hookError = false;
+  if (existsSync2(options.paths.hooksPath)) {
+    try {
+      const current = readFileSync3(options.paths.hooksPath, "utf8");
+      writeFileSync2(options.paths.hooksPath, removeCursorHook(current, options.hookCommand));
+    } catch {
+      hookError = true;
+    }
+  }
+  clearSpool(options.paths.spoolPath);
+  const config = readJson(options.paths.configPath);
+  if (config.token || config.lastAcceptedDay) {
+    const next = {};
+    if (config.lastAcceptedDay) next.lastAcceptedDay = config.lastAcceptedDay;
+    writeJson(options.paths.configPath, next);
+  }
+  if (launcherError) {
+    return { code: EXIT_LAUNCHER, message: `No se pudo quitar el arranque. ${launcherError.message}` };
+  }
+  if (hookError) {
+    return { code: EXIT_USAGE, message: "El arranque se quit\xF3, pero el hook de Cursor no: su fichero no es JSON." };
+  }
+  return { code: 0, message: "Agente retirado." };
+}
+function dropCursorHook(paths, hookCommand) {
+  if (!hookCommand || !existsSync2(paths.hooksPath)) return;
+  try {
+    const current = readFileSync3(paths.hooksPath, "utf8");
+    const next = removeCursorHook(current, hookCommand);
+    if (next !== current) writeFileSync2(paths.hooksPath, next);
+  } catch {
+  }
+}
+async function report(options) {
+  const config = readJson(options.paths.configPath);
+  const token = config.token;
+  if (!token) return { code: EXIT_USAGE, message: "No hay token. Hay que hacer login en esta conexi\xF3n." };
+  const device = config.device ?? newDevice();
+  const baseUrl = resolveUsageBaseUrl(options.baseUrl);
+  if (!baseUrl) return { code: EXIT_USAGE, message: "La URL del API tiene que ser https." };
+  const today = utcDay(options.now ?? /* @__PURE__ */ new Date());
+  const probe = await fetchUsageSource({ baseUrl, token, fetchImpl: options.fetchImpl });
+  if (probe.status === 401) {
+    return { code: EXIT_REPORT, message: "El servidor no reconoce el token. Hay que repetir el login con un token nuevo." };
+  }
+  const source = probe.source ?? config.source;
+  if (!source) {
+    return { code: EXIT_REPORT, message: `No se pudo saber qu\xE9 herramienta informa esta conexi\xF3n (${probe.status}). Se reintentar\xE1.` };
+  }
+  const files = readSpool(options.paths.spoolPath);
+  const accepted = /* @__PURE__ */ new Set();
+  const outcome = { error: void 0, mismatch: false, acceptedAny: false };
+  let lastAccepted = config.lastAcceptedDay;
+  let claudeState = config.claude;
+  let codexState = config.codex;
+  const send = async (day, rows, kept) => {
+    if (rows.length === 0) return "skip";
+    if (rows.length > MAX_ROWS) {
+      outcome.error = `El d\xEDa ${day} tiene m\xE1s de ${MAX_ROWS} modelos y no se ha subido.`;
+      return "stop";
+    }
+    const result = await postTelemetry({
+      baseUrl,
+      token,
+      day,
+      rows,
+      fetchImpl: options.fetchImpl,
+      source,
+      ...source === "github_copilot" ? {} : { device }
+    });
+    if (result.ok) {
+      outcome.acceptedAny = true;
+      accepted.add(day);
+      if (!lastAccepted || day > lastAccepted) lastAccepted = day;
+      return "ok";
+    }
+    if (result.code === "AI_USAGE_SOURCE_MISMATCH") {
+      outcome.mismatch = true;
+      return "stop";
+    }
+    if (source === "github_copilot" && result.code === "AI_USAGE_DAY_INVALID") return "skip";
+    outcome.error = `El d\xEDa ${day} no se acept\xF3 (${result.code ?? result.status}).${kept}`;
+    return "stop";
+  };
+  let copilotAuth = false;
+  let copilotUnavailable = false;
+  let codexAuth;
+  if (source === "cursor") {
+    const byDay = aggregateByDay(files.flatMap((file) => file.event ? [file.event] : []));
+    for (const day of [...byDay.keys()].sort()) {
+      if (await send(day, byDay.get(day) ?? [], " El spool de ese d\xEDa sigue en el port\xE1til.") === "stop") break;
+    }
+  } else if (source === "claude_code") {
+    const claudeDir = options.claudeProjectsDir;
+    const ready = claudeDir && existsSync2(claudeDir) ? readClaudeIncrement(claudeDir, config.claude ?? emptyClaudeState(today)) : null;
+    if (ready) {
+      for (const day of ready.dirtyDays) {
+        if (await send(day, rowsForDay(ready.state.days, day), " La transcripci\xF3n sigue en el port\xE1til.") === "stop") break;
+      }
+      if (!outcome.error) {
+        claudeState = ready.state;
+        if (ready.caughtUp) pruneClaudeDays(claudeState, previousUtcDay(today));
+      }
+    }
+  } else if (source === "github_copilot") {
+    if (options.gh) {
+      for (const day of [previousUtcDay(today), today]) {
+        const read = await readCopilotDay(options.gh, day);
+        if (read.status === "auth") {
+          copilotAuth = true;
+          break;
+        }
+        if (read.status === "unavailable") {
+          copilotUnavailable = true;
+          break;
+        }
+        if (read.status !== "rows") continue;
+        if (await send(day, read.rows, "") === "stop") break;
+      }
+    }
+  } else {
+    const codexHome2 = options.codexHome;
+    if (codexHome2 && existsSync2(codexHome2)) {
+      const auth = readCodexAuth(codexHome2);
+      const sessions = join4(codexHome2, "sessions");
+      if (auth !== "chatgpt") codexAuth = auth;
+      else if (existsSync2(sessions)) {
+        const ready = readCodexIncrement(sessions, codexState ?? emptyCodexState(today));
+        for (const day of ready.dirtyDays) {
+          if (await send(day, rowsForCodexDay(ready.state.days, day), " La sesi\xF3n sigue en el port\xE1til.") === "stop") break;
+        }
+        if (!outcome.error) {
+          codexState = ready.state;
+          if (ready.caughtUp) {
+            const before = previousUtcDay(today);
+            for (const day of Object.keys(codexState.days)) {
+              if (day < before) delete codexState.days[day];
+            }
+          }
+        }
+      }
+    }
+  }
+  const dropSpool = source !== "cursor" || outcome.mismatch;
+  if (dropSpool) dropCursorHook(options.paths, options.hookCommand);
+  for (const file of files) {
+    const day = file.event?.at.slice(0, 10);
+    if (dropSpool || day && day < today && accepted.has(day)) unlinkSync(file.path);
+  }
+  const next = { token, device };
+  if (lastAccepted) next.lastAcceptedDay = lastAccepted;
+  if (claudeState) next.claude = claudeState;
+  if (codexState) next.codex = codexState;
+  if (!outcome.mismatch) next.source = source;
+  writeJson(options.paths.configPath, next);
+  if (outcome.error) return { code: EXIT_REPORT, message: outcome.error };
+  if (outcome.mismatch) {
+    return { code: 0, message: "El uso de esta herramienta no corresponde a esta conexi\xF3n y no se ha subido." };
+  }
+  if (copilotAuth && !outcome.acceptedAny) {
+    return { code: EXIT_COPILOT, message: "gh no tiene permiso para leer el uso de Copilot. No se ha escrito una fila vac\xEDa." };
+  }
+  if (copilotUnavailable) {
+    return { code: EXIT_COPILOT, message: "No se pudo usar gh. Hace falta GitHub CLI con gh auth login en la cuenta de Copilot." };
+  }
+  if (!outcome.acceptedAny) {
+    if (codexAuth === "api_key") {
+      return { code: 0, message: "Codex usa una API key. Ese gasto no se atribuye a la cuenta individual." };
+    }
+    if (codexAuth === "unknown") {
+      return { code: 0, message: "No se pudo confirmar que Codex use la suscripci\xF3n de ChatGPT. No se ha subido nada." };
+    }
+    return { code: 0, message: "No hay uso nuevo que subir." };
+  }
+  return { code: 0, message: `Uso aceptado hasta ${lastAccepted ?? "hoy"}.` };
+}
+function previousUtcDay(day) {
+  return new Date(Date.parse(`${day}T00:00:00Z`) - 864e5).toISOString().slice(0, 10);
+}
+async function status(options) {
+  const config = readJson(options.paths.configPath);
+  const installed = await options.launcher.installed();
+  const lines = [
+    `agente: ${config.token ? "instalado" : "ausente"}`,
+    `arranque: ${installed ? "s\xED" : "no"}`,
+    `herramienta: ${config.source ?? "sin comprobar"}`,
+    `\xFAltimo d\xEDa aceptado: ${config.lastAcceptedDay ?? "ninguno"}`
+  ];
+  return { code: 0, message: lines.join("\n") };
+}
+
+// src/cli.ts
+var DEFAULT_BASE_URL = "https://api.aaa-sentinel.com";
+var execFileAsync = promisify(execFile);
+function nodeExec(file, args) {
+  return execFileAsync(file, args, { windowsHide: true }).then(
+    () => ({ code: 0, stderr: "" }),
+    (error) => ({
+      code: typeof error.code === "number" ? error.code : 1,
+      stderr: [error.stderr, error.stdout].filter((part) => part).join("\n") || error.message
+    })
+  );
+}
+function pathsFromEnv() {
+  const home = process.env["SENTINEL_USAGE_HOME"] ?? join5(homedir(), ".config", "aaa-sentinel");
+  return {
+    configPath: join5(home, "usage.json"),
+    spoolPath: join5(home, "spool"),
+    hooksPath: process.env["SENTINEL_USAGE_CURSOR_HOOKS"] ?? join5(homedir(), ".cursor", "hooks.json")
+  };
+}
+function codexHome() {
+  return process.env["SENTINEL_USAGE_CODEX_HOME"] || process.env["CODEX_HOME"] || join5(homedir(), ".codex");
+}
+function ghRun(args) {
+  return execFileAsync("gh", args, { windowsHide: true }).then(
+    (result) => ({ code: 0, stdout: String(result.stdout ?? ""), stderr: String(result.stderr ?? "") }),
+    (error) => ({
+      code: error.code === "ENOENT" ? 127 : typeof error.code === "number" ? error.code : 1,
+      stdout: String(error.stdout ?? ""),
+      stderr: error.code === "ENOENT" ? "ENOENT" : String(error.stderr ?? error.message)
+    })
+  );
+}
+function claudeProjectsDir() {
+  if (process.env["SENTINEL_USAGE_CLAUDE_DIR"]) return process.env["SENTINEL_USAGE_CLAUDE_DIR"];
+  return join5(process.env["CLAUDE_CONFIG_DIR"] ?? join5(homedir(), ".claude"), "projects");
+}
+function hookArgs(spoolPath) {
+  const hookJs = fileURLToPath(new URL("./hook.js", import.meta.url));
+  return [process.execPath, hookJs, spoolPath];
+}
+function reportArgs() {
+  const cliJs = fileURLToPath(new URL("./cli.js", import.meta.url));
+  return [process.execPath, cliJs, "report"];
+}
+async function main() {
+  const [command, tokenArg] = [process.argv[2], process.argv[3]];
+  const paths = pathsFromEnv();
+  const hookCommand = formatCommand(hookArgs(paths.spoolPath));
+  const uid = process.getuid?.();
+  const launcher = createLauncher({
+    platform: process.platform,
+    exec: nodeExec,
+    // El hook solo escribe el spool. Si la tarea lo relanza, el informe no sale del portátil.
+    args: reportArgs(),
+    homeDir: homedir(),
+    scriptDir: dirname2(paths.configPath),
+    ...uid !== void 0 ? { uid } : {}
+  });
+  if (command === "login") {
+    if (tokenArg) {
+      console.log("Pasa el token por la entrada est\xE1ndar, no como argumento: quedar\xEDa en el historial del shell.");
+      return 2;
+    }
+    if (process.stdin.isTTY) {
+      console.log("Redirige el token a la entrada est\xE1ndar. No se lee desde el teclado para no mostrarlo.");
+      return 2;
+    }
+    const token = (await readStdin()).trim();
+    const result = await login({ token, paths, launcher, hookCommand });
+    console.log(result.message);
+    return result.code;
+  }
+  if (command === "logout") {
+    const result = await logout({ paths, launcher, hookCommand });
+    console.log(result.message);
+    return result.code;
+  }
+  if (command === "report") {
+    const baseUrl = process.env["SENTINEL_USAGE_BASE_URL"] ?? DEFAULT_BASE_URL;
+    const result = await report({
+      paths,
+      baseUrl,
+      fetchImpl: fetch,
+      claudeProjectsDir: claudeProjectsDir(),
+      codexHome: codexHome(),
+      gh: ghRun,
+      hookCommand
+    });
+    console.log(result.message);
+    return result.code;
+  }
+  if (command === "status") {
+    const result = await status({ paths, launcher });
+    console.log(result.message);
+    return result.code;
+  }
+  console.log("Uso: sentinel-usage login|logout|report|status");
+  return 2;
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    process.stdin.on("error", reject);
+  });
+}
+main().then((code) => {
+  process.exitCode = code;
+}).catch((error) => {
+  console.error(`sentinel-usage: ${error.message}`);
+  process.exitCode = 1;
+});