@vibe-cafe/vibe-usage 0.9.7 → 0.9.9

package/README.md

@@ -63,7 +63,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Amp | `~/.local/share/amp/threads/` |
 | Droid | `~/.factory/sessions/` |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
-| Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` credit deltas as `kiro-credits`; legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
+| Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
 | Cline | `<host>/User/globalStorage/saoudrizwan.claude-dev/{state/taskHistory.json,tasks/<id>/ui_messages.json}` (walks all VSCode-fork hosts: Code, Cursor, Windsurf, VSCodium, Trae, ...) |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |
 | Antigravity | `~/.gemini/antigravity/conversations/*.pb` to discover cascades, then reads token usage + sessions from the running language server via Connect RPC (process discovered with `ps`/`lsof` on macOS/Linux, PowerShell CIM with a `wmic` fallback on Windows) |

package/package.json

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

package/src/parsers/cursor.js

@@ -95,20 +95,34 @@ 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];
+  // 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,
+  ];
 
-  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}` });
-  }
+  // 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 fetch(url, {
-        headers: { Accept: 'text/csv,*/*;q=0.8', ...headers },
+        headers: { ...baseHeaders, ...headers },
         signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
       });
     } catch (e) {
@@ -121,9 +135,18 @@ async function fetchUsageCsv(token) {
     }
     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;
+    }
   }
-  // All auth combos rejected — token is likely expired. Surface to user.
-  throw new Error(`Cursor usage export auth failed (${failures.join('; ')})`);
+  // 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) {

package/src/parsers/index.js

@@ -46,24 +46,43 @@ export function roundToHalfHour(date) {
   return d;
 }
 
+// Server column limits (usage_buckets: model varchar(100), project varchar(200)).
+// Anything longer aborts the whole INSERT chunk with 22001, so clamp here.
+const MODEL_MAX_LENGTH = 100;
+const PROJECT_MAX_LENGTH = 200;
+
+// Server token columns are bigint — a single fractional/NaN value aborts the
+// whole INSERT chunk with 22P02, taking every other tool's rows in the batch
+// down with it.
+function toTokenCount(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  return Math.round(n);
+}
+
 export function aggregateToBuckets(entries) {
   const map = new Map();
 
   for (const e of entries) {
+    const model = String(e.model || 'unknown').slice(0, MODEL_MAX_LENGTH);
+    const project = String(e.project || 'unknown').slice(0, PROJECT_MAX_LENGTH);
     const bucketStart = roundToHalfHour(e.timestamp).toISOString();
-    const key = `${e.source}|${e.model}|${e.project}|${bucketStart}`;
+    const key = `${e.source}|${model}|${project}|${e.hostname || ''}|${bucketStart}`;
 
     if (!map.has(key)) {
       map.set(key, {
         source: e.source,
-        model: e.model,
-        project: e.project,
+        model,
+        project,
+        // Cloud-sourced parsers (cursor) pre-set a fixed hostname sentinel; it
+        // must survive aggregation, or sync.js stamps the machine hostname and
+        // every machine gets its own duplicate row server-side.
+        ...(e.hostname ? { hostname: e.hostname } : {}),
         bucketStart,
         inputTokens: 0,
         outputTokens: 0,
         cachedInputTokens: 0,
         reasoningOutputTokens: 0,
-        totalTokens: 0,
       });
     }
 
@@ -72,10 +91,24 @@ export function aggregateToBuckets(entries) {
     b.outputTokens += e.outputTokens || 0;
     b.cachedInputTokens += e.cachedInputTokens || 0;
     b.reasoningOutputTokens += e.reasoningOutputTokens || 0;
-    b.totalTokens += (e.inputTokens || 0) + (e.outputTokens || 0) + (e.reasoningOutputTokens || 0);
   }
 
-  return Array.from(map.values());
+  // Clamp after summation, not per entry — rounding each entry first would
+  // discard sub-integer values instead of letting them accumulate.
+  return Array.from(map.values()).map((b) => {
+    const inputTokens = toTokenCount(b.inputTokens);
+    const outputTokens = toTokenCount(b.outputTokens);
+    const cachedInputTokens = toTokenCount(b.cachedInputTokens);
+    const reasoningOutputTokens = toTokenCount(b.reasoningOutputTokens);
+    return {
+      ...b,
+      inputTokens,
+      outputTokens,
+      cachedInputTokens,
+      reasoningOutputTokens,
+      totalTokens: inputTokens + outputTokens + reasoningOutputTokens,
+    };
+  });
 }
 
 /**

package/src/parsers/kiro.js

@@ -736,7 +736,12 @@ export function snapshotsToCreditEntries(snapshots) {
       continue;
     }
 
-    const delta = Number((snapshot.currentUsage - prev.currentUsage).toFixed(4));
+    // The server's token columns are bigint, so fractional credit deltas
+    // cannot be uploaded as-is. Diff floored cumulative values instead of
+    // rounding each delta: the diffs telescope, so sub-integer usage is never
+    // lost or double-counted — it surfaces on whichever snapshot crosses the
+    // next whole-credit boundary.
+    const delta = Math.floor(snapshot.currentUsage) - Math.floor(prev.currentUsage);
     if (delta > 0) {
       entries.push({
         source: 'kiro',