@vibe-cafe/vibe-usage 0.7.14 → 0.7.16

package/README.md

@@ -70,6 +70,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 - 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 (gzip-compressed when ≥ 1 KB, ~94% smaller)
 - Stateless: computes full totals from local logs each sync (idempotent, no state files)
+- SQLite-backed tools (Cursor, OpenCode, Kiro, Hermes) are read via Node's built-in `node:sqlite` on Node ≥ 22.5 — no `sqlite3` binary needed (works on Windows out of the box); on older Node it falls back to the system `sqlite3` CLI
 - For continuous syncing, use `npx @vibe-cafe/vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 
 ## AI Skill

package/package.json

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

package/src/daemon.js

@@ -22,16 +22,31 @@ export async function runDaemon() {
 
   log('daemon started (sync every 30m, Ctrl+C to stop)');
 
+  // Why we don't exit on the first 401: launchd KeepAlive / systemd
+  // Restart=on-failure relaunch in ~10s, which used to turn a single bad/
+  // revoked key into ~360 ingest-401s per hour per machine. Sleeping a full
+  // INTERVAL between auth retries collapses that storm to the daemon's normal
+  // 30m cadence; only after MAX_AUTH_FAILURES consecutive 401s do we hand
+  // off to the supervisor, which by then can't relaunch fast enough to matter.
+  const MAX_AUTH_FAILURES = 5;
+  let consecutiveAuthFailures = 0;
+
   // eslint-disable-next-line no-constant-condition
   while (true) {
     try {
       await runSync({ throws: true, quiet: true });
+      consecutiveAuthFailures = 0;
     } catch (err) {
       if (err.message === 'UNAUTHORIZED') {
-        log('API key invalid, exiting.');
-        process.exit(1);
+        consecutiveAuthFailures++;
+        if (consecutiveAuthFailures >= MAX_AUTH_FAILURES) {
+          log(`API key invalid for ${MAX_AUTH_FAILURES} consecutive syncs, exiting.`);
+          process.exit(1);
+        }
+        log(`API key invalid (attempt ${consecutiveAuthFailures}/${MAX_AUTH_FAILURES}), retrying in 30m.`);
+      } else {
+        log(`sync error: ${err.message}`);
       }
-      log(`sync error: ${err.message}`);
     }
     await sleep(INTERVAL);
   }

package/src/parsers/cursor.js

@@ -1,8 +1,8 @@
-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';
+import { queryDbJson } from './sqlite.js';
 
 const STATE_DB_RELATIVE = join('User', 'globalStorage', 'state.vscdb');
 const ACCESS_TOKEN_KEY = 'cursorAuth/accessToken';
@@ -66,14 +66,7 @@ function readAccessToken(dbPath) {
 
 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 rows = queryDbJson(dbPath, sql, { maxBuffer: 4 * 1024 * 1024, timeout: 15000 });
   const value = rows[0]?.value;
   if (typeof value !== 'string') return null;
   const t = value.trim();
@@ -182,7 +175,7 @@ export async function parse() {
     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 new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Cursor data.');
     }
     throw err;
   }

package/src/parsers/hermes.js

@@ -1,8 +1,8 @@
-import { execFileSync } from 'node:child_process';
 import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
+import { queryDbJson } from './sqlite.js';
 
 const HERMES_HOME = process.env.HERMES_HOME || join(homedir(), '.hermes');
 
@@ -38,7 +38,7 @@ export async function parse() {
         WHERE input_tokens > 0 OR output_tokens > 0`);
     } catch (err) {
       if (err.message && err.message.includes('ENOENT')) {
-        throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Hermes data.');
+        throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Hermes data.');
       }
       throw err;
     }
@@ -121,14 +121,5 @@ function discoverDbPaths(home) {
 }
 
 function queryDb(dbPath, sql) {
-  const output = execFileSync('sqlite3', [
-    '-json',
-    dbPath,
-    sql,
-  ], { encoding: 'utf-8', maxBuffer: 100 * 1024 * 1024, timeout: 30000 });
-
-  const trimmed = output.trim();
-  if (!trimmed || trimmed === '[]') return [];
-
-  return JSON.parse(trimmed);
+  return queryDbJson(dbPath, sql);
 }

package/src/parsers/kiro.js

