@geoqiao/pi-usage 0.1.0

package/vendor/vibe-usage/src/parsers/contract.js

@@ -0,0 +1,55 @@
+/**
+ * Parser result contract.
+ *
+ * Every parser exports an async parse() returning either
+ *   { buckets: object[], sessions: object[], skipped?: boolean, warnings?: string[], indexing?: object }
+ * or a legacy bare buckets array.
+ *
+ * buckets entries are the aggregateToBuckets() output shape
+ * ({ source, model, project, hostname?, bucketStart, inputTokens, ... }).
+ * sessions entries are the extractSessions() output shape
+ * ({ source, project, sessionHash, firstMessageAt, ... }).
+ */
+
+/**
+ * Normalize a raw parser return value into a validated shape. Every emitted
+ * item's source must match the registry key the parser is registered under;
+ * rejecting a typo keeps that parser out of state pruning and prevents a
+ * server-side dropped source from silently discarding its prior upload state.
+ *
+ * @param {string} source registry key
+ * @param {unknown} result raw return value
+ * @returns {{ buckets: object[], sessions: object[], skipped: boolean, warnings: string[], indexing?: object }}
+ */
+export function normalizeParserResult(source, result) {
+  const buckets = Array.isArray(result) ? result : result?.buckets;
+  const sessions = Array.isArray(result) ? [] : (result?.sessions || []);
+  if (!Array.isArray(buckets) || !Array.isArray(sessions)) {
+    throw new TypeError('Parser returned an invalid result');
+  }
+
+  for (const bucket of buckets) {
+    if (bucket?.source !== source) {
+      throw new TypeError(
+        'parser ' + source + ' emitted a bucket with source=' + JSON.stringify(bucket?.source),
+      );
+    }
+  }
+  for (const session of sessions) {
+    if (session?.source !== source) {
+      throw new TypeError(
+        'parser ' + source + ' emitted a session with source=' + JSON.stringify(session?.source),
+      );
+    }
+  }
+
+  const warnings = Array.isArray(result?.warnings) ? result.warnings.slice() : [];
+
+  return {
+    buckets,
+    sessions,
+    skipped: result?.skipped === true,
+    warnings,
+    ...(result?.indexing ? { indexing: result.indexing } : {}),
+  };
+}

package/vendor/vibe-usage/src/parsers/copilot-cli.js

