@vibe-cafe/vibe-usage 0.7.8 → 0.7.11

package/README.md

@@ -49,6 +49,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only) |
 | Codex CLI | `~/.codex/sessions/` |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
+| Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`) |
 | Gemini CLI | `~/.gemini/tmp/` |
 | OpenCode | `~/.local/share/opencode/opencode.db` (SQLite, `json_extract` query) |
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments) |
@@ -64,7 +65,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 - Parses local session logs from each AI coding tool
 - Aggregates token usage into 30-minute buckets
 - Extracts session metadata from all parsers: active time (AI generation time, excluding queue/TTFT wait), total duration, message counts
-- Uploads buckets + sessions to your vibecafe.ai dashboard
+- Uploads buckets + sessions to your vibecafe.ai dashboard (gzip-compressed when ≥ 1 KB, ~94% smaller)
 - Stateless: computes full totals from local logs each sync (idempotent, no state files)
 - For continuous syncing, use `npx @vibe-cafe/vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.7.8",
+  "version": "0.7.11",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "bin": {

package/src/api.js

@@ -1,9 +1,11 @@
 import https from 'node:https';
 import http from 'node:http';
 import { URL } from 'node:url';
+import { gzipSync } from 'node:zlib';
 
 const MAX_RETRIES = 3;
 const INITIAL_DELAY = 1000;
+const GZIP_MIN_BYTES = 1024;
 
 export async function ingest(apiUrl, apiKey, buckets, opts, sessions) {
   let lastError;
@@ -30,18 +32,23 @@ function _send(apiUrl, apiKey, buckets, onProgress, sessions) {
     const url = new URL('/api/usage/ingest', apiUrl);
     const payload = { buckets };
     if (sessions && sessions.length > 0) payload.sessions = sessions;
-    const body = Buffer.from(JSON.stringify(payload));
+    const raw = Buffer.from(JSON.stringify(payload));
+    const useGzip = raw.length >= GZIP_MIN_BYTES;
+    const body = useGzip ? gzipSync(raw) : raw;
     const totalBytes = body.length;
     const mod = url.protocol === 'https:' ? https : http;
 
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Length': totalBytes,
+    };
+    if (useGzip) headers['Content-Encoding'] = 'gzip';
+
     const req = mod.request(url, {
       method: 'POST',
       timeout: 60_000,
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-        'Content-Length': totalBytes,
-      },
+      headers,
     }, (res) => {
       let data = '';
       res.on('data', (chunk) => { data += chunk; });

package/src/parsers/cursor.js

@@ -0,0 +1,242 @@
+import { execFileSync } from 'node:child_process';
+import { copyFileSync, existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
+import { aggregateToBuckets } from './index.js';
+
+const STATE_DB_RELATIVE = join('User', 'globalStorage', 'state.vscdb');
+const ACCESS_TOKEN_KEY = 'cursorAuth/accessToken';
+const SESSION_COOKIE = 'WorkosCursorSessionToken';
+
+function getDefaultStateDbPath() {
+  if (process.platform === 'darwin') {
+    return join(homedir(), 'Library', 'Application Support', 'Cursor', STATE_DB_RELATIVE);
+  }
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    return join(appData, 'Cursor', STATE_DB_RELATIVE);
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+  return join(xdgConfigHome, 'Cursor', STATE_DB_RELATIVE);
+}
+
+export function getCursorStateDbPath() {
+  const explicit = process.env.CURSOR_STATE_DB_PATH?.trim();
+  if (explicit) {
+    const resolved = resolve(explicit);
+    return existsSync(resolved) ? resolved : null;
+  }
+
+  const configDirs = process.env.CURSOR_CONFIG_DIR?.trim();
+  const candidates = configDirs
+    ? configDirs.split(',').map(v => v.trim()).filter(Boolean).map(v => {
+        const r = resolve(v);
+        return r.endsWith('.vscdb') ? r : join(r, STATE_DB_RELATIVE);
+      })
+    : [getDefaultStateDbPath()];
+
+  for (const c of candidates) {
+    if (existsSync(c)) return c;
+  }
+  return null;
+}
+
+function readAccessToken(dbPath) {
+  let snapshotDir = null;
+  let queryPath = dbPath;
+  try {
+    return queryAccessToken(queryPath);
+  } catch (err) {
+    // Cursor app holds a write lock; copy WAL set to a temp dir and retry
+    if (!isLockError(err)) throw err;
+    snapshotDir = mkdtempSync(join(tmpdir(), 'vibe-usage-cursor-'));
+    queryPath = join(snapshotDir, 'state.vscdb');
+    copyFileSync(dbPath, queryPath);
+    for (const suffix of ['-shm', '-wal']) {
+      const companion = `${dbPath}${suffix}`;
+      if (existsSync(companion)) copyFileSync(companion, `${queryPath}${suffix}`);
+    }
+    try {
+      return queryAccessToken(queryPath);
+    } finally {
+      rmSync(snapshotDir, { recursive: true, force: true });
+    }
+  }
+}
+
+function queryAccessToken(dbPath) {
+  const sql = `SELECT value FROM ItemTable WHERE key = '${ACCESS_TOKEN_KEY}' LIMIT 1`;
+  const out = execFileSync('sqlite3', ['-json', dbPath, sql], {
+    encoding: 'utf-8',
+    maxBuffer: 4 * 1024 * 1024,
+    timeout: 15000,
+  });
+  const trimmed = out.trim();
+  if (!trimmed || trimmed === '[]') return null;
+  const rows = JSON.parse(trimmed);
+  const value = rows[0]?.value;
+  if (typeof value !== 'string') return null;
+  const t = value.trim();
+  return t || null;
+}
+
+function isLockError(err) {
+  return err && typeof err.message === 'string' && /database is locked/i.test(err.message);
+}
+
+function decodeJwtSub(token) {
+  const payload = token.split('.')[1];
+  if (!payload) return null;
+  try {
+    const b64 = payload.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = b64.padEnd(Math.ceil(b64.length / 4) * 4, '=');
+    const json = JSON.parse(Buffer.from(padded, 'base64').toString('utf-8'));
+    return typeof json.sub === 'string' ? json.sub.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+const FETCH_TIMEOUT_MS = 10_000;
+
+async function fetchUsageCsv(token) {
+  const url = `${(process.env.CURSOR_WEB_BASE_URL?.trim() || 'https://cursor.com').replace(/\/+$/, '')}/api/dashboard/export-usage-events-csv?strategy=tokens`;
+  const sub = decodeJwtSub(token);
+  const cookieValues = sub ? [token, `${sub}::${token}`] : [token];
+
+  const attempts = [{ Authorization: `Bearer ${token}` }];
+  for (const cv of cookieValues) {
+    attempts.push({ Cookie: `${SESSION_COOKIE}=${cv}` });
+    attempts.push({ Authorization: `Bearer ${token}`, Cookie: `${SESSION_COOKIE}=${cv}` });
+  }
+
+  const failures = [];
+  for (const headers of attempts) {
+    let resp;
+    try {
+      resp = await fetch(url, {
+        headers: { Accept: 'text/csv,*/*;q=0.8', ...headers },
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+      });
+    } catch (e) {
+      // Hard-fail on network/timeout: stop trying further headers (won't fix
+      // a downed host) and signal a soft skip to the caller.
+      const reason = e.name === 'TimeoutError' ? 'timeout' : `network: ${e.message}`;
+      const err = new Error(`Cursor usage export skipped (${reason})`);
+      err.skip = true;
+      throw err;
+    }
+    if (resp.ok) return await resp.text();
+    failures.push(`${resp.status} ${resp.statusText}`);
+  }
+  // All auth combos rejected — token is likely expired. Surface to user.
+  throw new Error(`Cursor usage export auth failed (${failures.join('; ')})`);
+}
+
+function parseCsv(text) {
+  const rows = [];
+  let field = '';
+  let row = [];
+  let inQuotes = false;
+  let i = 0;
+  while (i < text.length) {
+    const c = text[i];
+    if (inQuotes) {
+      if (c === '"') {
+        if (text[i + 1] === '"') { field += '"'; i += 2; continue; }
+        inQuotes = false; i++; continue;
+      }
+      field += c; i++; continue;
+    }
+    if (c === '"') { inQuotes = true; i++; continue; }
+    if (c === ',') { row.push(field); field = ''; i++; continue; }
+    if (c === '\r') { i++; continue; }
+    if (c === '\n') { row.push(field); rows.push(row); field = ''; row = []; i++; continue; }
+    field += c; i++;
+  }
+  if (field !== '' || row.length > 0) { row.push(field); rows.push(row); }
+  return rows;
+}
+
+function parseDate(value) {
+  if (!value) return null;
+  const t = String(value).trim();
+  if (!t) return null;
+  if (/^\d{4}-\d{2}-\d{2}$/.test(t)) return new Date(`${t}T00:00:00Z`);
+  const d = new Date(t);
+  return isNaN(d.getTime()) ? null : d;
+}
+
+function parseInt0(value) {
+  if (value == null) return 0;
+  const n = Number(String(value).replace(/,/g, '').trim());
+  return Number.isFinite(n) && n > 0 ? Math.round(n) : 0;
+}
+
+export async function parse() {
+  const dbPath = getCursorStateDbPath();
+  if (!dbPath) return { buckets: [], sessions: [] };
+
+  let token;
+  try {
+    token = readAccessToken(dbPath);
+  } catch (err) {
+    if (err && typeof err.message === 'string' && err.message.includes('ENOENT')) {
+      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Cursor data.');
+    }
+    throw err;
+  }
+  if (!token) return { buckets: [], sessions: [] };
+
+  let csv;
+  try {
+    csv = await fetchUsageCsv(token);
+  } catch (err) {
+    // Network/timeout → silent skip (avoid noisy daemon logs every 5 min).
+    // Auth failure → bubble up so user sees they need to re-login in Cursor.
+    if (err && err.skip) return { buckets: [], sessions: [] };
+    throw err;
+  }
+  const rows = parseCsv(csv);
+  if (rows.length < 2) return { buckets: [], sessions: [] };
+
+  const header = rows[0].map(h => h.trim());
+  const idx = (name) => header.indexOf(name);
+  const dateIdx = idx('Date');
+  const modelIdx = idx('Model');
+  const inputCacheWriteIdx = idx('Input (w/ Cache Write)');
+  const inputNoCacheIdx = idx('Input (w/o Cache Write)');
+  const cacheReadIdx = idx('Cache Read');
+  const outputIdx = idx('Output Tokens');
+
+  if (dateIdx < 0 || modelIdx < 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  for (let r = 1; r < rows.length; r++) {
+    const row = rows[r];
+    if (row.length === 1 && row[0].trim() === '') continue;
+    const timestamp = parseDate(row[dateIdx]);
+    const model = row[modelIdx]?.trim();
+    if (!timestamp || !model) continue;
+
+    const inputCacheWrite = inputCacheWriteIdx >= 0 ? parseInt0(row[inputCacheWriteIdx]) : 0;
+    const inputNoCache = inputNoCacheIdx >= 0 ? parseInt0(row[inputNoCacheIdx]) : 0;
+    const cacheRead = cacheReadIdx >= 0 ? parseInt0(row[cacheReadIdx]) : 0;
+    const output = outputIdx >= 0 ? parseInt0(row[outputIdx]) : 0;
+
+    if (inputCacheWrite + inputNoCache + cacheRead + output === 0) continue;
+
+    entries.push({
+      source: 'cursor',
+      model,
+      project: 'unknown',
+      timestamp,
+      inputTokens: inputCacheWrite + inputNoCache,
+      outputTokens: output,
+      cachedInputTokens: cacheRead,
+      reasoningOutputTokens: 0,
+    });
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: [] };
+}

package/src/parsers/index.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { parse as parseClaudeCode } from './claude-code.js';
 import { parse as parseCodex } from './codex.js';
 import { parse as parseCopilotCli } from './copilot-cli.js';
+import { parse as parseCursor } from './cursor.js';
 import { parse as parseGeminiCli } from './gemini-cli.js';
 import { parse as parseOpencode } from './opencode.js';
 import { parse as parseOpenclaw } from './openclaw.js';
@@ -17,6 +18,7 @@ export const parsers = {
   'claude-code': parseClaudeCode,
   'codex': parseCodex,
   'copilot-cli': parseCopilotCli,
+  'cursor': parseCursor,
   'gemini-cli': parseGeminiCli,
   'opencode': parseOpencode,
   'openclaw': parseOpenclaw,

package/src/tools.js

@@ -2,6 +2,19 @@ import { existsSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
+function getCursorStateDbPath() {
+  const rel = join('User', 'globalStorage', 'state.vscdb');
+  if (process.platform === 'darwin') {
+    return join(homedir(), 'Library', 'Application Support', 'Cursor', rel);
+  }
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA?.trim() || join(homedir(), 'AppData', 'Roaming');
+    return join(appData, 'Cursor', rel);
+  }
+  const xdgConfigHome = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), '.config');
+  return join(xdgConfigHome, 'Cursor', rel);
+}
+
 /** Find all OpenClaw data roots: ~/.openclaw and ~/.openclaw-<profile> */
 function findOpenclawDataDirs() {
   const home = homedir();
@@ -41,6 +54,11 @@ export const TOOLS = [
     id: 'copilot-cli',
     dataDir: join(homedir(), '.copilot', 'session-state'),
   },
+  {
+    name: 'Cursor',
+    id: 'cursor',
+    dataDir: getCursorStateDbPath(),
+  },
   {
     name: 'Gemini CLI',
     id: 'gemini-cli',