@vibe-cafe/vibe-usage 0.10.10 → 0.10.11

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) {