@askexenow/exe-os 0.9.287 → 0.9.288

package/dist/chunk-E4BXNYLD.js

@@ -0,0 +1,128 @@
+import {
+  getCurrentSessionScope,
+  strictSessionScopeFilter
+} from "./chunk-5XOAYMSU.js";
+import {
+  getProjectName
+} from "./chunk-OPU3NYOO.js";
+
+// src/lib/session-events.ts
+import { randomUUID } from "crypto";
+async function ensureSessionEventsTable(client) {
+  await client.execute(`
+    CREATE TABLE IF NOT EXISTS session_events (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      session_scope TEXT,
+      project_name  TEXT NOT NULL,
+      event_index   INTEGER NOT NULL,
+      event_type    TEXT NOT NULL,
+      tool_name     TEXT,
+      tool_use_id   TEXT,
+      content       TEXT NOT NULL,
+      payload_json  TEXT,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      created_at    TEXT NOT NULL
+    )
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_agent_time
+      ON session_events(agent_id, created_at DESC)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_session_index
+      ON session_events(session_id, event_index)
+  `);
+  await client.execute(`
+    CREATE INDEX IF NOT EXISTS idx_session_events_scope_agent_time
+      ON session_events(session_scope, agent_id, created_at DESC)
+  `);
+}
+async function recordSessionEvent(client, input) {
+  if (!input.content || input.content.trim().length === 0) return;
+  await ensureSessionEventsTable(client);
+  const maxResult = await client.execute({
+    sql: "SELECT COALESCE(MAX(event_index), 0) AS max_index FROM session_events WHERE session_id = ?",
+    args: [input.sessionId]
+  });
+  const currentMax = Number(maxResult.rows[0]?.max_index ?? 0);
+  const eventIndex = Number.isFinite(currentMax) ? currentMax + 1 : 1;
+  await client.execute({
+    sql: `INSERT INTO session_events (
+            id, agent_id, agent_role, session_id, session_scope, project_name,
+            event_index, event_type, tool_name, tool_use_id, content,
+            payload_json, has_error, created_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      randomUUID(),
+      input.agentId,
+      input.agentRole,
+      input.sessionId,
+      input.sessionScope ?? getCurrentSessionScope(),
+      input.projectName ?? getProjectName(input.cwd),
+      eventIndex,
+      input.eventType,
+      input.toolName ?? null,
+      input.toolUseId ?? null,
+      input.content,
+      input.payloadJson ?? null,
+      input.hasError ? 1 : 0,
+      input.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
+    ]
+  });
+}
+async function listRecentSessionEvents(client, options) {
+  await ensureSessionEventsTable(client);
+  const conditions = ["agent_id = ?"];
+  const args = [options.agentId];
+  if (options.sessionId) {
+    conditions.push("session_id = ?");
+    args.push(options.sessionId);
+  }
+  if (options.eventType) {
+    conditions.push("event_type = ?");
+    args.push(options.eventType);
+  }
+  if (options.projectName && options.projectName !== "all") {
+    conditions.push("project_name = ?");
+    args.push(options.projectName);
+  }
+  const scope = strictSessionScopeFilter(options.sessionScope);
+  const where = `WHERE ${conditions.join(" AND ")}${scope.sql}`;
+  args.push(...scope.args);
+  args.push(Math.min(Math.max(options.limit ?? 20, 1), 100));
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, agent_role, session_id, session_scope,
+                 project_name, event_index, event_type, tool_name, tool_use_id,
+                 content, payload_json, has_error, created_at
+          FROM session_events
+          ${where}
+          ORDER BY created_at DESC, event_index DESC
+          LIMIT ?`,
+    args
+  });
+  return result.rows.map((row) => ({
+    id: String(row.id),
+    agentId: String(row.agent_id),
+    agentRole: String(row.agent_role),
+    sessionId: String(row.session_id),
+    sessionScope: row.session_scope == null ? null : String(row.session_scope),
+    projectName: String(row.project_name),
+    eventIndex: Number(row.event_index),
+    eventType: String(row.event_type),
+    toolName: row.tool_name == null ? null : String(row.tool_name),
+    toolUseId: row.tool_use_id == null ? null : String(row.tool_use_id),
+    content: String(row.content),
+    payloadJson: row.payload_json == null ? null : String(row.payload_json),
+    hasError: Number(row.has_error) === 1,
+    createdAt: String(row.created_at)
+  }));
+}
+
+export {
+  ensureSessionEventsTable,
+  recordSessionEvent,
+  listRecentSessionEvents
+};

