slopmeter 0.4.1 → 0.5.0

package/dist/cli.js

@@ -2,7 +2,7 @@
 
 // src/cli.ts
 import { mkdirSync, writeFileSync } from "fs";
-import { dirname, extname, resolve as resolve4 } from "path";
+import { dirname, extname, resolve as resolve5 } from "path";
 import { parseArgs } from "util";
 import ora from "ora";
 import ow from "ow";
@@ -5715,6 +5715,35 @@ var heatmapThemes = {
       ]
     }
   },
+  cursor: {
+    title: "Cursor",
+    colors: {
+      light: [
+        "#fff7ed",
+        // orange-50
+        "#fed7aa",
+        // orange-200
+        "#fdba74",
+        // orange-300
+        "#f97316",
+        // orange-500
+        "#9a3412"
+        // orange-800
+      ],
+      dark: [
+        "#431407",
+        // orange-950
+        "#9a3412",
+        // orange-800
+        "#c2410c",
+        // orange-700
+        "#f97316",
+        // orange-500
+        "#fdba74"
+        // orange-300
+      ]
+    }
+  },
   opencode: {
     title: "Open Code",
     colors: {
@@ -5745,7 +5774,7 @@ var heatmapThemes = {
     }
   },
   all: {
-    title: "Codex / Claude Code / Open Code",
+    title: "Codex / Claude Code / Cursor / Open Code",
     titleCaption: "Total usage from",
     colors: {
       light: [
@@ -7007,19 +7036,468 @@ async function loadCodexRows(start, end, warnings = []) {
   return createUsageSummary("codex", totals, modelTotals, recentModelTotals, end);
 }
 
+// src/lib/cursor.ts
+import { existsSync as existsSync2 } from "fs";
+import { copyFile, mkdtemp, rm } from "fs/promises";
+import { homedir as homedir3, tmpdir } from "os";
+import { join as join4, resolve as resolve3 } from "path";
+import Database from "better-sqlite3";
+var CURSOR_CONFIG_DIR_ENV = "CURSOR_CONFIG_DIR";
+var CURSOR_STATE_DB_PATH_ENV = "CURSOR_STATE_DB_PATH";
+var CURSOR_WEB_BASE_URL_ENV = "CURSOR_WEB_BASE_URL";
+var CURSOR_STATE_DB_RELATIVE_PATH = join4(
+  "User",
+  "globalStorage",
+  "state.vscdb"
+);
+var CURSOR_SESSION_COOKIE_NAME = "WorkosCursorSessionToken";
+function getCursorDefaultStateDbPath() {
+  if (process.platform === "darwin") {
+    return join4(
+      homedir3(),
+      "Library",
+      "Application Support",
+      "Cursor",
+      CURSOR_STATE_DB_RELATIVE_PATH
+    );
+  }
+  if (process.platform === "win32") {
+    const appData = process.env.APPDATA?.trim() || join4(homedir3(), "AppData", "Roaming");
+    return join4(appData, "Cursor", CURSOR_STATE_DB_RELATIVE_PATH);
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join4(homedir3(), ".config");
+  return join4(xdgConfigHome, "Cursor", CURSOR_STATE_DB_RELATIVE_PATH);
+}
+function getCursorStateDbCandidates() {
+  const explicitDbPath = process.env[CURSOR_STATE_DB_PATH_ENV]?.trim();
+  if (explicitDbPath) {
+    return [resolve3(explicitDbPath)];
+  }
+  const configuredDirs = process.env[CURSOR_CONFIG_DIR_ENV]?.trim();
+  if (!configuredDirs) {
+    return [getCursorDefaultStateDbPath()];
+  }
+  return configuredDirs.split(",").map((value) => value.trim()).filter((value) => value !== "").map((value) => {
+    const resolved = resolve3(value);
+    return resolved.endsWith(".vscdb") ? resolved : join4(resolved, CURSOR_STATE_DB_RELATIVE_PATH);
+  });
+}
+function getCursorStateDbPath() {
+  const seen = /* @__PURE__ */ new Set();
+  for (const candidate of getCursorStateDbCandidates()) {
+    if (!seen.has(candidate) && existsSync2(candidate)) {
+      return candidate;
+    }
+    seen.add(candidate);
+  }
+  return null;
+}
+function normalizeCursorDbValue(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed === "" ? void 0 : trimmed;
+  }
+  if (Buffer.isBuffer(value)) {
+    const trimmed = value.toString("utf8").trim();
+    return trimmed === "" ? void 0 : trimmed;
+  }
+  return void 0;
+}
+function readCursorAuthStateFromDatabase(databasePath) {
+  const database = new Database(databasePath, {
+    readonly: true,
+    fileMustExist: true
+  });
+  try {
+    const query = database.prepare(
+      "SELECT value FROM ItemTable WHERE key = ? LIMIT 1"
+    );
+    const accessRow = query.get("cursorAuth/accessToken");
+    const refreshRow = query.get("cursorAuth/refreshToken");
+    return {
+      accessToken: normalizeCursorDbValue(accessRow?.value),
+      refreshToken: normalizeCursorDbValue(refreshRow?.value)
+    };
+  } finally {
+    database.close();
+  }
+}
+function isSqliteLockedError(error) {
+  return error instanceof Error && /database is locked/i.test(error.message);
+}
+async function withCursorStateSnapshot(databasePath, callback) {
+  const snapshotDir = await mkdtemp(join4(tmpdir(), "slopmeter-cursor-"));
+  const snapshotPath = join4(snapshotDir, "state.vscdb");
+  await copyFile(databasePath, snapshotPath);
+  for (const suffix of ["-shm", "-wal"]) {
+    const companionPath = `${databasePath}${suffix}`;
+    if (!existsSync2(companionPath)) {
+      continue;
+    }
+    await copyFile(companionPath, `${snapshotPath}${suffix}`);
+  }
+  try {
+    return await callback(snapshotPath);
+  } finally {
+    await rm(snapshotDir, { recursive: true, force: true });
+  }
+}
+async function readCursorAuthState(databasePath) {
+  try {
+    return readCursorAuthStateFromDatabase(databasePath);
+  } catch (error) {
+    if (!isSqliteLockedError(error)) {
+      throw error;
+    }
+    return withCursorStateSnapshot(
+      databasePath,
+      async (snapshotPath) => readCursorAuthStateFromDatabase(snapshotPath)
+    );
+  }
+}
+function decodeJwtPayload(token) {
+  const encodedPayload = token.split(".")[1];
+  if (!encodedPayload) {
+    return null;
+  }
+  const base64 = encodedPayload.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+  try {
+    return JSON.parse(Buffer.from(padded, "base64").toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function getCursorWebBaseUrl() {
+  return (process.env[CURSOR_WEB_BASE_URL_ENV]?.trim() || "https://cursor.com").replace(/\/+$/, "");
+}
+function buildCookieHeaderValue(cookieValue) {
+  return `${CURSOR_SESSION_COOKIE_NAME}=${cookieValue}`;
+}
+function getCursorFetchAttempts(accessToken) {
+  const attempts = [];
+  const seen = /* @__PURE__ */ new Set();
+  const subject = decodeJwtPayload(accessToken)?.sub?.trim();
+  const cookieValues = [accessToken];
+  if (subject) {
+    cookieValues.push(`${subject}::${accessToken}`);
+  }
+  const pushAttempt = (label, headers) => {
+    const signature = JSON.stringify({
+      label,
+      headers: Object.entries(headers).sort(
+        ([left], [right]) => left.localeCompare(right)
+      )
+    });
+    if (seen.has(signature)) {
+      return;
+    }
+    seen.add(signature);
+    attempts.push({ label, headers });
+  };
+  pushAttempt("bearer", {
+    Authorization: `Bearer ${accessToken}`
+  });
+  for (const cookieValue of cookieValues) {
+    pushAttempt("cookie", {
+      Cookie: buildCookieHeaderValue(cookieValue)
+    });
+    pushAttempt("cookie-encoded", {
+      Cookie: buildCookieHeaderValue(encodeURIComponent(cookieValue))
+    });
+    pushAttempt("bearer+cookie", {
+      Authorization: `Bearer ${accessToken}`,
+      Cookie: buildCookieHeaderValue(cookieValue)
+    });
+    pushAttempt("bearer+cookie-encoded", {
+      Authorization: `Bearer ${accessToken}`,
+      Cookie: buildCookieHeaderValue(encodeURIComponent(cookieValue))
+    });
+  }
+  return attempts;
+}
+async function fetchCursorUsageCsv(accessToken) {
+  const url = new URL(
+    "/api/dashboard/export-usage-events-csv?strategy=tokens",
+    getCursorWebBaseUrl()
+  );
+  const failures = [];
+  for (const attempt of getCursorFetchAttempts(accessToken)) {
+    const response = await fetch(url, {
+      headers: {
+        Accept: "text/csv,text/plain;q=0.9,*/*;q=0.8",
+        ...attempt.headers
+      }
+    });
+    if (response.ok) {
+      return response;
+    }
+    failures.push({
+      label: attempt.label,
+      status: response.status,
+      statusText: response.statusText,
+      body: (await response.text()).trim().slice(0, 200)
+    });
+  }
+  const summary = failures.map((failure) => {
+    const statusLine = `${failure.label}: ${failure.status} ${failure.statusText}`.trim();
+    return failure.body ? `${statusLine} (${failure.body})` : statusLine;
+  }).join("; ");
+  throw new Error(
+    `Failed to authenticate Cursor usage export with local auth state from ${url.origin}. ${summary}`
+  );
+}
+function parseCsvLine(line) {
+  const values = [];
+  let current = "";
+  let inQuotes = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (char === '"') {
+      if (inQuotes && line[index + 1] === '"') {
+        current += '"';
+        index += 1;
+        continue;
+      }
+      inQuotes = !inQuotes;
+      continue;
+    }
+    if (char === "," && !inQuotes) {
+      values.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  values.push(current);
+  return values;
+}
+function createCursorCsvRow(headers, values) {
+  const row = {};
+  headers.forEach((header, index) => {
+    row[header] = values[index];
+  });
+  return row;
+}
+function processCursorCsvLines(lines, onRow) {
+  let headers = null;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line === "") {
+      continue;
+    }
+    const values = parseCsvLine(line);
+    if (!headers) {
+      headers = values;
+      continue;
+    }
+    onRow(createCursorCsvRow(headers, values));
+  }
+}
+function processCursorUsageCsvText(content, onRow) {
+  processCursorCsvLines(content.split(/\r?\n/), onRow);
+}
+async function processCursorUsageCsvStream(response, onRow) {
+  if (!response.body) {
+    processCursorUsageCsvText(await response.text(), onRow);
+    return;
+  }
+  let headers = null;
+  let currentField = "";
+  let currentRow = [];
+  let inQuotes = false;
+  let pendingQuote = false;
+  let sawCarriageReturn = false;
+  const decoder = new TextDecoder();
+  const emitField = () => {
+    currentRow.push(currentField);
+    currentField = "";
+  };
+  const emitRow = () => {
+    emitField();
+    if (currentRow.every((value) => value.trim() === "")) {
+      currentRow = [];
+      return;
+    }
+    if (!headers) {
+      headers = currentRow;
+      currentRow = [];
+      return;
+    }
+    onRow(createCursorCsvRow(headers, currentRow));
+    currentRow = [];
+  };
+  const processChunk = (chunk) => {
+    for (const char of chunk) {
+      let shouldReprocess = true;
+      while (shouldReprocess) {
+        shouldReprocess = false;
+        if (sawCarriageReturn) {
+          sawCarriageReturn = false;
+          if (char === "\n") {
+            break;
+          }
+        }
+        if (pendingQuote) {
+          pendingQuote = false;
+          if (char === '"') {
+            currentField += '"';
+            break;
+          }
+          inQuotes = false;
+          shouldReprocess = true;
+          continue;
+        }
+        if (inQuotes) {
+          if (char === '"') {
+            pendingQuote = true;
+          } else {
+            currentField += char;
+          }
+          break;
+        }
+        if (char === '"') {
+          inQuotes = true;
+          break;
+        }
+        if (char === ",") {
+          emitField();
+          break;
+        }
+        if (char === "\n") {
+          emitRow();
+          break;
+        }
+        if (char === "\r") {
+          emitRow();
+          sawCarriageReturn = true;
+          break;
+        }
+        currentField += char;
+        break;
+      }
+    }
+  };
+  const reader = response.body.getReader();
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      processChunk(decoder.decode(value, { stream: true }));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  processChunk(decoder.decode());
+  if (pendingQuote) {
+    pendingQuote = false;
+    inQuotes = false;
+  }
+  if (currentField !== "" || currentRow.length > 0) {
+    emitRow();
+  }
+}
+function addCursorUsageRow(row, start, end, recentStart, totals, modelTotals, recentModelTotals) {
+  const date = parseCursorDate(row.Date);
+  const rawModel = row.Model?.trim();
+  const tokenTotals = createCursorTokenTotals(row);
+  if (!date || !rawModel || !tokenTotals) {
+    return;
+  }
+  if (date < start || date > end) {
+    return;
+  }
+  const modelName = normalizeModelName(rawModel);
+  addDailyTokenTotals(totals, date, tokenTotals, modelName);
+  addModelTokenTotals(modelTotals, modelName, tokenTotals);
+  if (date >= recentStart) {
+    addModelTokenTotals(recentModelTotals, modelName, tokenTotals);
+  }
+}
+function parseCursorDate(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+    return /* @__PURE__ */ new Date(`${trimmed}T00:00:00`);
+  }
+  const parsed = new Date(trimmed);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function parseCursorNumber(value) {
+  const numeric = Number(value?.replaceAll(",", "").trim() ?? "");
+  if (!Number.isFinite(numeric) || numeric <= 0) {
+    return null;
+  }
+  return Math.round(numeric);
+}
+function createCursorTokenTotals(row) {
+  const total = parseCursorNumber(row["Total Tokens"]) ?? parseCursorNumber(row.Tokens);
+  if (!total) {
+    return null;
+  }
+  const inputWithCacheWrite = parseCursorNumber(row["Input (w/ Cache Write)"]) ?? 0;
+  const inputWithoutCacheWrite = parseCursorNumber(row["Input (w/o Cache Write)"]) ?? 0;
+  const cacheInput = parseCursorNumber(row["Cache Read"]) ?? 0;
+  const outputTokens = parseCursorNumber(row["Output Tokens"]) ?? 0;
+  return {
+    input: inputWithCacheWrite + inputWithoutCacheWrite + cacheInput,
+    output: outputTokens,
+    cache: { input: cacheInput, output: inputWithCacheWrite },
+    total
+  };
+}
+async function loadCursorRows(start, end) {
+  const databasePath = getCursorStateDbPath();
+  const totals = /* @__PURE__ */ new Map();
+  const modelTotals = /* @__PURE__ */ new Map();
+  const recentModelTotals = /* @__PURE__ */ new Map();
+  if (!databasePath) {
+    return createUsageSummary("cursor", totals, modelTotals, recentModelTotals, end);
+  }
+  const authState = await readCursorAuthState(databasePath);
+  if (!authState.accessToken) {
+    return createUsageSummary("cursor", totals, modelTotals, recentModelTotals, end);
+  }
+  const recentStart = getRecentWindowStart(end, 30);
+  const response = await fetchCursorUsageCsv(authState.accessToken);
+  return summarizeCursorUsageCsv(response, start, end, recentStart);
+}
+async function summarizeCursorUsageCsv(response, start, end, recentStart = getRecentWindowStart(end, 30)) {
+  const totals = /* @__PURE__ */ new Map();
+  const modelTotals = /* @__PURE__ */ new Map();
+  const recentModelTotals = /* @__PURE__ */ new Map();
+  await processCursorUsageCsvStream(response, (row) => {
+    addCursorUsageRow(
+      row,
+      start,
+      end,
+      recentStart,
+      totals,
+      modelTotals,
+      recentModelTotals
+    );
+  });
+  return createUsageSummary("cursor", totals, modelTotals, recentModelTotals, end);
+}
+
 // src/lib/interfaces.ts
-var providerIds = ["claude", "codex", "opencode"];
+var providerIds = ["claude", "codex", "cursor", "opencode"];
 var providerStatusLabel = {
   claude: "Claude code",
   codex: "Codex",
+  cursor: "Cursor",
   opencode: "Open Code"
 };
 
 // src/lib/open-code.ts
-import { existsSync as existsSync2 } from "fs";
-import { copyFile, mkdtemp, rm } from "fs/promises";
-import { homedir as homedir3, tmpdir } from "os";
-import { join as join4, resolve as resolve3 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { copyFile as copyFile2, mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
+import { homedir as homedir4, tmpdir as tmpdir2 } from "os";
+import { join as join5, resolve as resolve4 } from "path";
 function sumOpenCodeTokens(tokens) {
   const cacheInput = tokens?.cache?.read ?? 0;
   const cacheOutput = tokens?.cache?.write ?? 0;
@@ -7036,16 +7514,16 @@ async function parseOpenCodeFile(filePath) {
   return readJsonDocument(filePath);
 }
 function getOpenCodeBaseDir() {
-  const baseDir = process.env.OPENCODE_DATA_DIR?.trim() ? resolve3(process.env.OPENCODE_DATA_DIR) : join4(homedir3(), ".local", "share", "opencode");
+  const baseDir = process.env.OPENCODE_DATA_DIR?.trim() ? resolve4(process.env.OPENCODE_DATA_DIR) : join5(homedir4(), ".local", "share", "opencode");
   return baseDir;
 }
 async function getOpenCodeSource() {
   const baseDir = getOpenCodeBaseDir();
-  const databasePath = join4(baseDir, "opencode.db");
-  if (existsSync2(databasePath)) {
+  const databasePath = join5(baseDir, "opencode.db");
+  if (existsSync3(databasePath)) {
     return { kind: "database", path: databasePath };
   }
-  const messagesDir = join4(baseDir, "storage", "message");
+  const messagesDir = join5(baseDir, "storage", "message");
   return { kind: "legacy", files: await listFilesRecursive(messagesDir, ".json") };
 }
 async function loadSqliteModule() {
@@ -7084,24 +7562,24 @@ function parseOpenCodeMessageData(rowId, sourceLabel, content) {
     id: message.id || rowId
   };
 }
-function isSqliteLockedError(error) {
+function isSqliteLockedError2(error) {
   return error instanceof Error && /database is locked/i.test(error.message);
 }
 async function withDatabaseSnapshot(databasePath, callback) {
-  const snapshotDir = await mkdtemp(join4(tmpdir(), "slopmeter-opencode-"));
-  const snapshotPath = join4(snapshotDir, "opencode.db");
-  await copyFile(databasePath, snapshotPath);
+  const snapshotDir = await mkdtemp2(join5(tmpdir2(), "slopmeter-opencode-"));
+  const snapshotPath = join5(snapshotDir, "opencode.db");
+  await copyFile2(databasePath, snapshotPath);
   for (const suffix of ["-shm", "-wal"]) {
     const companionPath = `${databasePath}${suffix}`;
-    if (!existsSync2(companionPath)) {
+    if (!existsSync3(companionPath)) {
       continue;
     }
-    await copyFile(companionPath, `${snapshotPath}${suffix}`);
+    await copyFile2(companionPath, `${snapshotPath}${suffix}`);
   }
   try {
     return await callback(snapshotPath);
   } finally {
-    await rm(snapshotDir, { recursive: true, force: true });
+    await rm2(snapshotDir, { recursive: true, force: true });
   }
 }
 async function iterateOpenCodeDatabaseMessages(databasePath, onMessage) {
@@ -7130,7 +7608,7 @@ async function loadOpenCodeDatabaseMessages(databasePath, onMessage) {
   try {
     await iterateOpenCodeDatabaseMessages(databasePath, onMessage);
   } catch (error) {
-    if (!isSqliteLockedError(error)) {
+    if (!isSqliteLockedError2(error)) {
       throw error;
     }
     await withDatabaseSnapshot(databasePath, async (snapshotPath) => {
@@ -7219,11 +7697,12 @@ async function aggregateUsage({
   const rowsByProvider = {
     claude: null,
     codex: null,
+    cursor: null,
     opencode: null
   };
   const warnings = [];
   for (const provider of providersToLoad) {
-    const summary = provider === "claude" ? await loadClaudeRows(start, end) : provider === "codex" ? await loadCodexRows(start, end, warnings) : await loadOpenCodeRows(start, end);
+    const summary = provider === "claude" ? await loadClaudeRows(start, end) : provider === "codex" ? await loadCodexRows(start, end, warnings) : provider === "cursor" ? await loadCursorRows(start, end) : await loadOpenCodeRows(start, end);
     rowsByProvider[provider] = hasUsage(summary) ? summary : null;
   }
   return { rowsByProvider, warnings };
@@ -7239,12 +7718,13 @@ var HELP_TEXT = `slopmeter
 Generate rolling 1-year usage heatmap image(s) (today is the latest day).
 
 Usage:
-  slopmeter [--all] [--claude] [--codex] [--opencode] [--dark] [--format png|svg|json] [--output ./heatmap-last-year.png]
+  slopmeter [--all] [--claude] [--codex] [--cursor] [--opencode] [--dark] [--format png|svg|json] [--output ./heatmap-last-year.png]
 
 Options:
   --all                       Render one merged graph for all providers
   --claude                    Render Claude Code graph
   --codex                     Render Codex graph
+  --cursor                    Render Cursor graph
   --opencode                  Render Open Code graph
   --dark                      Render with the dark theme
   -f, --format                Output format: png, svg, or json (default: png)
@@ -7265,6 +7745,7 @@ function validateArgs(values) {
       all: ow.boolean,
       claude: ow.boolean,
       codex: ow.boolean,
+      cursor: ow.boolean,
       opencode: ow.boolean
     })
   );
@@ -7337,7 +7818,7 @@ function getOutputProviders(values, rowsByProvider, end) {
   const merged = mergeProviderUsage(rowsByProvider, end);
   if (!merged) {
     throw new Error(
-      "No usage data found for Claude code, Codex, or Open code."
+      "No usage data found for Claude code, Codex, Cursor, or Open code."
     );
   }
   return [merged];
@@ -7355,7 +7836,7 @@ function selectProvidersToRender(rowsByProvider, requested) {
   }
   if (providersToRender.length === 0) {
     throw new Error(
-      "No usage data found for Claude code, Codex, or Open code."
+      "No usage data found for Claude code, Codex, Cursor, or Open code."
     );
   }
   return providersToRender.map((provider) => rowsByProvider[provider]);
@@ -7388,6 +7869,7 @@ async function main() {
       all: { type: "boolean", default: false },
       claude: { type: "boolean", default: false },
       codex: { type: "boolean", default: false },
+      cursor: { type: "boolean", default: false },
       opencode: { type: "boolean", default: false }
     },
     allowPositionals: false
@@ -7424,7 +7906,7 @@ async function main() {
       rowsByProvider,
       end
     );
-    const outputPath = resolve4(
+    const outputPath = resolve5(
       values.output ?? `./heatmap-last-year.${format}`
     );
     mkdirSync(dirname(outputPath), { recursive: true });