@tokentop/agent-cursor 1.0.0 → 1.2.0

package/dist/index.js

@@ -1,10 +1,861 @@
 // src/index.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
+import * as fs4 from "fs";
 import {
   createAgentPlugin
 } from "@tokentop/plugin-sdk";
+
+// src/cache.ts
+var sessionCache = {
+  lastCheck: 0,
+  lastResult: [],
+  lastLimit: 0,
+  lastSince: undefined
+};
+var CACHE_TTL_MS = 2000;
+var SESSION_AGGREGATE_CACHE_MAX = 1e4;
+var sessionAggregateCache = new Map;
+function evictSessionAggregateCache() {
+  if (sessionAggregateCache.size <= SESSION_AGGREGATE_CACHE_MAX)
+    return;
+  const entries = Array.from(sessionAggregateCache.entries());
+  entries.sort((a, b) => a[1].lastAccessed - b[1].lastAccessed);
+  const toEvict = entries.length - SESSION_AGGREGATE_CACHE_MAX;
+  for (let i = 0;i < toEvict; i++) {
+    sessionAggregateCache.delete(entries[i][0]);
+  }
+}
+var composerMetadataIndex = new Map;
+
+// src/parser.ts
+import * as fs3 from "fs/promises";
+
+// src/paths.ts
+import * as fs from "fs/promises";
+import * as os from "os";
+import * as path from "path";
+var HOME = os.homedir();
+var PLATFORM = os.platform();
+var CURSOR_HOME = path.join(HOME, ".cursor");
+function getCursorUserDataPath() {
+  switch (PLATFORM) {
+    case "darwin":
+      return path.join(HOME, "Library", "Application Support", "Cursor", "User");
+    case "win32":
+      return path.join(process.env.APPDATA ?? path.join(HOME, "AppData", "Roaming"), "Cursor", "User");
+    default:
+      return path.join(HOME, ".config", "Cursor", "User");
+  }
+}
+var CURSOR_USER_DATA = getCursorUserDataPath();
+var CURSOR_GLOBAL_STORAGE_PATH = path.join(CURSOR_USER_DATA, "globalStorage");
+var CURSOR_WORKSPACE_STORAGE_PATH = path.join(CURSOR_USER_DATA, "workspaceStorage");
+var CURSOR_STATE_DB_PATH = path.join(CURSOR_GLOBAL_STORAGE_PATH, "state.vscdb");
+async function getWorkspaceDirs() {
+  try {
+    const entries = await fs.readdir(CURSOR_WORKSPACE_STORAGE_PATH, { withFileTypes: true });
+    const dirs = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        dirs.push(path.join(CURSOR_WORKSPACE_STORAGE_PATH, entry.name));
+      }
+    }
+    return dirs;
+  } catch {
+    return [];
+  }
+}
+
+// src/utils.ts
+import { Database } from "bun:sqlite";
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+function openDatabase(dbPath) {
+  try {
+    return new Database(dbPath, { readonly: true, create: false });
+  } catch {
+    return null;
+  }
+}
+function openDatabaseForWatcher(dbPath) {
+  try {
+    return new Database(dbPath, { readwrite: true, create: false });
+  } catch {
+    return null;
+  }
+}
+function readComposerData(db, composerId) {
+  try {
+    const row = db.query("SELECT value FROM cursorDiskKV WHERE key = ?").get(`composerData:${composerId}`);
+    if (!row)
+      return null;
+    return JSON.parse(row.value);
+  } catch {
+    return null;
+  }
+}
+function readBubbleData(db, composerId, bubbleId) {
+  try {
+    const row = db.query("SELECT value FROM cursorDiskKV WHERE key = ?").get(`bubbleId:${composerId}:${bubbleId}`);
+    if (!row)
+      return null;
+    return JSON.parse(row.value);
+  } catch {
+    return null;
+  }
+}
+function readAllComposerIds(db) {
+  try {
+    const PREFIX = "composerData:";
+    const rows = db.query("SELECT key FROM cursorDiskKV WHERE key LIKE 'composerData:%'").all();
+    return rows.map((row) => row.key.slice(PREFIX.length));
+  } catch {
+    return [];
+  }
+}
+function readAllBubbleKeys(db, composerId) {
+  try {
+    const PREFIX = `bubbleId:${composerId}:`;
+    const rows = db.query("SELECT key FROM cursorDiskKV WHERE key LIKE ?").all(`bubbleId:${composerId}:%`);
+    return rows.map((row) => row.key.slice(PREFIX.length));
+  } catch {
+    return [];
+  }
+}
+function readWorkspaceComposerIndex(workspaceDirPath) {
+  const dbPath = path2.join(workspaceDirPath, "state.vscdb");
+  const db = openDatabase(dbPath);
+  if (!db)
+    return null;
+  try {
+    const row = db.query("SELECT value FROM ItemTable WHERE key = 'composer.composerData'").get();
+    if (!row)
+      return null;
+    return JSON.parse(row.value);
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+async function readWorkspaceJson(workspaceDirPath) {
+  try {
+    const content = await fs2.readFile(path2.join(workspaceDirPath, "workspace.json"), "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function parseWorkspaceFolderUri(folderUri) {
+  if (folderUri.startsWith("file://")) {
+    try {
+      return decodeURIComponent(folderUri.slice(7));
+    } catch {
+      return folderUri.slice(7);
+    }
+  }
+  return folderUri;
+}
+function resolveProviderId(modelName) {
+  const lower = modelName.toLowerCase();
+  if (lower.startsWith("claude"))
+    return "anthropic";
+  if (lower.startsWith("gpt") || lower.startsWith("o1") || lower.startsWith("o3") || lower.startsWith("o4") || lower.startsWith("chatgpt") || lower.includes("codex"))
+    return "openai";
+  if (lower.startsWith("gemini"))
+    return "google";
+  if (lower.startsWith("deepseek"))
+    return "deepseek";
+  return "cursor";
+}
+
+// src/watcher.ts
+import * as fsSync from "fs";
+var RECONCILIATION_INTERVAL_MS = 10 * 60 * 1000;
+var sessionWatcher = {
+  watchers: [],
+  dirty: false,
+  reconciliationTimer: null,
+  started: false
+};
+var activityWatcher = {
+  watchers: [],
+  callback: null,
+  lastBubbleRowId: 0,
+  pendingBubbles: new Map,
+  pollTimer: null,
+  pendingPollTimer: null,
+  debounceTimer: null,
+  started: false
+};
+var forceFullReconciliation = false;
+var ASSISTANT_BUBBLE_TYPE = 2;
+function toTimestamp(isoString) {
+  if (!isoString)
+    return Date.now();
+  const parsed = Date.parse(isoString);
+  return Number.isFinite(parsed) ? parsed : Date.now();
+}
+function extractComposerId(key) {
+  const firstColon = key.indexOf(":");
+  const secondColon = key.indexOf(":", firstColon + 1);
+  return key.slice(firstColon + 1, secondColon);
+}
+function extractBubbleId(key) {
+  const firstColon = key.indexOf(":");
+  const secondColon = key.indexOf(":", firstColon + 1);
+  return key.slice(secondColon + 1);
+}
+function initializeRowIdCursor() {
+  const db = openDatabaseForWatcher(CURSOR_STATE_DB_PATH);
+  if (!db) {
+    return;
+  }
+  try {
+    const row = db.query("SELECT MAX(rowid) as maxRowId FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'").get();
+    activityWatcher.lastBubbleRowId = row?.maxRowId ?? 0;
+  } finally {
+    db.close();
+  }
+}
+function tryFireBubble(db, composerId, bubbleId, callback) {
+  if (!db)
+    return false;
+  const row = db.query("SELECT value FROM cursorDiskKV WHERE key = ?").get(`bubbleId:${composerId}:${bubbleId}`);
+  if (!row)
+    return false;
+  let bubble;
+  try {
+    bubble = JSON.parse(row.value);
+  } catch {
+    return false;
+  }
+  if (bubble.type !== ASSISTANT_BUBBLE_TYPE)
+    return true;
+  const tc = bubble.tokenCount;
+  const hasRealTokens = tc && typeof tc.inputTokens === "number" && tc.inputTokens > 0 || tc && typeof tc.outputTokens === "number" && tc.outputTokens > 0;
+  const outputTokens = hasRealTokens && tc ? tc.outputTokens ?? 0 : estimateOutputTokens(bubble.text);
+  const inputTokens = hasRealTokens && tc ? tc.inputTokens ?? 0 : 0;
+  if (inputTokens === 0 && outputTokens === 0)
+    return false;
+  const tokens = {
+    input: inputTokens,
+    output: outputTokens
+  };
+  callback({
+    sessionId: composerId,
+    messageId: typeof bubble.bubbleId === "string" ? bubble.bubbleId : bubbleId,
+    tokens,
+    timestamp: toTimestamp(bubble.createdAt)
+  });
+  return true;
+}
+function processDbChange() {
+  const callback = activityWatcher.callback;
+  if (!callback)
+    return;
+  const db = openDatabaseForWatcher(CURSOR_STATE_DB_PATH);
+  if (!db)
+    return;
+  try {
+    const rows = db.query("SELECT rowid, key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%' AND rowid > ? ORDER BY rowid ASC").all(activityWatcher.lastBubbleRowId);
+    for (const row of rows) {
+      activityWatcher.lastBubbleRowId = row.rowid;
+      sessionWatcher.dirty = true;
+      let bubble;
+      try {
+        bubble = JSON.parse(row.value);
+      } catch {
+        continue;
+      }
+      if (bubble.type !== ASSISTANT_BUBBLE_TYPE)
+        continue;
+      const composerId = extractComposerId(row.key);
+      const bubbleId = typeof bubble.bubbleId === "string" ? bubble.bubbleId : extractBubbleId(row.key);
+      if (!tryFireBubble(db, composerId, bubbleId, callback)) {
+        const pendingKey = `${composerId}:${bubbleId}`;
+        activityWatcher.pendingBubbles.set(pendingKey, { composerId, bubbleId });
+      }
+    }
+    if (activityWatcher.pendingBubbles.size > 0) {
+      const resolved = [];
+      for (const [pendingKey, { composerId, bubbleId }] of activityWatcher.pendingBubbles) {
+        if (tryFireBubble(db, composerId, bubbleId, callback)) {
+          resolved.push(pendingKey);
+        }
+      }
+      for (const key of resolved) {
+        activityWatcher.pendingBubbles.delete(key);
+      }
+    }
+    if (activityWatcher.pendingBubbles.size > 0 && !activityWatcher.pendingPollTimer) {
+      activityWatcher.pendingPollTimer = setTimeout(() => {
+        activityWatcher.pendingPollTimer = null;
+        processDbChange();
+      }, PENDING_POLL_MS);
+    } else if (activityWatcher.pendingBubbles.size === 0 && activityWatcher.pendingPollTimer) {
+      clearTimeout(activityWatcher.pendingPollTimer);
+      activityWatcher.pendingPollTimer = null;
+    }
+  } catch {} finally {
+    db.close();
+  }
+}
+function startSessionWatcher() {
+  if (sessionWatcher.started)
+    return;
+  sessionWatcher.started = true;
+  const pathsToWatch = [CURSOR_STATE_DB_PATH, `${CURSOR_STATE_DB_PATH}-wal`];
+  for (const p of pathsToWatch) {
+    try {
+      const w = fsSync.watch(p, () => {
+        sessionWatcher.dirty = true;
+      });
+      sessionWatcher.watchers.push(w);
+    } catch {}
+  }
+  sessionWatcher.reconciliationTimer = setInterval(() => {
+    forceFullReconciliation = true;
+  }, RECONCILIATION_INTERVAL_MS);
+}
+function consumeForceFullReconciliation() {
+  const value = forceFullReconciliation;
+  if (forceFullReconciliation) {
+    forceFullReconciliation = false;
+  }
+  return value;
+}
+var ACTIVITY_DEBOUNCE_MS = 150;
+var ACTIVITY_POLL_MS = 1000;
+var PENDING_POLL_MS = 500;
+function scheduleProcessDbChange() {
+  if (activityWatcher.debounceTimer)
+    return;
+  activityWatcher.debounceTimer = setTimeout(() => {
+    activityWatcher.debounceTimer = null;
+    processDbChange();
+  }, ACTIVITY_DEBOUNCE_MS);
+}
+function startActivityWatch(callback) {
+  activityWatcher.callback = callback;
+  if (activityWatcher.started)
+    return;
+  activityWatcher.started = true;
+  initializeRowIdCursor();
+  const pathsToWatch = [CURSOR_STATE_DB_PATH, `${CURSOR_STATE_DB_PATH}-wal`];
+  for (const p of pathsToWatch) {
+    try {
+      const w = fsSync.watch(p, () => {
+        scheduleProcessDbChange();
+      });
+      activityWatcher.watchers.push(w);
+    } catch {}
+  }
+  activityWatcher.pollTimer = setInterval(() => {
+    processDbChange();
+  }, ACTIVITY_POLL_MS);
+}
+function stopActivityWatch() {
+  activityWatcher.callback = null;
+}
+
+// src/auth.ts
+function readItemTableValue(db, key) {
+  try {
+    const row = db.query("SELECT value FROM ItemTable WHERE key = ?").get(key);
+    return row?.value ?? null;
+  } catch {
+    return null;
+  }
+}
+function decodeJwtPayload(jwt) {
+  try {
+    const parts = jwt.split(".");
+    if (parts.length !== 3)
+      return null;
+    const base64 = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const json = atob(base64);
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+function buildSessionCookie() {
+  const db = openDatabase(CURSOR_STATE_DB_PATH);
+  if (!db)
+    return null;
+  try {
+    const accessToken = readItemTableValue(db, "cursorAuth/accessToken");
+    if (!accessToken)
+      return null;
+    const payload = decodeJwtPayload(accessToken);
+    if (!payload || typeof payload.sub !== "string")
+      return null;
+    const userId = payload.sub;
+    return `WorkosCursorSessionToken=${userId}%3A%3A${accessToken}`;
+  } finally {
+    db.close();
+  }
+}
+
+// src/storage.ts
+var pluginStorage = null;
+var ENRICHMENT_CACHE_KEY = "enrichment-cache";
+function setPluginStorage(storage) {
+  pluginStorage = storage;
+}
+async function loadEnrichmentCache() {
+  if (!pluginStorage)
+    return null;
+  try {
+    const raw = await pluginStorage.get(ENRICHMENT_CACHE_KEY);
+    if (!raw)
+      return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed.sessions || typeof parsed.sessions !== "object")
+      return null;
+    const map = new Map;
+    for (const [sessionId, rows] of Object.entries(parsed.sessions)) {
+      if (Array.isArray(rows) && rows.length > 0) {
+        map.set(sessionId, rows);
+      }
+    }
+    return map.size > 0 ? map : null;
+  } catch {
+    return null;
+  }
+}
+function saveEnrichmentCache(cache) {
+  if (!pluginStorage || cache.size === 0)
+    return;
+  const payload = {
+    savedAt: new Date().toISOString(),
+    sessions: Object.fromEntries(cache)
+  };
+  pluginStorage.set(ENRICHMENT_CACHE_KEY, JSON.stringify(payload)).catch(() => {});
+}
+
+// src/csv.ts
+var USAGE_CSV_URL = "https://cursor.com/api/dashboard/export-usage-events-csv?strategy=tokens";
+var CSV_CACHE_TTL_MS = 5 * 60 * 1000;
+var MATCH_WINDOW_MS = 60000;
+var csvCache = null;
+var csvFetchInFlight = null;
+var sessionEnrichmentCache = new Map;
+var enrichmentCacheHydrated = false;
+function parseUsageCsv(csvText) {
+  const lines = csvText.trim().split(`
+`);
+  if (lines.length < 2)
+    return [];
+  const rows = [];
+  for (let i = 1;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line)
+      continue;
+    const cols = line.split(",").map((c) => c.replace(/^"|"$/g, ""));
+    if (cols.length < 10)
+      continue;
+    const timestamp = Date.parse(cols[0]);
+    if (!Number.isFinite(timestamp))
+      continue;
+    const outputTokens = parseInt(cols[7], 10);
+    if (!Number.isFinite(outputTokens) || outputTokens <= 0)
+      continue;
+    rows.push({
+      timestamp,
+      kind: cols[1].trim(),
+      model: cols[2].trim(),
+      maxMode: cols[3].trim().toLowerCase() === "true",
+      inputTokensWithCacheWrite: parseInt(cols[4], 10) || 0,
+      inputTokensWithoutCacheWrite: parseInt(cols[5], 10) || 0,
+      cacheReadTokens: parseInt(cols[6], 10) || 0,
+      outputTokens,
+      totalTokens: parseInt(cols[8], 10) || 0,
+      cost: parseFloat(cols[9]) || 0
+    });
+  }
+  return rows;
+}
+async function fetchCsvFromServer(ctx) {
+  const cookie = buildSessionCookie();
+  if (!cookie) {
+    ctx.logger.debug("Cursor CSV: no auth token available");
+    return [];
+  }
+  const response = await ctx.http.fetch(USAGE_CSV_URL, {
+    headers: { Cookie: cookie },
+    signal: ctx.signal
+  });
+  if (!response.ok) {
+    ctx.logger.debug("Cursor CSV: fetch failed", { status: response.status });
+    return [];
+  }
+  const csvText = await response.text();
+  return parseUsageCsv(csvText);
+}
+async function getCsvRows(ctx) {
+  if (ctx.config.csvEnrichment === false)
+    return [];
+  const refreshMinutes = typeof ctx.config.csvRefreshMinutes === "number" ? ctx.config.csvRefreshMinutes : 5;
+  const ttlMs = refreshMinutes * 60 * 1000;
+  const now = Date.now();
+  if (csvCache && now - csvCache.fetchedAt < ttlMs) {
+    return csvCache.rows;
+  }
+  if (!csvFetchInFlight) {
+    csvFetchInFlight = fetchCsvFromServer(ctx).then((rows) => {
+      csvCache = { rows, fetchedAt: Date.now() };
+      ctx.logger.debug("Cursor CSV: cached", { rowCount: rows.length });
+    }).catch((err) => {
+      ctx.logger.debug("Cursor CSV: fetch error", { error: String(err) });
+    }).finally(() => {
+      csvFetchInFlight = null;
+    });
+  }
+  if (csvFetchInFlight) {
+    await csvFetchInFlight;
+  }
+  return csvCache?.rows ?? [];
+}
+async function hydrateEnrichmentCache() {
+  if (enrichmentCacheHydrated)
+    return;
+  enrichmentCacheHydrated = true;
+  const persisted = await loadEnrichmentCache();
+  if (!persisted)
+    return;
+  for (const [sessionId, rows] of persisted) {
+    if (!sessionEnrichmentCache.has(sessionId)) {
+      sessionEnrichmentCache.set(sessionId, rows);
+    }
+  }
+}
+async function enrichWithCsvData(localRows, csvRows) {
+  await hydrateEnrichmentCache();
+  if (csvRows.length === 0) {
+    if (sessionEnrichmentCache.size === 0)
+      return localRows;
+    return applyEnrichmentCache(localRows);
+  }
+  const sessionGroups = new Map;
+  for (const row of localRows) {
+    const existing = sessionGroups.get(row.sessionId);
+    if (existing) {
+      existing.rows.push(row);
+    } else {
+      sessionGroups.set(row.sessionId, { rows: [row] });
+    }
+  }
+  const sortedCsv = [...csvRows].sort((a, b) => a.timestamp - b.timestamp);
+  const usedCsvIndices = new Set;
+  const sessionCsvMap = new Map;
+  for (const [sessionId, group] of sessionGroups) {
+    const updatedAt = group.rows.reduce((max, r) => {
+      const ts = r.sessionUpdatedAt ?? r.timestamp;
+      return ts > max ? ts : max;
+    }, 0);
+    let bestIdx = -1;
+    let bestDelta = Infinity;
+    for (let i = 0;i < sortedCsv.length; i++) {
+      if (usedCsvIndices.has(i))
+        continue;
+      const delta = Math.abs(sortedCsv[i].timestamp - updatedAt);
+      if (delta > MATCH_WINDOW_MS)
+        continue;
+      if (delta < bestDelta) {
+        bestDelta = delta;
+        bestIdx = i;
+      }
+    }
+    if (bestIdx !== -1) {
+      usedCsvIndices.add(bestIdx);
+      sessionCsvMap.set(sessionId, sortedCsv[bestIdx]);
+    }
+  }
+  const enrichedRows = localRows.map((row) => {
+    const csv = sessionCsvMap.get(row.sessionId);
+    if (!csv)
+      return row;
+    const group = sessionGroups.get(row.sessionId);
+    const totalEstOutput = group.rows.reduce((sum, r) => sum + r.tokens.output, 0);
+    const weight = totalEstOutput > 0 ? row.tokens.output / totalEstOutput : 1 / group.rows.length;
+    const cacheWrite = csv.inputTokensWithCacheWrite - csv.inputTokensWithoutCacheWrite;
+    return {
+      ...row,
+      tokens: {
+        input: Math.round(csv.inputTokensWithoutCacheWrite * weight),
+        output: Math.round(csv.outputTokens * weight),
+        ...csv.cacheReadTokens > 0 ? { cacheRead: Math.round(csv.cacheReadTokens * weight) } : {},
+        ...cacheWrite > 0 ? { cacheWrite: Math.round(cacheWrite * weight) } : {}
+      },
+      ...csv.cost > 0 ? { cost: Number((csv.cost * weight).toFixed(6)) } : {},
+      metadata: { isEstimated: false }
+    };
+  });
+  let cacheUpdated = false;
+  for (const [sessionId] of sessionCsvMap) {
+    const sessionRows = enrichedRows.filter((r) => r.sessionId === sessionId);
+    if (sessionRows.length > 0) {
+      sessionEnrichmentCache.set(sessionId, sessionRows);
+      cacheUpdated = true;
+    }
+  }
+  if (cacheUpdated) {
+    saveEnrichmentCache(sessionEnrichmentCache);
+  }
+  if (sessionCsvMap.size < sessionGroups.size && sessionEnrichmentCache.size > 0) {
+    return enrichedRows.map((row) => {
+      if (sessionCsvMap.has(row.sessionId))
+        return row;
+      return applyCachedEnrichmentToRow(row) ?? row;
+    });
+  }
+  return enrichedRows;
+}
+function applyEnrichmentCache(localRows) {
+  return localRows.map((row) => applyCachedEnrichmentToRow(row) ?? row);
+}
+function applyCachedEnrichmentToRow(row) {
+  const cachedRows = sessionEnrichmentCache.get(row.sessionId);
+  if (!cachedRows)
+    return null;
+  const match = cachedRows.find((c) => c.timestamp === row.timestamp);
+  if (!match)
+    return null;
+  return {
+    ...row,
+    tokens: match.tokens,
+    ...match.cost !== undefined ? { cost: match.cost } : {},
+    metadata: { isEstimated: false }
+  };
+}
+function resetCsvCache() {
+  csvCache = null;
+  csvFetchInFlight = null;
+  sessionEnrichmentCache.clear();
+}
+
+// src/parser.ts
+var ASSISTANT_BUBBLE_TYPE2 = 2;
+var ESTIMATED_CHARS_PER_TOKEN = 4;
+function toTimestamp2(isoString, fallback) {
+  if (!isoString)
+    return fallback;
+  const parsed = Date.parse(isoString);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function isAssistantBubble(bubble) {
+  if (!bubble || typeof bubble !== "object")
+    return false;
+  const candidate = bubble;
+  if (candidate.type !== ASSISTANT_BUBBLE_TYPE2)
+    return false;
+  if (typeof candidate.bubbleId !== "string" || candidate.bubbleId.length === 0)
+    return false;
+  const hasTokens = candidate.tokenCount && typeof candidate.tokenCount === "object" && typeof candidate.tokenCount.inputTokens === "number" && typeof candidate.tokenCount.outputTokens === "number";
+  const hasText = typeof candidate.text === "string" && candidate.text.length > 0;
+  return hasTokens || hasText;
+}
+function estimateOutputTokens(text) {
+  if (!text || text.length === 0)
+    return 0;
+  return Math.ceil(text.length / ESTIMATED_CHARS_PER_TOKEN);
+}
+function resolveModelName(bubble, composer) {
+  const bubbleModel = bubble.modelInfo?.modelName;
+  if (bubbleModel && bubbleModel !== "default" && bubbleModel !== "?") {
+    return bubbleModel;
+  }
+  const composerModel = composer.modelConfig?.modelName;
+  if (composerModel && composerModel !== "default") {
+    return composerModel;
+  }
+  return "cursor-default";
+}
+function parseComposerBubbles(db, meta, composer, shouldEstimate = true) {
+  const deduped = new Map;
+  const bubbleIds = readAllBubbleKeys(db, meta.composerId);
+  for (const bubbleId of bubbleIds) {
+    const bubble = readBubbleData(db, meta.composerId, bubbleId);
+    if (!isAssistantBubble(bubble))
+      continue;
+    const modelId = resolveModelName(bubble, composer);
+    const providerId = resolveProviderId(modelId);
+    const timestamp = toTimestamp2(bubble.createdAt, meta.lastUpdatedAt);
+    const hasRealTokens = bubble.tokenCount.inputTokens > 0 || bubble.tokenCount.outputTokens > 0;
+    const outputTokens = hasRealTokens ? bubble.tokenCount.outputTokens : shouldEstimate ? estimateOutputTokens(bubble.text) : 0;
+    const inputTokens = hasRealTokens ? bubble.tokenCount.inputTokens : 0;
+    if (inputTokens === 0 && outputTokens === 0)
+      continue;
+    const usage = {
+      sessionId: meta.composerId,
+      providerId,
+      modelId,
+      tokens: {
+        input: inputTokens,
+        output: outputTokens
+      },
+      timestamp,
+      metadata: { isEstimated: true },
+      sessionUpdatedAt: meta.lastUpdatedAt
+    };
+    if (meta.sessionName) {
+      usage.sessionName = meta.sessionName;
+    }
+    if (meta.projectPath) {
+      usage.projectPath = meta.projectPath;
+    }
+    deduped.set(bubble.bubbleId, usage);
+  }
+  return Array.from(deduped.values());
+}
+async function buildWorkspaceMap() {
+  const workspaceDirs = await getWorkspaceDirs();
+  const composerToWorkspace = new Map;
+  for (const wsDir of workspaceDirs) {
+    const workspaceJson = await readWorkspaceJson(wsDir);
+    if (!workspaceJson?.folder)
+      continue;
+    const projectPath = parseWorkspaceFolderUri(workspaceJson.folder);
+    const workspaceHash = wsDir.split("/").pop() ?? wsDir.split("\\").pop() ?? "";
+    const index = readWorkspaceComposerIndex(wsDir);
+    if (!index?.allComposers)
+      continue;
+    const composerIds = index.allComposers.map((c) => c.composerId);
+    const info = {
+      workspaceHash,
+      projectPath,
+      composerIds
+    };
+    for (const cid of composerIds) {
+      composerToWorkspace.set(cid, info);
+    }
+  }
+  return composerToWorkspace;
+}
+async function parseSessionsFromWorkspaces(options, ctx) {
+  const limit = options.limit ?? 100;
+  const since = options.since;
+  try {
+    await fs3.access(CURSOR_STATE_DB_PATH);
+  } catch {
+    ctx.logger.debug("No Cursor state database found");
+    return [];
+  }
+  startSessionWatcher();
+  const now = Date.now();
+  if (!options.sessionId && limit === sessionCache.lastLimit && now - sessionCache.lastCheck < CACHE_TTL_MS && sessionCache.lastResult.length > 0 && sessionCache.lastSince === since) {
+    ctx.logger.debug("Cursor: using cached sessions (within TTL)", { count: sessionCache.lastResult.length });
+    return sessionCache.lastResult;
+  }
+  const isDirty = sessionWatcher.dirty;
+  sessionWatcher.dirty = false;
+  const needsFullStat = consumeForceFullReconciliation();
+  if (needsFullStat) {
+    ctx.logger.debug("Cursor: full reconciliation sweep triggered");
+  }
+  const db = openDatabase(CURSOR_STATE_DB_PATH);
+  if (!db) {
+    ctx.logger.debug("Cursor: failed to open state database");
+    return [];
+  }
+  try {
+    const composerToWorkspace = await buildWorkspaceMap();
+    const composerIds = options.sessionId ? [options.sessionId] : readAllComposerIds(db);
+    const composers = [];
+    const seenComposerIds = new Set;
+    let statCount = 0;
+    let statSkipCount = 0;
+    for (const composerId of composerIds) {
+      seenComposerIds.add(composerId);
+      const composerData = readComposerData(db, composerId);
+      if (!composerData)
+        continue;
+      const lastUpdatedAt = composerData.lastUpdatedAt || composerData.createdAt || 0;
+      const metadata = composerMetadataIndex.get(composerId);
+      if (!isDirty && !needsFullStat && metadata && metadata.lastUpdatedAt === lastUpdatedAt) {
+        statSkipCount++;
+        if (!since || lastUpdatedAt >= since) {
+          const wsInfo2 = composerToWorkspace.get(composerId);
+          composers.push({
+            composerId,
+            lastUpdatedAt,
+            projectPath: wsInfo2?.projectPath,
+            sessionName: composerData.name
+          });
+        }
+        continue;
+      }
+      statCount++;
+      composerMetadataIndex.set(composerId, { lastUpdatedAt, composerId });
+      if (since && lastUpdatedAt < since)
+        continue;
+      const wsInfo = composerToWorkspace.get(composerId);
+      composers.push({
+        composerId,
+        lastUpdatedAt,
+        projectPath: wsInfo?.projectPath,
+        sessionName: composerData.name
+      });
+    }
+    for (const cachedId of composerMetadataIndex.keys()) {
+      if (!seenComposerIds.has(cachedId)) {
+        composerMetadataIndex.delete(cachedId);
+      }
+    }
+    composers.sort((a, b) => b.lastUpdatedAt - a.lastUpdatedAt);
+    const sessions = [];
+    let aggregateCacheHits = 0;
+    let aggregateCacheMisses = 0;
+    for (const meta of composers) {
+      const cached = sessionAggregateCache.get(meta.composerId);
+      const cacheStale = isDirty || needsFullStat || cached !== undefined && cached.usageRows.length === 0;
+      if (!cacheStale && cached && cached.updatedAt === meta.lastUpdatedAt) {
+        cached.lastAccessed = now;
+        aggregateCacheHits++;
+        sessions.push(...cached.usageRows);
+        continue;
+      }
+      aggregateCacheMisses++;
+      const composerData = readComposerData(db, meta.composerId);
+      if (!composerData)
+        continue;
+      const shouldEstimate = ctx.config.estimateTokens !== false;
+      const usageRows = parseComposerBubbles(db, meta, composerData, shouldEstimate);
+      sessionAggregateCache.set(meta.composerId, {
+        updatedAt: meta.lastUpdatedAt,
+        usageRows,
+        lastAccessed: now
+      });
+      sessions.push(...usageRows);
+    }
+    evictSessionAggregateCache();
+    const csvRows = await getCsvRows(ctx);
+    const enrichedSessions = await enrichWithCsvData(sessions, csvRows);
+    if (!options.sessionId) {
+      sessionCache.lastCheck = Date.now();
+      sessionCache.lastResult = enrichedSessions;
+      sessionCache.lastLimit = limit;
+      sessionCache.lastSince = since;
+    }
+    ctx.logger.debug("Cursor: parsed sessions", {
+      count: enrichedSessions.length,
+      composers: composers.length,
+      statChecks: statCount,
+      statSkips: statSkipCount,
+      aggregateCacheHits,
+      aggregateCacheMisses,
+      metadataIndexSize: composerMetadataIndex.size,
+      aggregateCacheSize: sessionAggregateCache.size,
+      csvEnriched: csvRows.length > 0
+    });
+    return enrichedSessions;
+  } finally {
+    db.close();
+  }
+}
+
+// src/index.ts
 var cursorAgentPlugin = createAgentPlugin({
   id: "cursor",
   type: "agent",
@@ -17,29 +868,80 @@ var cursorAgentPlugin = createAgentPlugin({
   permissions: {
     filesystem: {
       read: true,
-      paths: ["~/.cursor"]
+      paths: ["~/.cursor", "~/Library/Application Support/Cursor", "~/.config/Cursor"]
+    },
+    network: {
+      enabled: true,
+      allowedDomains: ["cursor.com"]
     }
   },
   agent: {
     name: "Cursor",
     command: "cursor",
-    configPath: path.join(os.homedir(), ".cursor"),
-    sessionPath: path.join(os.homedir(), ".cursor")
+    configPath: CURSOR_HOME,
+    sessionPath: CURSOR_GLOBAL_STORAGE_PATH
   },
   capabilities: {
-    sessionParsing: false,
+    sessionParsing: true,
     authReading: false,
-    realTimeTracking: false,
+    realTimeTracking: true,
     multiProvider: false
   },
-  async isInstalled(_ctx) {
-    return fs.existsSync(path.join(os.homedir(), ".cursor"));
+  configSchema: {
+    csvEnrichment: {
+      type: "boolean",
+      label: "Server enrichment",
+      description: "Fetch accurate token counts and costs from Cursor's server. When enabled, local estimates are replaced with exact data on subsequent refreshes.",
+      default: true
+    },
+    csvRefreshMinutes: {
+      type: "number",
+      label: "Server refresh interval",
+      description: "How often to fetch updated token data from the server (minutes).",
+      default: 5,
+      min: 1,
+      max: 60
+    },
+    estimateTokens: {
+      type: "boolean",
+      label: "Estimate tokens",
+      description: "Estimate output tokens from response text when exact server counts are unavailable. Provides immediate visibility while server data loads.",
+      default: true
+    }
+  },
+  defaultConfig: {
+    csvEnrichment: true,
+    csvRefreshMinutes: 5,
+    estimateTokens: true
   },
-  async parseSessions(_options, _ctx) {
-    return [];
+  startActivityWatch(ctx, callback) {
+    setPluginStorage(ctx.storage);
+    startActivityWatch(callback);
+  },
+  stopActivityWatch(_ctx) {
+    stopActivityWatch();
+  },
+  async isInstalled(ctx) {
+    setPluginStorage(ctx.storage);
+    return fs4.existsSync(CURSOR_STATE_DB_PATH) || fs4.existsSync(CURSOR_HOME);
+  },
+  async parseSessions(options, ctx) {
+    return parseSessionsFromWorkspaces(options, ctx);
   }
 });
 var src_default = cursorAgentPlugin;
 export {
-  src_default as default
+  sessionCache,
+  sessionAggregateCache,
+  resetCsvCache,
+  src_default as default,
+  composerMetadataIndex,
+  SESSION_AGGREGATE_CACHE_MAX,
+  RECONCILIATION_INTERVAL_MS,
+  CURSOR_WORKSPACE_STORAGE_PATH,
+  CURSOR_STATE_DB_PATH,
+  CURSOR_HOME,
+  CURSOR_GLOBAL_STORAGE_PATH,
+  CSV_CACHE_TTL_MS,
+  CACHE_TTL_MS
 };