package/dist/chunk-EKXOBH7F.js

@@ -0,0 +1,227 @@
+import {
+  getClient
+} from "./chunk-XVDWHYIK.js";
+
+// src/lib/token-spend.ts
+import { readdir, stat } from "fs/promises";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import path from "path";
+import os from "os";
+var MODEL_PRICING = {
+  // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
+  "claude-opus-4-7": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-6": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-5": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  // Opus 4.0/4.1 (legacy $15/$75)
+  "claude-opus-4-1": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  "claude-opus-4": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 4.x
+  "claude-sonnet-4": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Sonnet 3.7/3.5
+  "claude-3-7-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  "claude-3-5-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 4.5
+  "claude-haiku-4-5": { input: 1 / 1e6, output: 5 / 1e6, cacheRead: 0.1 / 1e6, cacheWrite: 1.25 / 1e6 },
+  // Haiku 3.5
+  "claude-3-5-haiku": { input: 0.8 / 1e6, output: 4 / 1e6, cacheRead: 0.08 / 1e6, cacheWrite: 1 / 1e6 },
+  // Opus 3
+  "claude-3-opus": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 3
+  "claude-3-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 3
+  "claude-3-haiku": { input: 0.25 / 1e6, output: 1.25 / 1e6, cacheRead: 0.03 / 1e6, cacheWrite: 0.3 / 1e6 }
+};
+var DEFAULT_PRICING = MODEL_PRICING["claude-sonnet-4"];
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var JSONL_INDEX_TTL_MS = 5 * 60 * 1e3;
+var USAGE_CACHE_MAX_ENTRIES = 1e4;
+var _spendCache = /* @__PURE__ */ new Map();
+var _spendInFlight = /* @__PURE__ */ new Map();
+var _usageCache = /* @__PURE__ */ new Map();
+var _usageInFlight = /* @__PURE__ */ new Map();
+var _jsonlPathIndex = null;
+function yieldToEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function getPricing(model) {
+  if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+  const stripped = model.replace(/-\d{8}$/, "");
+  if (MODEL_PRICING[stripped]) return MODEL_PRICING[stripped];
+  const sortedKeys = Object.keys(MODEL_PRICING).sort((a, b) => b.length - a.length);
+  for (const key of sortedKeys) {
+    if (model.includes(key)) return MODEL_PRICING[key];
+  }
+  return DEFAULT_PRICING;
+}
+async function getAgentSpend(period = "7d") {
+  const cached = _spendCache.get(period);
+  if (cached && Date.now() < cached.expires) {
+    return cached.result;
+  }
+  const inFlight = _spendInFlight.get(period);
+  if (inFlight) return inFlight;
+  const promise = computeAgentSpend(period).finally(() => _spendInFlight.delete(period));
+  _spendInFlight.set(period, promise);
+  return promise;
+}
+async function computeAgentSpend(period) {
+  const cutoff = periodToCutoff(period);
+  const client = getClient();
+  const dbResult = await client.execute({
+    sql: `SELECT session_uuid, agent_id FROM session_agent_map WHERE started_at >= ?`,
+    args: [cutoff]
+  });
+  if (dbResult.rows.length === 0) return [];
+  const sessionAgent = /* @__PURE__ */ new Map();
+  for (const row of dbResult.rows) {
+    sessionAgent.set(row.session_uuid, row.agent_id);
+  }
+  const jsonlPaths = await getClaudeSessionJsonlIndex();
+  if (jsonlPaths.size === 0) return [];
+  const agentTotals = /* @__PURE__ */ new Map();
+  let processed = 0;
+  for (const [sessionUuid, agentId] of sessionAgent) {
+    const jsonlPath = jsonlPaths.get(sessionUuid);
+    if (!jsonlPath) continue;
+    try {
+      const usage = await extractSessionUsageCached(jsonlPath);
+      if (usage.input === 0 && usage.output === 0) continue;
+      const totals = agentTotals.get(agentId) ?? {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheCreate: 0,
+        costUSD: 0,
+        sessions: /* @__PURE__ */ new Set()
+      };
+      totals.input += usage.input;
+      totals.output += usage.output;
+      totals.cacheRead += usage.cacheRead;
+      totals.cacheCreate += usage.cacheCreate;
+      totals.costUSD += usage.costUSD;
+      totals.sessions.add(sessionUuid);
+      agentTotals.set(agentId, totals);
+    } catch {
+    }
+    processed++;
+    if (processed % 25 === 0) await yieldToEventLoop();
+  }
+  const result = Array.from(agentTotals.entries()).map(([agentId, t]) => ({
+    agentId,
+    inputTokens: t.input,
+    outputTokens: t.output,
+    cacheReadTokens: t.cacheRead,
+    cacheCreationTokens: t.cacheCreate,
+    costUSD: t.costUSD,
+    sessions: t.sessions.size,
+    period
+  })).sort((a, b) => b.costUSD - a.costUSD);
+  _spendCache.set(period, { result, expires: Date.now() + CACHE_TTL_MS });
+  return result;
+}
+async function getClaudeSessionJsonlIndex() {
+  if (_jsonlPathIndex && Date.now() < _jsonlPathIndex.expires) {
+    return _jsonlPathIndex.paths;
+  }
+  const claudeDir = path.join(os.homedir(), ".claude", "projects");
+  const paths = /* @__PURE__ */ new Map();
+  let projectDirs = [];
+  try {
+    const entries = await readdir(claudeDir, { withFileTypes: true });
+    projectDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(claudeDir, entry.name));
+  } catch {
+    _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+    return paths;
+  }
+  let scanned = 0;
+  for (const dir of projectDirs) {
+    try {
+      const files = await readdir(dir);
+      for (const file of files) {
+        if (!file.endsWith(".jsonl")) continue;
+        paths.set(file.slice(0, -".jsonl".length), path.join(dir, file));
+      }
+    } catch {
+    }
+    scanned++;
+    if (scanned % 25 === 0) await yieldToEventLoop();
+  }
+  _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+  return paths;
+}
+async function extractSessionUsageCached(jsonlPath) {
+  const st = await stat(jsonlPath);
+  const cached = _usageCache.get(jsonlPath);
+  if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+    return cached.usage;
+  }
+  const existing = _usageInFlight.get(jsonlPath);
+  if (existing) return existing;
+  const promise = extractSessionUsage(jsonlPath).then((usage) => {
+    _usageCache.set(jsonlPath, { mtimeMs: st.mtimeMs, size: st.size, usage });
+    pruneUsageCache();
+    return usage;
+  }).finally(() => _usageInFlight.delete(jsonlPath));
+  _usageInFlight.set(jsonlPath, promise);
+  return promise;
+}
+function pruneUsageCache() {
+  if (_usageCache.size <= USAGE_CACHE_MAX_ENTRIES) return;
+  const overflow = _usageCache.size - USAGE_CACHE_MAX_ENTRIES;
+  let removed = 0;
+  for (const key of _usageCache.keys()) {
+    _usageCache.delete(key);
+    removed++;
+    if (removed >= overflow) break;
+  }
+}
+async function extractSessionUsage(jsonlPath) {
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheCreate = 0;
+  let costUSD = 0;
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  const rl = createInterface({
+    input: createReadStream(jsonlPath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.includes('"type":"assistant"')) continue;
+    try {
+      const record = JSON.parse(line);
+      if (record.type !== "assistant") continue;
+      const messageId = record.message?.id;
+      if (messageId) {
+        if (seenMessageIds.has(messageId)) continue;
+        seenMessageIds.add(messageId);
+      }
+      const usage = record.message?.usage;
+      if (!usage) continue;
+      const model = record.message?.model ?? "";
+      const pricing = getPricing(model);
+      const inp = usage.input_tokens ?? 0;
+      const out = usage.output_tokens ?? 0;
+      const cr = usage.cache_read_input_tokens ?? 0;
+      const cc = usage.cache_creation_input_tokens ?? 0;
+      input += inp;
+      output += out;
+      cacheRead += cr;
+      cacheCreate += cc;
+      if (pricing) {
+        costUSD += inp * pricing.input + out * pricing.output + cr * pricing.cacheRead + cc * pricing.cacheWrite;
+      }
+    } catch {
+    }
+  }
+  return { input, output, cacheRead, cacheCreate, costUSD };
+}
+function periodToCutoff(period) {
+  const ms = { "24h": 864e5, "7d": 6048e5, "30d": 2592e6 }[period];
+  return new Date(Date.now() - ms).toISOString();
+}
+
+export {
+  getAgentSpend
+};