@@ -1,4 +1,3 @@
-import { execFileSync } from 'node:child_process';
 import {
   copyFileSync,
   existsSync,
@@ -11,6 +10,7 @@ import {
 import { join, resolve } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { aggregateToBuckets } from './index.js';
+import { queryDbJson } from './sqlite.js';
 
 const KIROAGENT_RELATIVE = join('User', 'globalStorage', 'kiro.kiroagent');
 
@@ -41,14 +41,7 @@ function isLockError(err) {
 }
 
 function queryDb(dbPath, sql) {
-  const out = execFileSync('sqlite3', ['-json', dbPath, sql], {
-    encoding: 'utf-8',
-    maxBuffer: 100 * 1024 * 1024,
-    timeout: 30000,
-  });
-  const trimmed = out.trim();
-  if (!trimmed || trimmed === '[]') return [];
-  return JSON.parse(trimmed);
+  return queryDbJson(dbPath, sql);
 }
 
 const TOKENS_SQL =
@@ -195,7 +188,7 @@ export async function parse() {
     }
   } catch (err) {
     if (err && typeof err.message === 'string' && err.message.includes('ENOENT')) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Kiro data.');
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync Kiro data.');
     }
     throw err;
   }

package/src/parsers/opencode.js

@@ -1,8 +1,8 @@
-import { execFileSync } from 'node:child_process';
-import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
+import { readdirSync, readFileSync, existsSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
+import { queryDbJson } from './sqlite.js';
 
 const DATA_DIR = join(homedir(), '.local', 'share', 'opencode');
 const DB_PATH = join(DATA_DIR, 'opencode.db');
@@ -33,29 +33,16 @@ function parseFromSqlite() {
     json_extract(data, '$.path.root') as rootPath
     FROM message`;
 
-  let output;
+  let rows;
   try {
-    output = execFileSync('sqlite3', [
-      '-json',
-      DB_PATH,
-      query,
-    ], { encoding: 'utf-8', maxBuffer: 100 * 1024 * 1024, timeout: 30000 });
+    rows = queryDbJson(DB_PATH, query);
   } catch (err) {
     if (err.status === 127 || (err.message && err.message.includes('ENOENT'))) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync opencode data.');
+      throw new Error('sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync opencode data.');
     }
     throw err;
   }
-
-  output = output.trim();
-  if (!output || output === '[]') return { buckets: [], sessions: [] };
-
-  let rows;
-  try {
-    rows = JSON.parse(output);
-  } catch {
-    throw new Error('Failed to parse sqlite3 JSON output');
-  }
+  if (!rows.length) return { buckets: [], sessions: [] };
 
   const entries = [];
   const sessionEvents = [];

package/src/parsers/sqlite.js

@@ -0,0 +1,74 @@
+import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Run a SQL query against a SQLite database and return rows as plain objects
+ * (column name → value), mirroring the shape of `sqlite3 -json` output.
+ *
+ * Prefers Node's built-in `node:sqlite` (available on Node >= 22.5, no external
+ * binary needed — important on Windows where the `sqlite3` CLI is rarely on
+ * PATH). Falls back to shelling out to the `sqlite3` CLI on older Node.
+ *
+ * If neither is available, throws an Error whose message contains "ENOENT" so
+ * callers can surface an "Install sqlite3" hint, matching the previous behavior.
+ */
+export function queryDbJson(dbPath, sql, { timeout = 30000, maxBuffer = 100 * 1024 * 1024 } = {}) {
+  const db = openNodeSqlite(dbPath);
+  if (db) {
+    try {
+      return db.prepare(sql).all();
+    } finally {
+      db.close();
+    }
+  }
+  return queryViaCli(dbPath, sql, { timeout, maxBuffer });
+}
+
+let nodeSqlite; // undefined = not tried, null = unavailable
+
+function getNodeSqlite() {
+  if (nodeSqlite !== undefined) return nodeSqlite;
+  try {
+    // Suppress the one-time "SQLite is an experimental feature" ExperimentalWarning
+    // on Node versions where node:sqlite is still flagged experimental.
+    const prevEmit = process.emitWarning;
+    process.emitWarning = (warning, ...rest) => {
+      const opts = rest[0];
+      const type = typeof opts === 'object' && opts ? opts.type : opts;
+      const name = typeof warning === 'object' && warning ? warning.name : undefined;
+      if ((type === 'ExperimentalWarning' || name === 'ExperimentalWarning') && String(warning).includes('SQLite')) return;
+      return prevEmit.call(process, warning, ...rest);
+    };
+    try {
+      nodeSqlite = require('node:sqlite');
+    } finally {
+      process.emitWarning = prevEmit;
+    }
+  } catch {
+    nodeSqlite = null;
+  }
+  return nodeSqlite;
+}
+
+function openNodeSqlite(dbPath) {
+  const mod = getNodeSqlite();
+  if (!mod || !mod.DatabaseSync) return null;
+  try {
+    return new mod.DatabaseSync(dbPath, { readOnly: true });
+  } catch {
+    return null;
+  }
+}
+
+function queryViaCli(dbPath, sql, { timeout, maxBuffer }) {
+  const out = execFileSync('sqlite3', ['-json', dbPath, sql], {
+    encoding: 'utf-8',
+    maxBuffer,
+    timeout,
+  });
+  const trimmed = out.trim();
+  if (!trimmed || trimmed === '[]') return [];
+  return JSON.parse(trimmed);
+}