@@ -0,0 +1,128 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+
+const SESSION_STATE_DIR = join(homedir(), '.copilot', 'session-state');
+
+function findEventFiles(baseDir) {
+  const results = [];
+  if (!existsSync(baseDir)) return results;
+
+  try {
+    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+
+      const eventsFile = join(baseDir, entry.name, 'events.jsonl');
+      if (existsSync(eventsFile)) {
+        results.push({ filePath: eventsFile, sessionId: entry.name });
+      }
+    }
+  } catch {
+    return results;
+  }
+
+  return results;
+}
+
+function getProjectFromContext(context) {
+  const projectPath = context?.gitRoot || context?.cwd;
+  if (!projectPath) return 'unknown';
+
+  return basename(projectPath) || 'unknown';
+}
+
+/**
+ * Parse GitHub Copilot CLI session logs from ~/.copilot/session-state.
+ * Returns usage buckets from session shutdown summaries and session metadata
+ * from user/assistant message timings.
+ */
+export async function parse() {
+  const eventFiles = findEventFiles(SESSION_STATE_DIR);
+  if (eventFiles.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const { filePath, sessionId } of eventFiles) {
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    let currentProject = 'unknown';
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+
+      try {
+        const obj = JSON.parse(line);
+        const timestamp = obj.timestamp ? new Date(obj.timestamp) : null;
+        const hasTimestamp = timestamp && !isNaN(timestamp.getTime());
+
+        if (obj.type === 'session.start' || obj.type === 'session.resume') {
+          currentProject = getProjectFromContext(obj.data?.context);
+        }
+
+        if (hasTimestamp && obj.type === 'user.message') {
+          sessionEvents.push({
+            sessionId,
+            source: 'copilot-cli',
+            project: currentProject,
+            timestamp,
+            role: 'user',
+          });
+        }
+
+        if (hasTimestamp && obj.type === 'assistant.message') {
+          sessionEvents.push({
+            sessionId,
+            source: 'copilot-cli',
+            project: currentProject,
+            timestamp,
+            role: 'assistant',
+          });
+        }
+
+        if (obj.type !== 'session.shutdown' || !hasTimestamp) continue;
+
+        const modelMetrics = obj.data?.modelMetrics || {};
+        for (const [model, metrics] of Object.entries(modelMetrics)) {
+          const usage = metrics?.usage;
+          if (!usage) continue;
+
+          const totalInput = usage.inputTokens || 0;
+          const cachedRead = usage.cacheReadTokens || 0;
+          const cacheWrite = usage.cacheWriteTokens || 0;
+          const output = usage.outputTokens || 0;
+
+          if (totalInput === 0 && cachedRead === 0 && cacheWrite === 0 && output === 0) {
+            continue;
+          }
+
+          entries.push({
+            source: 'copilot-cli',
+            model,
+            project: currentProject,
+            timestamp,
+            // Copilot reports cache reads separately, but cache writes are part of
+            // regular input for this schema because buckets don't have a dedicated field.
+            inputTokens: Math.max(0, totalInput - cachedRead),
+            outputTokens: output,
+            cachedInputTokens: cachedRead,
+            reasoningOutputTokens: 0,
+          });
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(sessionEvents),
+  };
+}

package/vendor/vibe-usage/src/parsers/craft-agent.js

@@ -0,0 +1,21 @@
+import { getCraftWorkspacesDir } from '../craft-roots.js';
+import { parsePiSessionJsonl } from './pi-session-jsonl.js';
+
+function isCraftPiSession(filePath) {
+  return filePath.split(/[\\/]/).includes('.pi-sessions');
+}
+
+function projectFromCraftPath(filePath) {
+  const parts = filePath.replace(/\\/g, '/').split('/');
+  const sessionsIndex = parts.lastIndexOf('sessions');
+  return parts[sessionsIndex + 1] || 'unknown';
+}
+
+export async function parse() {
+  return parsePiSessionJsonl({
+    source: 'craft-agent',
+    sessionsDirs: [getCraftWorkspacesDir()],
+    includeFile: isCraftPiSession,
+    projectFromPath: projectFromCraftPath,
+  });
+}

package/vendor/vibe-usage/src/parsers/cursor.js

@@ -0,0 +1,262 @@
+import { sourceFetch } from '../../../../src/network.js';
+import { existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets } from './aggregate.js';
+import { queryDbJsonSnapshotOnLock, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.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) {
+  // Cursor app holds a write lock; queryDbJsonSnapshotOnLock copies the WAL set
+  // to a temp dir and retries on "database is locked".
+  const sql = `SELECT value FROM ItemTable WHERE key = '${ACCESS_TOKEN_KEY}' LIMIT 1`;
+  const rows = queryDbJsonSnapshotOnLock(dbPath, sql, {
+    tempPrefix: 'vibe-usage-cursor-',
+    opts: { maxBuffer: 4 * 1024 * 1024, timeout: 15000 },
+  });
+  const value = rows[0]?.value;
+  if (typeof value !== 'string') return null;
+  const t = value.trim();
+  return t || null;
+}
+
+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;
+  }
+}
+
+// Under full sync many parsers hammer disk concurrently; cursor.com's CSV
+// export can still succeed but take >10s. A short timeout caused silent skips.
+const DEFAULT_FETCH_TIMEOUT_MS = 30_000;
+const MAX_FETCH_TIMEOUT_MS = 2_147_483_647;
+
+export function resolveCursorFetchTimeout(value) {
+  const timeout = Number(value);
+  return Number.isInteger(timeout) && timeout > 0 && timeout <= MAX_FETCH_TIMEOUT_MS
+    ? timeout
+    : DEFAULT_FETCH_TIMEOUT_MS;
+}
+
+const FETCH_TIMEOUT_MS = resolveCursorFetchTimeout(process.env.VIBE_USAGE_CURSOR_FETCH_TIMEOUT_MS);
+
+async function fetchUsageCsv(token) {
+  const url = 'https://cursor.com/api/dashboard/export-usage-events-csv?strategy=tokens';
+  const sub = decodeJwtSub(token);
+  // The dashboard API authenticates via the WorkosCursorSessionToken cookie in
+  // `{sub}%3A%3A{jwt}` form (what the browser sends). Bearer and bare-token
+  // cookies now return 401, so they're kept only as last-resort fallbacks.
+  const userId = sub?.includes('|') ? sub.split('|').pop() : null;
+  const cookieValues = [
+    ...(sub ? [`${sub}%3A%3A${token}`] : []),
+    ...(userId ? [`${userId}%3A%3A${token}`] : []),
+    token,
+  ];
+
+  // Browser-mimicking headers, matching what the dashboard sends (and what
+  // cursor-stats / cursor-price-tracking send) — Node's default UA is a
+  // common target for intermittent WAF blocks on cursor.com.
+  const baseHeaders = {
+    Accept: 'text/csv,*/*;q=0.8',
+    Origin: 'https://cursor.com',
+    Referer: 'https://cursor.com/dashboard?tab=usage',
+    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
+  };
+  const attempts = cookieValues.map(cv => ({ Cookie: `${SESSION_COOKIE}=${cv}` }));
+  attempts.push({ Authorization: `Bearer ${token}` });
+
+  const failures = [];
+  for (const headers of attempts) {
+    let resp;
+    try {
+      resp = await sourceFetch(url, {
+        headers: { ...baseHeaders, ...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}`);
+    // Only auth rejections are worth retrying with different credentials.
+    // 429/5xx are transient server-side states — soft-skip like network errors
+    // instead of surfacing them as auth failures every daemon cycle.
+    if (resp.status !== 401 && resp.status !== 403) {
+      const err = new Error(`Cursor usage export skipped (HTTP ${resp.status} ${resp.statusText})`);
+      err.skip = true;
+      throw err;
+    }
+  }
+  // Every auth combo rejected — the stored token no longer works. Surface an
+  // actionable message: re-signing in inside Cursor rewrites the token.
+  throw new Error(`Cursor session rejected (${failures.join('; ')}). Open Cursor and sign in again (Cursor Settings → Account), then re-run sync.`);
+}
+
+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 (isSqliteUnavailableError(err)) {
+      throw sqliteUnavailableError('Cursor');
+    }
+    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.
+    // Tell sync.js this was not a successful empty snapshot so it preserves
+    // Cursor's incremental state instead of pruning it as dead history.
+    if (err && err.skip) {
+      return {
+        buckets: [],
+        sessions: [],
+        skipped: true,
+        warnings: [`cursor: ${err.message}`],
+      };
+    }
+    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',
+      // Cursor usage is pulled from the cloud API — it reflects the same account
+      // data on every machine. Use a fixed sentinel so all machines share one row
+      // per (model, bucket_start) rather than duplicating per hostname.
+      hostname: 'cursor-cloud',
+      timestamp,
+      inputTokens: inputCacheWrite + inputNoCache,
+      outputTokens: output,
+      cachedInputTokens: cacheRead,
+      reasoningOutputTokens: 0,
+    });
+  }
+
+  return { buckets: aggregateToBuckets(entries), sessions: [] };
+}

package/vendor/vibe-usage/src/parsers/dimagent.js

@@ -0,0 +1,127 @@
+import { existsSync } from 'node:fs';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { toCount } from './fs-utils.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
+import { getDimAgentDbPath } from '../tools.js';
+
+const SOURCE = 'dimagent';
+const FORKED_LEDGER_ID = /^ledger_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function projectName(cwd) {
+  if (!cwd) return 'unknown';
+  const parts = String(cwd).replace(/[/\\]+$/, '').split(/[/\\]/);
+  return parts.at(-1) || 'unknown';
+}
+
+function usageSignature(row) {
+  return [
+    row.runId || '',
+    row.providerId || '',
+    row.modelId || '',
+    row.usage || '',
+    row.cost ?? '',
+    row.createdAt || '',
+  ].join('\0');
+}
+
+function parseUsageRows(rows) {
+  const entries = [];
+  const originalSignatures = new Set(
+    rows
+      .filter(row => !FORKED_LEDGER_ID.test(row.ledgerId || ''))
+      .map(usageSignature),
+  );
+  const keptOrphanClones = new Set();
+
+  for (const row of rows) {
+    const signature = usageSignature(row);
+    if (FORKED_LEDGER_ID.test(row.ledgerId || '')) {
+      if (originalSignatures.has(signature) || keptOrphanClones.has(signature)) continue;
+      keptOrphanClones.add(signature);
+    }
+
+    let usage;
+    try {
+      usage = typeof row.usage === 'string' ? JSON.parse(row.usage) : row.usage;
+    } catch {
+      continue;
+    }
+    if (!usage || typeof usage !== 'object') continue;
+
+    const timestamp = new Date(row.createdAt);
+    if (Number.isNaN(timestamp.getTime())) continue;
+
+    const promptTokens = toCount(usage.promptTokens);
+    const cachedInputTokens = toCount(usage.cacheReadTokens);
+    const inputTokens = Math.max(0, promptTokens - cachedInputTokens);
+    const outputTokens = toCount(usage.completionTokens);
+    if (inputTokens + outputTokens + cachedInputTokens === 0) continue;
+
+    entries.push({
+      source: SOURCE,
+      model: row.modelId || 'unknown',
+      project: projectName(row.cwd),
+      timestamp,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens: 0,
+    });
+  }
+
+  return entries;
+}
+
+function queryDb(dbPath, sql) {
+  try {
+    return queryDbJson(dbPath, sql);
+  } catch (err) {
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('DimAgent');
+    throw err;
+  }
+}
+
+export async function parse() {
+  const dbPath = getDimAgentDbPath();
+  if (!existsSync(dbPath)) return { buckets: [], sessions: [] };
+
+  const usageRows = queryDb(dbPath, `SELECT
+    u.ledgerId,
+    u.runId,
+    u.providerId,
+    u.modelId,
+    u.usage,
+    u.cost,
+    u.createdAt,
+    s.cwd
+    FROM usage_ledger u
+    LEFT JOIN sessions s ON s.sessionId = u.sessionId`);
+
+  const messageRows = queryDb(dbPath, `SELECT
+    m.sessionId,
+    m.role,
+    m.createdAt,
+    s.cwd
+    FROM messages m
+    LEFT JOIN sessions s ON s.sessionId = m.sessionId
+    WHERE m.role IN ('user', 'assistant')
+      AND m.messageId NOT LIKE 'msg_fork_%'`);
+
+  const sessionEvents = [];
+  for (const row of messageRows) {
+    const timestamp = new Date(row.createdAt);
+    if (Number.isNaN(timestamp.getTime())) continue;
+    sessionEvents.push({
+      sessionId: row.sessionId,
+      source: SOURCE,
+      project: projectName(row.cwd),
+      timestamp,
+      role: row.role,
+    });
+  }
+
+  return {
+    buckets: aggregateToBuckets(parseUsageRows(usageRows)),
+    sessions: extractSessions(sessionEvents),
+  };
+}