@vibe-cafe/vibe-usage 0.10.1 → 0.10.3

package/package.json

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

package/src/api.js

@@ -10,11 +10,22 @@ const INITIAL_DELAY = 1000;
 // guaranteeing no uncompressed request ever leaves the client.
 const GZIP_MIN_BYTES = 0;
 
+export function retryDelayMs(attempt, random = Math.random) {
+  const ceiling = INITIAL_DELAY * 2 ** attempt;
+  // Equal jitter keeps a real backoff floor while preventing every desktop
+  // client from retrying a shared outage on the same 1s / 2s boundaries.
+  return Math.round(ceiling / 2 + random() * ceiling / 2);
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
 export async function ingest(apiUrl, apiKey, buckets, opts, sessions) {
   let lastError;
   for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
     try {
-      return await _send(apiUrl, apiKey, buckets, opts?.onProgress, sessions);
+      return await _send(apiUrl, apiKey, buckets, opts, sessions);
     } catch (err) {
       lastError = err;
       // Don't retry auth errors or client errors
@@ -22,22 +33,29 @@ export async function ingest(apiUrl, apiKey, buckets, opts, sessions) {
         throw err;
       }
       if (attempt < MAX_RETRIES - 1) {
-        const delay = INITIAL_DELAY * 2 ** attempt;
-        await new Promise(r => setTimeout(r, delay));
+        await sleep(retryDelayMs(attempt));
       }
     }
   }
   throw lastError;
 }
 
