@vibe-cafe/vibe-usage 0.7.19 → 0.8.1

package/README.md

@@ -49,7 +49,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only) |
 | Codex CLI | `~/.codex/sessions/` and `~/.codex/archived_sessions/` |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
-| Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`) |
+| Cursor | `state.vscdb` (SQLite, reads `cursorAuth/accessToken`, fetches CSV from `cursor.com`); cloud data is stamped with a fixed `cursor-cloud` hostname so multi-machine setups don't double-count |
 | Gemini CLI | `~/.gemini/tmp/` |
 | OpenCode | `~/.local/share/opencode/opencode.db` (SQLite, `json_extract` query) |
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments) |
@@ -68,11 +68,33 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 - Parses local session logs from each AI coding tool
 - Aggregates token usage into 30-minute buckets
 - 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)
+- Uploads buckets + sessions to your vibecafe.ai dashboard (always gzip-compressed, ~94% smaller)
+- Incremental: parsers still compute full totals from local logs each sync (idempotent), but only buckets/sessions that are new or changed since the last successful upload are sent — a quiet machine uploads nothing. Sync state is kept in `~/.vibe-usage/state.json`; deleting it just triggers a one-time full re-upload
 - 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)
 
+## Trust Model
+
+vibe-usage parses **local tool logs and local application state** on a machine the user fully controls. The reported data is self-reported telemetry — local logs, parsers, and upload requests can all be modified by the user.
+
+**Good for visibility, not sufficient for settlement.**
+
+Suitable for:
+
+- personal analytics and efficiency review
+- team-internal AI coding adoption visibility
+- token usage trends across tools, models, and projects
+- rough cost estimation and anomaly detection
+
+Not sufficient for:
+
+- financial settlement or team expense reimbursement
+- user rewards, credits, token, or airdrop allocation
+- agent contribution scoring or marketplace revenue sharing
+- proof-of-work / proof-of-usage or contractual billing
+
+In short: this solves the *visibility* problem, not the *verifiability* problem. High-trust use cases need additional, independently verifiable metering layers.
+
 ## AI Skill
 
 Install vibe-usage as a skill for your AI coding assistant, so it knows how to sync usage data on your behalf:

package/package.json

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

package/src/api.js

@@ -5,7 +5,10 @@ import { gzipSync } from 'node:zlib';
 
 const MAX_RETRIES = 3;
 const INITIAL_DELAY = 1000;
-const GZIP_MIN_BYTES = 1024;
+// Always gzip: ingest bodies are repetitive JSON that compresses ~10:1, and
+// the few-byte gzip header overhead on a tiny body is irrelevant next to
+// guaranteeing no uncompressed request ever leaves the client.
+const GZIP_MIN_BYTES = 0;
 
 export async function ingest(apiUrl, apiKey, buckets, opts, sessions) {
   let lastError;

package/src/parsers/cursor.js

@@ -223,6 +223,10 @@ export async function parse() {
       source: 'cursor',
       model,
       project: 'unknown',
+      // Cursor usage is pulled from the cloud API — it reflects the same account
+      // data on every machine. Use a fixed sentinel so all machines share one row
+      // per (model, bucket_start) rather than duplicating per hostname.
+      hostname: 'cursor-cloud',
       timestamp,
       inputTokens: inputCacheWrite + inputNoCache,
       outputTokens: output,

package/src/sync.js

@@ -1,5 +1,9 @@
 import { hostname as osHostname } from 'node:os';
 import { loadConfig, saveConfig } from './config.js';
+import {
+  loadState, saveState, pruneState,
+  bucketKey, bucketHash, sessionKey, sessionHash,
+} from './state.js';
 import { ingest, fetchSettings } from './api.js';
 import { parsers } from './parsers/index.js';
 import { success, failure, arrow, link, dim } from './output.js';
@@ -67,8 +71,10 @@ export async function runSync({ throws = false, quiet = false } = {}) {
     config.hostname = host;
     saveConfig(config);
   }
-  for (const b of allBuckets) b.hostname = host;
-  for (const s of allSessions) s.hostname = host;
+  // Cloud-sourced parsers (e.g. cursor) pre-set their own hostname sentinel so
+  // the same account data isn't stored as separate rows per machine.
+  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';
@@ -87,18 +93,72 @@ export async function runSync({ throws = false, quiet = false } = {}) {
     for (const s of allSessions) s.project = 'unknown';
   }
 
+  // Incremental diff: parsers above always read the full local history (cheap,
+  // local-only). Here we drop anything whose content matches what we already
+  // uploaded, so only new/changed items go over the network. A quiet machine
+  // sends zero bytes; an active one sends just the current 30-min bucket.
+  // Missing/corrupt state.json => empty maps => one-time full upload, then
+  // incremental forever after.
+  const state = loadState();
+  const changedBuckets = [];
+  const changedSessions = [];
+  const liveBucketKeys = new Set();
+  const liveSessionKeys = new Set();
+  // key -> hash, committed to state only after the owning batch's upload
+  // succeeds (a failed batch re-sends next sync — no silent gap).
+  const pendingBucketState = new Map();
+  const pendingSessionState = new Map();
+
+  for (const b of allBuckets) {
+    const key = bucketKey(b);
+    const h = bucketHash(b);
+    liveBucketKeys.add(key);
+    if (state.buckets[key] === h) continue;
+    changedBuckets.push(b);
+    pendingBucketState.set(key, h);
+  }
+  for (const s of allSessions) {
+    const key = sessionKey(s);
+    const h = sessionHash(s);
+    liveSessionKeys.add(key);
+    if (state.sessions[key] === h) continue;
+    changedSessions.push(s);
+    pendingSessionState.set(key, h);
+  }
+
+  // Drop entries the parsers no longer emit (deleted logs) so state.json can't
+  // grow forever. Done by liveness, never by age — an old bucket's hash never
+  // changes, so keeping it is exactly what prevents re-uploading it.
+  //
+  // Persist the pruned state unconditionally and immediately: removing dead
+  // keys is independent of whether anything uploads, so it must NOT be coupled
+  // to upload success. If we deferred this to the batch loop, a first-batch
+  // failure would throw before any saveState and the prune would be lost.
+  const before = Object.keys(state.buckets).length + Object.keys(state.sessions).length;
+  pruneState(state, liveBucketKeys, liveSessionKeys);
+  const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
+  if (pruned > 0) saveState(state);
+
+  if (changedBuckets.length === 0 && changedSessions.length === 0) {
+    if (!quiet) console.log(dim('无新增数据。'));
+    return 0;
+  }
+
+  const allBucketsToSend = changedBuckets;
+  const allSessionsToSend = changedSessions;
+
   let totalIngested = 0;
   let totalSessionsSynced = 0;
   let totalDroppedBuckets = 0;
   const droppedSources = new Set();
-  const bucketBatches = Math.ceil(allBuckets.length / BATCH_SIZE);
-  const sessionBatches = Math.ceil(allSessions.length / SESSION_BATCH_SIZE);
+  const bucketBatches = Math.ceil(allBucketsToSend.length / BATCH_SIZE);
+  const sessionBatches = Math.ceil(allSessionsToSend.length / SESSION_BATCH_SIZE);
   const totalBatches = Math.max(bucketBatches, sessionBatches, 1);
 
   try {
     for (let batchIdx = 0; batchIdx < totalBatches; batchIdx++) {
-      const batch = allBuckets.slice(batchIdx * BATCH_SIZE, (batchIdx + 1) * BATCH_SIZE);
-      const batchSessions = allSessions.slice(batchIdx * SESSION_BATCH_SIZE, (batchIdx + 1) * SESSION_BATCH_SIZE);
+      const batch = allBucketsToSend.slice(batchIdx * BATCH_SIZE, (batchIdx + 1) * BATCH_SIZE);
+      const batchSessions = allSessionsToSend.slice(batchIdx * SESSION_BATCH_SIZE, (batchIdx + 1) * SESSION_BATCH_SIZE);
       const batchNum = batchIdx + 1;
       const prefix = totalBatches > 1 ? `  ${dim(`[${batchNum}/${totalBatches}]`)} 上传中 ` : '  上传中 ';
 
@@ -114,9 +174,25 @@ export async function runSync({ throws = false, quiet = false } = {}) {
         totalDroppedBuckets += Number(result.dropped.buckets) || 0;
         for (const s of result.dropped.unknownSources || []) droppedSources.add(s);
       }
+
+      // 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.
+      for (const b of batch) {
+        const key = bucketKey(b);
+        const entry = pendingBucketState.get(key);
+        if (entry) state.buckets[key] = entry;
+      }
+      for (const s of batchSessions) {
+        const key = sessionKey(s);
+        const entry = pendingSessionState.get(key);
+        if (entry) state.sessions[key] = entry;
+      }
+      saveState(state);
     }
 
-    if (totalBatches > 1 || allBuckets.length > 0) {
+    if (totalBatches > 1 || allBucketsToSend.length > 0) {
       process.stdout.write('\r\x1b[K');
     }
     const syncParts = [`${totalIngested} buckets`];
@@ -132,9 +208,9 @@ export async function runSync({ throws = false, quiet = false } = {}) {
     }
 
     if (!quiet && totalSessionsSynced > 0) {
-      const totalActive = allSessions.reduce((s, x) => s + x.activeSeconds, 0);
-      const totalDuration = allSessions.reduce((s, x) => s + x.durationSeconds, 0);
-      const totalMsgs = allSessions.reduce((s, x) => s + x.messageCount, 0);
+      const totalActive = allSessionsToSend.reduce((s, x) => s + x.activeSeconds, 0);
+      const totalDuration = allSessionsToSend.reduce((s, x) => s + x.durationSeconds, 0);
+      const totalMsgs = allSessionsToSend.reduce((s, x) => s + x.messageCount, 0);
       const fmtTime = (secs) => {
         if (secs < 60) return `${secs}s`;
         const h = Math.floor(secs / 3600);