@vibe-cafe/vibe-usage 0.7.18 → 0.8.0

package/README.md

@@ -47,7 +47,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Tool | Data Location |
 |------|---------------|
 | Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only) |
-| Codex CLI | `~/.codex/sessions/` |
+| 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`) |
 | Gemini CLI | `~/.gemini/tmp/` |
@@ -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.18",
+  "version": "0.8.0",
   "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/codex.js

@@ -4,7 +4,18 @@ import { homedir } from 'node:os';
 import { createInterface } from 'node:readline';
 import { aggregateToBuckets, extractSessions } from './index.js';
 
-const SESSIONS_DIR = join(homedir(), '.codex', 'sessions');
+// Codex stores live sessions in ~/.codex/sessions and, once a session is
+// "completed", moves its rollout file verbatim into ~/.codex/archived_sessions.
+// A session can be archived between two syncs, so scanning only the live dir
+// loses that session's usage forever. We scan both: the parser is stateless
+// and the server dedups on (source, sessionHash/bucket), so re-reading an
+// archived file that was already synced from sessions/ is idempotent. Indexing
+// both together also keeps fork replay-skip correct when a fork and its parent
+// end up split across the two directories.
+const SESSIONS_DIRS = [
+  join(homedir(), '.codex', 'sessions'),
+  join(homedir(), '.codex', 'archived_sessions'),
+];
 
 /**
  * Recursively find all .jsonl files under a directory.
@@ -80,11 +91,11 @@ async function indexSessionFile(filePath) {
 }
 
 export async function parse() {
-  if (!existsSync(SESSIONS_DIR)) return { buckets: [], sessions: [] };
+  if (!SESSIONS_DIRS.some(existsSync)) return { buckets: [], sessions: [] };
 
   const entries = [];
   const sessionEvents = [];
-  const files = findJsonlFiles(SESSIONS_DIR);
+  const files = SESSIONS_DIRS.flatMap(findJsonlFiles);
   if (files.length === 0) return { buckets: [], sessions: [] };
 
   // Pass 1: index every session by its UUID and count its token_count
@@ -134,6 +145,12 @@ export async function parse() {
     let tokenCountSeen = 0;
 
     const sessionProject = fm.sessionProject;
+    // Group timing events by the real Codex session id, not the file path: the
+    // same session can briefly exist in both sessions/ and archived_sessions/
+    // (mid-archive, or a re-synced archive). Path-keyed grouping would emit it
+    // as two different sessionHashes and double-count its session stats. Fall
+    // back to the path only when the id is unknown (corrupt/missing meta).
+    const sessionKey = fm.sessionId || filePath;
 
     let turnContextModel = 'unknown';
     const prevTotal = new Map();
@@ -161,7 +178,7 @@ export async function parse() {
             if (!isReplay) {
               const isUserTurn = obj.type === 'turn_context' || obj.type === 'session_meta';
               sessionEvents.push({
-                sessionId: filePath,
+                sessionId: sessionKey,
                 source: 'codex',
                 project: sessionProject,
                 timestamp: evTs,

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';
@@ -87,18 +91,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 +172,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 +206,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);

package/src/tools.js

@@ -80,6 +80,16 @@ function findOpenclawDataDirs() {
   return dirs;
 }
 
+// Codex keeps live sessions in ~/.codex/sessions and moves completed ones to
+// ~/.codex/archived_sessions. Detect Codex if either dir exists, so a user
+// whose sessions have all been archived is still recognized.
+function findCodexDataDirs() {
+  return [
+    join(homedir(), '.codex', 'sessions'),
+    join(homedir(), '.codex', 'archived_sessions'),
+  ].filter(existsSync);
+}
+
 export const TOOLS = [
   {
     name: 'Antigravity',
@@ -101,6 +111,7 @@ export const TOOLS = [
     name: 'Codex CLI',
     id: 'codex',
     dataDir: join(homedir(), '.codex', 'sessions'),
+    detectDataDirs: findCodexDataDirs,
   },
   {
     name: 'GitHub Copilot CLI',