@vibe-cafe/vibe-usage 0.10.10 → 0.10.12

package/src/parsers/sqlite.js

@@ -1,5 +1,8 @@
 import { execFileSync } from 'node:child_process';
 import { createRequire } from 'node:module';
+import { copyFileSync, existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
 
 const require = createRequire(import.meta.url);
 
@@ -72,3 +75,46 @@ function queryViaCli(dbPath, sql, { timeout, maxBuffer }) {
   if (!trimmed || trimmed === '[]') return [];
   return JSON.parse(trimmed);
 }
+
+/** Standard "sqlite3 unavailable" hint, reused by every SQLite-backed parser. */
+export function sqliteUnavailableError(label) {
+  return new Error(`sqlite3 CLI not found. Install sqlite3 (or use Node >= 22.5) to sync ${label} data.`);
+}
+
+/** True when the error is the "no sqlite3" hint (node:sqlite absent + CLI absent). */
+export function isSqliteUnavailableError(err) {
+  return !!err && (
+    err.code === 'ENOENT'
+    || err.status === 127
+    || /ENOENT|sqlite3.*not found/i.test(err?.message || '')
+  );
+}
+
+export function isLockError(err) {
+  return !!err && typeof err.message === 'string' && /database is locked/i.test(err.message);
+}
+
+/**
+ * Run a query, and if the source app holds a write lock on the database, copy
+ * the DB (plus its -wal/-shm companions) to a temp dir and re-query the
+ * snapshot. Shared by Cursor / Antigravity / Kiro.
+ */
+export function queryDbJsonSnapshotOnLock(dbPath, sql, { tempPrefix = 'vibe-usage-sqlite', opts } = {}) {
+  try {
+    return queryDbJson(dbPath, sql, opts);
+  } catch (err) {
+    if (!isLockError(err)) throw err;
+    const snapshotDir = mkdtempSync(join(tmpdir(), tempPrefix));
+    const queryPath = join(snapshotDir, basename(dbPath));
+    try {
+      copyFileSync(dbPath, queryPath);
+      for (const suffix of ['-shm', '-wal']) {
+        const companion = `${dbPath}${suffix}`;
+        if (existsSync(companion)) copyFileSync(companion, `${queryPath}${suffix}`);
+      }
+      return queryDbJson(queryPath, sql, opts);
+    } finally {
+      rmSync(snapshotDir, { recursive: true, force: true });
+    }
+  }
+}

package/src/parsers/trae-cli.js

@@ -1,18 +1,8 @@
 import { readFileSync, readdirSync } from 'node:fs';
-import { basename, join } from 'node:path';
+import { join } from 'node:path';
 import { findTraeCliDataDirs } from '../tools.js';
-import { aggregateToBuckets, extractSessions } from './index.js';
-
-function readJsonSafe(path) {
-  try { return JSON.parse(readFileSync(path, 'utf-8')); } catch { return null; }
-}
-
-function projectFromPath(absPath) {
-  if (!absPath || typeof absPath !== 'string') return 'unknown';
-  const trimmed = absPath.replace(/[\\/]+$/, '');
-  const name = basename(trimmed);
-  return name || 'unknown';
-}
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { readJsonSafe, projectFromPath } from './fs-utils.js';
 
 function parseJsonlSafe(path) {
   try {

package/src/parsers/workbuddy.js

@@ -2,7 +2,7 @@ import { createReadStream, readdirSync, statSync } from 'node:fs';
 import { createInterface } from 'node:readline';
 import { basename, join, relative, sep } from 'node:path';
 import { findWorkbuddyDataDirs } from '../workbuddy-roots.js';
-import { aggregateToBuckets, extractSessions } from './index.js';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
 
 const SOURCE = 'workbuddy';
 const MAX_WARNINGS = 20;

package/src/parsers/zcode.js

@@ -1,8 +1,8 @@
 import { 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';
+import { aggregateToBuckets, extractSessions } from './aggregate.js';
+import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 
 // ZCode (z.ai / Zhipu's coding agent) stores everything in a SQLite database
 // at ~/.zcode/cli/db/db.sqlite. The `message` table is the canonical source:
@@ -46,9 +46,7 @@ export async function parse() {
   try {
     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 (or use Node >= 22.5) to sync ZCode data.');
-    }
+    if (isSqliteUnavailableError(err)) throw sqliteUnavailableError('ZCode');
     throw err;
   }
   if (!rows.length) return { buckets: [], sessions: [] };

package/src/state.js

@@ -1,7 +1,7 @@
-import { readFileSync, writeFileSync, unlinkSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, unlinkSync, mkdirSync, existsSync, renameSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
-import { createHash } from 'node:crypto';
+import { createHash, randomBytes } from 'node:crypto';
 
 // Persisted sync state, kept next to config.js's files (same dir + dev split).
 // Maps a stable item key -> hash of its mutable fields, recording what we have
@@ -34,7 +34,18 @@ export function loadState() {
 
 export function saveState(state) {
   mkdirSync(STATE_DIR, { recursive: true });
-  writeFileSync(STATE_FILE, JSON.stringify(state) + '\n', 'utf-8');
+  // Atomic replace: write to a unique temp file then rename over the target.
+  // A crash mid-write can no longer truncate state.json into an unreadable
+  // file that loadState() would treat as empty (triggering a full re-upload).
+  const tempPath = `${STATE_FILE}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`;
+  try {
+    writeFileSync(tempPath, JSON.stringify(state) + '\n', 'utf-8');
+    renameSync(tempPath, STATE_FILE);
+  } finally {
+    // No-op after a successful rename (the temp file is already gone); cleans
+    // up the partial write if writeFileSync threw.
+    rmSync(tempPath, { force: true });
+  }
 }
 
 // Drop all recorded upload state so the next sync re-uploads everything.

package/src/summary.js

@@ -1,32 +1,30 @@
-import https from 'node:https';
-import http from 'node:http';
-import { URL } from 'node:url';
 import { loadConfig } from './config.js';
+import { getJson } from './api.js';
+import { failure } from './output.js';
 
 export async function runSummary(args = []) {
   const days = parseDays(args);
   const config = loadConfig();
   if (!config?.apiKey) {
-    console.error('No vibe-usage config found. Run `npx @vibe-cafe/vibe-usage init` first.');
+    console.error(failure('尚未配置，请先运行 `npx @vibe-cafe/vibe-usage init`。'));
     process.exit(1);
   }
 
-  const url = new URL('/api/usage', config.apiUrl || 'https://vibecafe.ai');
-  url.searchParams.set('days', String(days));
+  const apiUrl = config.apiUrl || 'https://vibecafe.ai';
 
   let data;
   try {
-    data = await fetchJson(url, config.apiKey);
+    data = await getJson(apiUrl, config.apiKey, `/api/usage?days=${days}`, { timeoutMs: 15_000 });
   } catch (err) {
     if (err.statusCode === 401) {
-      console.error('API key invalid or revoked. Run `npx @vibe-cafe/vibe-usage init` to re-link.');
+      console.error(failure('API Key 无效，请运行 `npx @vibe-cafe/vibe-usage init` 重新配置。'));
     } else {
-      console.error(`Failed to fetch usage: ${err.message}`);
+      console.error(failure(`获取用量数据失败: ${err.message}`));
     }
     process.exit(1);
   }
 
-  console.log(render(data, days));
+  console.log(render(data, days, apiUrl));
 }
 
 function parseDays(args) {
@@ -38,12 +36,13 @@ function parseDays(args) {
   return v;
 }
 
-function render(data, days) {
+function render(data, days, apiUrl) {
   const buckets = Array.isArray(data?.buckets) ? data.buckets : [];
   const sessions = Array.isArray(data?.sessions) ? data.sessions : [];
+  const dashboard = `${apiUrl}/usage`;
 
   if (buckets.length === 0) {
-    return `# Vibe Usage Summary (Last ${days} ${days === 1 ? 'day' : 'days'})\n\n暂无数据。运行 \`npx @vibe-cafe/vibe-usage sync\` 上传本地 token 记录。\n\n详情: https://vibecafe.ai/usage\n`;
+    return `# Vibe Usage Summary (Last ${days} ${days === 1 ? 'day' : 'days'})\n\n暂无数据。运行 \`npx @vibe-cafe/vibe-usage sync\` 上传本地 token 记录。\n\n详情: ${dashboard}\n`;
   }
 
   let totalCost = 0;
@@ -94,7 +93,7 @@ function render(data, days) {
   }
   lines.push('');
 
-  lines.push('详情: https://vibecafe.ai/usage');
+  lines.push(`详情: ${dashboard}`);
   return lines.join('\n');
 }
 
@@ -115,32 +114,3 @@ function formatTokens(n) {
   if (n >= 1_000) return (n / 1_000).toFixed(0) + 'K';
   return String(n);
 }
-
-function fetchJson(url, apiKey) {
-  return new Promise((resolve, reject) => {
-    const mod = url.protocol === 'https:' ? https : http;
-    const req = mod.request(url, {
-      method: 'GET',
-      timeout: 15_000,
-      headers: { 'Authorization': `Bearer ${apiKey}` },
-    }, (res) => {
-      let data = '';
-      res.on('data', (chunk) => { data += chunk; });
-      res.on('end', () => {
-        if (res.statusCode === 401) {
-          const err = new Error('Unauthorized'); err.statusCode = 401; reject(err); return;
-        }
-        if (res.statusCode < 200 || res.statusCode >= 300) {
-          const err = new Error(`HTTP ${res.statusCode}: ${data.slice(0, 200)}`);
-          err.statusCode = res.statusCode;
-          reject(err); return;
-        }
-        try { resolve(JSON.parse(data)); }
-        catch { reject(new Error('Invalid JSON response')); }
-      });
-    });
-    req.on('error', reject);
-    req.on('timeout', () => { req.destroy(); reject(new Error('timeout (15s)')); });
-    req.end();
-  });
-}

package/src/sync.js

@@ -6,8 +6,10 @@ import {
 } from './state.js';
 import { ingest, fetchSettings } from './api.js';
 import { createSyncClient, forBatch } from './client-meta.js';
-import { aggregateToBuckets, parsers } from './parsers/index.js';
-import { success, failure, arrow, link, dim } from './output.js';
+import { parsers } from './parsers/index.js';
+import { aggregateToBuckets } from './parsers/aggregate.js';
+import { normalizeParserResult } from './parsers/contract.js';
+import { success, failure, warn, arrow, link, dim } from './output.js';
 
 const BATCH_SIZE = 100;
 const SESSION_BATCH_SIZE = 500;
@@ -27,6 +29,13 @@ export function resolveUploadProjectSetting(settings) {
   return settings.uploadProject;
 }
 
+export function resolveCachedUploadProjectSetting(config, apiUrl) {
+  if (config?.lastUploadProjectApiUrl !== apiUrl) return undefined;
+  return typeof config.lastUploadProject === 'boolean'
+    ? config.lastUploadProject
+    : undefined;
+}
+
 export function resolveCodexExtraHome(configured, temporary) {
   return temporary ?? configured;
 }
@@ -41,6 +50,27 @@ export function reaggregateHiddenProjectBuckets(buckets) {
   })));
 }
 
+// Parser execution is I/O bound (log reads, occasional network calls). Run a
+// bounded number at once to cut wall-clock sync time without the memory spike
+// of loading every tool's logs simultaneously.
+export const PARSER_CONCURRENCY = 4;
+
+// Run `fn` over `items` with at most `limit` in flight, preserving order.
+export async function mapWithConcurrency(items, limit, fn) {
+  const results = new Array(items.length);
+  let nextIndex = 0;
+  const workerCount = Math.max(1, Math.min(limit, items.length));
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (true) {
+      const index = nextIndex++;
+      if (index >= items.length) return;
+      results[index] = await fn(items[index], index);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+
 export async function runSync({
   throws = false,
   quiet = false,
@@ -70,14 +100,34 @@ export async function runSync({
   try {
     const settings = await fetchSettings(apiUrl, config.apiKey);
     uploadProject = resolveUploadProjectSetting(settings);
+    // Scope the cached privacy choice to the server that returned it. Reusing
+    // the value after `apiUrl` changes could expose project names to a
+    // different server during its first settings outage.
+    if (
+      config.lastUploadProject !== uploadProject
+      || config.lastUploadProjectApiUrl !== apiUrl
+    ) {
+      config.lastUploadProject = uploadProject;
+      config.lastUploadProjectApiUrl = apiUrl;
+      saveConfig(config);
+    }
   } catch (err) {
     if (err.message === 'UNAUTHORIZED') {
       console.error(failure('API Key 无效，请运行 `npx @vibe-cafe/vibe-usage init` 重新配置。'));
+      if (throws) throw err;
+      process.exit(1);
+    }
+    // Settings endpoint unreachable (not auth): degrade to the last confirmed
+    // choice for this same server rather than hard-aborting every upload.
+    const cachedUploadProject = resolveCachedUploadProjectSetting(config, apiUrl);
+    if (typeof cachedUploadProject === 'boolean') {
+      uploadProject = cachedUploadProject;
+      if (!quiet) console.log(warn('设置接口不可用，沿用上次的项目名设置。'));
     } else {
       console.error(failure('暂时无法读取上传设置，本次同步已安全取消（未上传数据）。请稍后重试。'));
+      if (throws) throw err;
+      process.exit(1);
     }
-    if (throws) throw err;
-    process.exit(1);
   }
 
   let allBuckets = [];
@@ -89,36 +139,52 @@ export async function runSync({
   // state and force a full re-upload next run.
   const okSources = new Set();
 
-  for (const [source, parse] of Object.entries(parsers)) {
-    try {
-      const result = source === 'codex'
-        ? await parse({ codexExtraHome: resolveCodexExtraHome(config.codexExtraHome, codexExtraHome) })
-        : await parse();
-      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');
+  // Run parsers concurrently (bounded) so one slow parser (Cursor's network
+  // fetch, a cold Codex index) can't stall the rest. Results are collected in
+  // registry order so output and merged arrays stay deterministic.
+  const parserOutcomes = await mapWithConcurrency(
+    Object.entries(parsers),
+    PARSER_CONCURRENCY,
+    async ([source, parse]) => {
+      try {
+        const result = source === 'codex'
+          ? await parse({ codexExtraHome: resolveCodexExtraHome(config.codexExtraHome, codexExtraHome) })
+          : await parse();
+        return { source, result };
+      } catch (err) {
+        return { source, error: err };
       }
-      if (result?.indexing) {
-        parserProgress.push({ source, ...result.indexing });
-      }
-      if (Array.isArray(result?.warnings)) {
-        for (const message of result.warnings) {
-          process.stderr.write(`${dim(`  ${message}`)}\n`);
-        }
-      }
-      // A parser may deliberately suppress a transient error (Cursor network
-      // timeout) to keep daemon logs quiet. Its empty result is not proof that
-      // its prior data disappeared, so it must not be pruned this run.
-      if (!result?.skipped) okSources.add(source);
-      if (buckets.length > 0) allBuckets.push(...buckets);
-      if (sessions.length > 0) allSessions.push(...sessions);
-      if (buckets.length > 0 || sessions.length > 0) {
-        parserResults.push({ source, buckets: buckets.length, sessions: sessions.length });
-      }
-    } catch (err) {
+    },
+  );
+
+  for (const { source, result, error } of parserOutcomes) {
+    if (error) {
       // Parser errors are non-fatal — pass-through in dim gray (no translation).
+      process.stderr.write(`${dim(`  ${source}: ${error.message}`)}\n`);
+      continue;
+    }
+    let normalized;
+    try {
+      normalized = normalizeParserResult(source, result);
+    } catch (err) {
       process.stderr.write(`${dim(`  ${source}: ${err.message}`)}\n`);
+      continue;
+    }
+    const { buckets, sessions, skipped, warnings, indexing } = normalized;
+    if (indexing) {
+      parserProgress.push({ source, ...indexing });
+    }
+    for (const message of warnings) {
+      process.stderr.write(`${dim(`  ${message}`)}\n`);
+    }
+    // A parser may deliberately suppress a transient error (Cursor network
+    // timeout) to keep daemon logs quiet. Its empty result is not proof that
+    // its prior data disappeared, so it must not be pruned this run.
+    if (!skipped) okSources.add(source);
+    if (buckets.length > 0) allBuckets.push(...buckets);
+    if (sessions.length > 0) allSessions.push(...sessions);
+    if (buckets.length > 0 || sessions.length > 0) {
+      parserResults.push({ source, buckets: buckets.length, sessions: sessions.length });
     }
   }
 
@@ -271,10 +337,10 @@ export async function runSync({
       }
       totalProtectedBuckets += Number(result.protected?.buckets) || 0;
 
-      // Commit only this batch's hashes, only after it uploaded successfully.
-      // A batch that throws aborts the loop with its keys still absent from
-      // state, so the next sync re-sends exactly those items — no data loss,
-      // no silent gaps.
+      // Commit only hashes from this successful batch. Persist before starting
+      // the next batch: if a later upload fails or the process exits abruptly,
+      // the next sync retries only the uncommitted suffix.
+      let batchStateChanged = false;
       for (const b of batch) {
         // A source unknown to an older backend may become valid after deploy.
         // Leave those hashes uncommitted so the next sync retries them instead
@@ -282,14 +348,20 @@ export async function runSync({
         if (batchUnknownSources.has(b.source)) continue;
         const key = bucketKey(b);
         const entry = pendingBucketState.get(key);
-        if (entry) state.buckets[key] = entry;
+        if (entry) {
+          state.buckets[key] = entry;
+          batchStateChanged = true;
+        }
       }
       for (const s of batchSessions) {
         const key = sessionKey(s);
         const entry = pendingSessionState.get(key);
-        if (entry) state.sessions[key] = entry;
+        if (entry) {
+          state.sessions[key] = entry;
+          batchStateChanged = true;
+        }
       }
-      saveState(state);
+      if (batchStateChanged) saveState(state);
     }
 
     if (totalBatches > 1 || allBucketsToSend.length > 0) {