-function _send(apiUrl, apiKey, buckets, onProgress, sessions) {
+export function encodeIngestBody(buckets, opts, sessions) {
+  const payload = { buckets };
+  if (sessions && sessions.length > 0) payload.sessions = sessions;
+  if (opts?.client) payload.client = opts.client;
+  const raw = Buffer.from(JSON.stringify(payload));
+  const useGzip = raw.length >= GZIP_MIN_BYTES;
+  return {
+    body: useGzip ? gzipSync(raw) : raw,
+    useGzip,
+  };
+}
+
+function _send(apiUrl, apiKey, buckets, opts, sessions) {
   return new Promise((resolve, reject) => {
     const url = new URL('/api/usage/ingest', apiUrl);
-    const payload = { buckets };
-    if (sessions && sessions.length > 0) payload.sessions = sessions;
-    const raw = Buffer.from(JSON.stringify(payload));
-    const useGzip = raw.length >= GZIP_MIN_BYTES;
-    const body = useGzip ? gzipSync(raw) : raw;
+    const { body, useGzip } = encodeIngestBody(buckets, opts, sessions);
     const totalBytes = body.length;
     const mod = url.protocol === 'https:' ? https : http;
 
@@ -89,7 +107,7 @@ function _send(apiUrl, apiKey, buckets, onProgress, sessions) {
       while (ok && sent < totalBytes) {
         const slice = body.subarray(sent, sent + CHUNK);
         sent += slice.length;
-        if (onProgress) onProgress(sent, totalBytes);
+        if (opts?.onProgress) opts.onProgress(sent, totalBytes);
         ok = req.write(slice);
       }
       if (sent < totalBytes) {
@@ -214,13 +232,36 @@ function _jsonRequest(apiUrl, path, method, body, timeoutMs) {
 
 /**
  * GET user settings from the vibecafe API.
- * Returns null on any failure (network, auth, timeout) — caller should fail-safe.
+ * Returns null after transient failures are exhausted. A 401 remains distinct
+ * so callers can surface invalid credentials instead of calling it an outage.
  * @param {string} apiUrl
  * @param {string} apiKey
  * @returns {Promise<{uploadProject: boolean} | null>}
  */
-export function fetchSettings(apiUrl, apiKey) {
-  return new Promise((resolve) => {
+export async function fetchSettings(apiUrl, apiKey, retry = {}) {
+  const wait = retry.sleep ?? sleep;
+  const random = retry.random ?? Math.random;
+
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      return await fetchSettingsOnce(apiUrl, apiKey);
+    } catch (err) {
+      if (err.message === 'UNAUTHORIZED') throw err;
+      // Retrying a permanent client response cannot make it valid. 429 is the
+      // exception: it is transient load shedding and benefits from backoff.
+      if (err.statusCode >= 400 && err.statusCode < 500 && err.statusCode !== 429) {
+        return null;
+      }
+      if (attempt < MAX_RETRIES - 1) {
+        await wait(retryDelayMs(attempt, random));
+      }
+    }
+  }
+  return null;
+}
+
+function fetchSettingsOnce(apiUrl, apiKey) {
+  return new Promise((resolve, reject) => {
     const url = new URL('/api/usage/settings', apiUrl);
     const mod = url.protocol === 'https:' ? https : http;
 
@@ -234,20 +275,31 @@ export function fetchSettings(apiUrl, apiKey) {
       let data = '';
       res.on('data', (chunk) => { data += chunk; });
       res.on('end', () => {
+        if (res.statusCode === 401) {
+          reject(new Error('UNAUTHORIZED'));
+          return;
+        }
         if (res.statusCode < 200 || res.statusCode >= 300) {
-          resolve(null);
+          const err = new Error(`HTTP ${res.statusCode}: ${data}`);
+          err.statusCode = res.statusCode;
+          reject(err);
           return;
         }
         try {
-          resolve(JSON.parse(data));
+          const settings = JSON.parse(data);
+          if (typeof settings?.uploadProject !== 'boolean') {
+            reject(new Error('Invalid settings response'));
+            return;
+          }
+          resolve(settings);
         } catch {
-          resolve(null);
+          reject(new Error('Invalid settings response'));
         }
       });
     });
 
-    req.on('error', () => resolve(null));
-    req.on('timeout', () => { req.destroy(); resolve(null); });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(new Error('Settings request timed out')); });
     req.end();
   });
 }

package/src/client-meta.js

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+
+const pkg = JSON.parse(
+  readFileSync(new URL('../package.json', import.meta.url), 'utf-8'),
+);
+
+const SURFACES = new Set(['cli', 'daemon', 'mac-app', 'windows-app']);
+
+export const COLLECTOR_VERSION = String(pkg.version);
+
+function cleanEnv(value, maxLength = 50) {
+  if (typeof value !== 'string') return null;
+  const cleaned = value.trim().slice(0, maxLength);
+  return cleaned || null;
+}
+
+export function createSyncClient({ defaultSurface = 'cli', hostname } = {}) {
+  const requestedSurface = cleanEnv(process.env.VIBE_USAGE_SURFACE, 30);
+  const surface = requestedSurface && SURFACES.has(requestedSurface)
+    ? requestedSurface
+    : defaultSurface;
+  const runtime = process.versions.bun ? 'bun' : 'node';
+  const runtimeVersion = process.versions.bun || process.versions.node;
+
+  return {
+    collectorVersion: COLLECTOR_VERSION,
+    surface,
+    surfaceVersion: cleanEnv(process.env.VIBE_USAGE_SURFACE_VERSION) || COLLECTOR_VERSION,
+    runtime,
+    runtimeVersion,
+    platform: process.platform,
+    hostname: cleanEnv(hostname, 200) || 'unknown',
+    syncId: randomUUID(),
+  };
+}
+
+export function forBatch(client, batchIndex, batchCount) {
+  return {
+    ...client,
+    batchIndex,
+    batchCount,
+  };
+}

package/src/daemon.js

@@ -34,7 +34,7 @@ export async function runDaemon() {
   // eslint-disable-next-line no-constant-condition
   while (true) {
     try {
-      await runSync({ throws: true, quiet: true });
+      await runSync({ throws: true, quiet: true, surface: 'daemon' });
       consecutiveAuthFailures = 0;
     } catch (err) {
       if (err.message === 'UNAUTHORIZED') {

package/src/sync.js

@@ -5,6 +5,7 @@ import {
   bucketKey, bucketHash, sessionKey, sessionHash,
 } from './state.js';
 import { ingest, fetchSettings } from './api.js';
+import { createSyncClient, forBatch } from './client-meta.js';
 import { parsers } from './parsers/index.js';
 import { success, failure, arrow, link, dim } from './output.js';
 
@@ -17,7 +18,16 @@ function formatBytes(bytes) {
   return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
 }
 
-export async function runSync({ throws = false, quiet = false } = {}) {
+export function resolveUploadProjectSetting(settings) {
+  if (typeof settings?.uploadProject !== 'boolean') {
+    const error = new Error('SETTINGS_UNAVAILABLE');
+    error.code = 'SETTINGS_UNAVAILABLE';
+    throw error;
+  }
+  return settings.uploadProject;
+}
+
+export async function runSync({ throws = false, quiet = false, surface = 'cli' } = {}) {
   const config = loadConfig();
   if (!config?.apiKey) {
     console.error(failure('尚未配置，请先运行 `npx @vibe-cafe/vibe-usage init`。'));
@@ -31,6 +41,26 @@ export async function runSync({ throws = false, quiet = false } = {}) {
     saveConfig(config);
   }
 
+  // Privacy is a required input, not an optional hint. If the settings API is
+  // unavailable, treating it as `false` changes every project-bearing item's
+  // incremental identity to `unknown` and can trigger a full-history upload.
+  // Resolve it before parsing or loading upload state so failure is a true
+  // no-op: no data upload and no state mutation.
+  const apiUrl = config.apiUrl || 'https://vibecafe.ai';
+  let uploadProject;
+  try {
+    const settings = await fetchSettings(apiUrl, config.apiKey);
+    uploadProject = resolveUploadProjectSetting(settings);
+  } catch (err) {
+    if (err.message === 'UNAUTHORIZED') {
+      console.error(failure('API Key 无效，请运行 `npx @vibe-cafe/vibe-usage init` 重新配置。'));
+    } else {
+      console.error(failure('暂时无法读取上传设置，本次同步已安全取消（未上传数据）。请稍后重试。'));
+    }
+    if (throws) throw err;
+    process.exit(1);
+  }
+
   const allBuckets = [];
   const allSessions = [];
   const parserResults = [];
@@ -115,11 +145,6 @@ export async function runSync({ throws = false, quiet = false } = {}) {
   for (const b of allBuckets) if (!b.hostname) b.hostname = host;
   for (const s of allSessions) if (!s.hostname) s.hostname = host;
 
-  // Privacy: check if user allows project name upload
-  const apiUrl = config.apiUrl || 'https://vibecafe.ai';
-  const settings = await fetchSettings(apiUrl, config.apiKey);
-  const uploadProject = settings?.uploadProject === true;
-
   if (!quiet) {
     if (uploadProject) {
       console.log(dim('  项目名: 上传（可在 Web 设置中关闭）'));
@@ -192,10 +217,12 @@ export async function runSync({ throws = false, quiet = false } = {}) {
   let totalDroppedBuckets = 0;
   let totalDroppedUnknownModels = 0;
   let totalDroppedImplausible = 0;
+  let totalProtectedBuckets = 0;
   const droppedSources = new Set();
   const bucketBatches = Math.ceil(allBucketsToSend.length / BATCH_SIZE);
   const sessionBatches = Math.ceil(allSessionsToSend.length / SESSION_BATCH_SIZE);
   const totalBatches = Math.max(bucketBatches, sessionBatches, 1);
+  const syncClient = createSyncClient({ defaultSurface: surface, hostname: host });
 
   try {
     for (let batchIdx = 0; batchIdx < totalBatches; batchIdx++) {
@@ -205,6 +232,7 @@ export async function runSync({ throws = false, quiet = false } = {}) {
       const prefix = totalBatches > 1 ? `  ${dim(`[${batchNum}/${totalBatches}]`)} 上传中 ` : '  上传中 ';
 
       const result = await ingest(apiUrl, config.apiKey, batch, {
+        client: forBatch(syncClient, batchIdx, totalBatches),
         onProgress(sent, total) {
           const pct = Math.round((sent / total) * 100);
           process.stdout.write(`\r${prefix}${dim(`${formatBytes(sent)}/${formatBytes(total)} (${pct}%)`)}\x1b[K`);
@@ -219,6 +247,7 @@ export async function runSync({ throws = false, quiet = false } = {}) {
         totalDroppedImplausible += Number(result.dropped.implausible) || 0;
         for (const s of result.dropped.unknownSources || []) droppedSources.add(s);
       }
+      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
@@ -259,6 +288,10 @@ export async function runSync({ throws = false, quiet = false } = {}) {
       console.log(dim(`  ${totalDroppedBuckets} buckets dropped (${reasons.join('；')})`));
     }
 
+    if (totalProtectedBuckets > 0) {
+      console.log(dim(`  服务端保留了 ${totalProtectedBuckets} 个更大的已有 bucket（本次较小快照未覆盖）`));
+    }
+
     if (!quiet && totalSessionsSynced > 0) {
       const totalActive = allSessionsToSend.reduce((s, x) => s + x.activeSeconds, 0);
       const totalDuration = allSessionsToSend.reduce((s, x) => s + x.durationSeconds, 0);