@vibe-cafe/vibe-usage 0.9.13 → 0.9.15

package/README.md

@@ -40,7 +40,7 @@ npx @vibe-cafe/vibe-usage daemon status     # Show background service status
 npx @vibe-cafe/vibe-usage daemon stop       # Stop background service
 npx @vibe-cafe/vibe-usage daemon restart    # Restart background service
 npx @vibe-cafe/vibe-usage reset        # Delete all data and re-upload from local logs
-npx @vibe-cafe/vibe-usage reset --local  # Delete this host's data only and re-upload
+npx @vibe-cafe/vibe-usage reset --local  # Delete this host's data only and re-upload (`--host` remains a legacy alias)
 npx @vibe-cafe/vibe-usage skill         # Install skill for AI coding assistants
 npx @vibe-cafe/vibe-usage skill --remove  # Remove installed skills
 npx @vibe-cafe/vibe-usage status       # Show config & detected tools
@@ -52,6 +52,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 |------|---------------|
 | Claude Code | `~/.claude/projects/` (tokens + sessions), `~/.claude/transcripts/` (sessions only); also scans `$CLAUDE_CONFIG_DIR` when set (deduped), so relocated configs and GUI/CLI env mismatches are both covered |
 | Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`); forked and sub-agent rollouts replay parent metadata, tasks, and `token_count` records at spawn time — full or last-N-turn replay blocks are matched as a fingerprinted parent suffix plus the child's own task boundary, duplicate cumulative emissions count once, and live/archive copies of the same session are deduplicated |
+| Grok | `$GROK_HOME/sessions/<encoded-cwd>/<session-id>/` (default `~/.grok`); token usage from `updates.jsonl` `turn_completed.usage` (per-model `modelUsage`, cache reads, reasoning); project from `summary.json` cwd; honors `GROK_HOME` |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
 | 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/<project_hash>/chats/session-*.jsonl` (current line-delimited format) and legacy `session-*.json`; recurses into nested subagent sessions |
@@ -59,7 +60,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | OpenClaw | `~/.openclaw/agents/`, `~/.openclaw-<profile>/agents/` (profile deployments) |
 | pi | `~/.pi/agent/sessions/` |
 | Qwen Code | `~/.qwen/tmp/` |
-| Kimi Code | `~/.kimi/sessions/<md5(workdir)>/<session-id>/wire.jsonl` (wire protocol 1.9, model from `~/.kimi/config.toml`, project from `~/.kimi/kimi.json`) |
+| Kimi Code | Current `~/.kimi-code/sessions/wd_<slug>_<hash>/session_<id>/agents/<agent>/wire.jsonl` (`usage.record` deltas, including retry/compaction scope and cache creation; main/subagent wires form one session), with project names from `session_index.jsonl`; legacy `~/.kimi/sessions/` remains supported |
 | Amp | `~/.local/share/amp/threads/` |
 | Droid | `~/.factory/sessions/` |
 | Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
@@ -76,7 +77,7 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 - 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 (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
+- 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`; failed parsers retain their prior state, while deleted local logs are pruned. Deleting the state file triggers a one-time full re-upload, and `reset` clears it automatically after deleting cloud data
 - 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)
 
@@ -124,6 +125,8 @@ npx skills add vibe-cafe/vibe-usage
 
 ## Development
 
+Run the Node test suite locally with `npm test`. CI covers Node 20 and 22 on Ubuntu and macOS.
+
 Test against a local vibe-cafe dev server without publishing:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-cafe/vibe-usage",
-  "version": "0.9.13",
+  "version": "0.9.15",
   "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
   "type": "module",
   "scripts": {
@@ -23,6 +23,7 @@
     "tokens",
     "claude",
     "codex",
+    "grok",
     "gemini"
   ],
   "dependencies": {},

package/src/config.js

@@ -1,8 +1,9 @@
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { readFileSync, writeFileSync, chmodSync, mkdirSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 
-const CONFIG_DIR = join(homedir(), '.vibe-usage');
+// VIBE_USAGE_CONFIG_DIR overrides the dir (test hook).
+const CONFIG_DIR = process.env.VIBE_USAGE_CONFIG_DIR?.trim() || join(homedir(), '.vibe-usage');
 const isDev = process.env.VIBE_USAGE_DEV === '1';
 const CONFIG_FILE = join(CONFIG_DIR, isDev ? 'config.dev.json' : 'config.json');
 
@@ -21,5 +22,15 @@ export function loadConfig() {
 
 export function saveConfig(config) {
   mkdirSync(CONFIG_DIR, { recursive: true });
-  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  // The file holds the vbu_ API key — never leave it group/world-readable.
+  // mode only applies at file creation, so chmod explicitly for pre-existing
+  // files written before this hardening.
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', { encoding: 'utf-8', mode: 0o600 });
+  try {
+    chmodSync(CONFIG_FILE, 0o600);
+  } catch (err) {
+    // Windows permission models vary; on POSIX, do not silently leave an API
+    // key file broader than owner-only if hardening a pre-existing file fails.
+    if (process.platform !== 'win32') throw err;
+  }
 }

package/src/daemon-service.js

@@ -236,7 +236,16 @@ function stop() {
   }
 
   if (plat === 'launchd') {
-    const result = run('launchctl', ['stop', LAUNCHD_LABEL]);
+    // The plist sets KeepAlive=true, so `launchctl stop` is useless here —
+    // launchd immediately relaunches the job and the daemon keeps running.
+    // unload removes the job from launchd entirely; the plist file stays on
+    // disk, so `daemon restart` (load) and status detection keep working.
+    const paths = getServicePaths(plat);
+    if (!existsSync(paths.file)) {
+      console.log(dim('未安装 daemon 服务。'));
+      return;
+    }
+    const result = run('launchctl', ['unload', paths.file]);
     console.log(result.ok ? success('服务已停止。') : failure(`停止失败: ${result.output}`));
   }
 }
@@ -254,8 +263,11 @@ function restart() {
   }
 
   if (plat === 'launchd') {
-    run('launchctl', ['stop', LAUNCHD_LABEL]);
-    const result = run('launchctl', ['start', LAUNCHD_LABEL]);
+    // unload + load (not stop + start): stop can't win against KeepAlive, and
+    // load re-runs the job immediately thanks to RunAtLoad=true.
+    const paths = getServicePaths(plat);
+    run('launchctl', ['unload', paths.file]);
+    const result = run('launchctl', ['load', paths.file]);
     console.log(result.ok ? success('服务已重启。') : failure(`重启失败: ${result.output}`));
   }
 }

package/src/index.js

@@ -146,14 +146,17 @@ export async function run(rawArgs) {
     case 'daemon':
     case '--daemon': {
       const sub = args[1];
-      if (sub && ['install', 'uninstall', 'status', 'stop', 'restart'].includes(sub)) {
-        printSmallHeader();
-        const { manageDaemon } = await import('./daemon-service.js');
-        await manageDaemon(sub);
-      } else {
+      if (sub === undefined) {
         // Foreground daemon loop — no header, just start syncing
         const { runDaemon } = await import('./daemon.js');
         await runDaemon();
+      } else {
+        // manageDaemon validates the subcommand and exits 1 on unknown ones —
+        // a typo (e.g. `daemon stauts`) must never fall through to the
+        // infinite foreground loop.
+        printSmallHeader();
+        const { manageDaemon } = await import('./daemon-service.js');
+        await manageDaemon(sub);
       }
       break;
     }
@@ -191,7 +194,7 @@ export async function run(rawArgs) {
     npx @vibe-cafe/vibe-usage daemon stop       Stop background service
     npx @vibe-cafe/vibe-usage daemon restart    Restart background service
     npx @vibe-cafe/vibe-usage reset        Delete all data and re-upload
-    npx @vibe-cafe/vibe-usage reset --local  Delete data for this host only and re-upload
+    npx @vibe-cafe/vibe-usage reset --local  Delete data for this host only and re-upload (--host is a legacy alias)
     npx @vibe-cafe/vibe-usage skill         Install skill for AI coding tools
     npx @vibe-cafe/vibe-usage skill --remove  Remove installed skills
     npx @vibe-cafe/vibe-usage status       Show config and detected tools
@@ -202,7 +205,9 @@ export async function run(rawArgs) {
 `);
       break;
     }
-    default: {
+    case undefined: {
+      // Bare invocation (no command): first run OR a one-shot --key setup →
+      // init; already configured → sync.
       const config = loadConfig();
       if (!config?.apiKey || apiKey) {
         // First run OR user passed --key for a one-shot setup — init.js prints the big header
@@ -214,6 +219,15 @@ export async function run(rawArgs) {
         const { runSync } = await import('./sync.js');
         await runSync();
       }
+      break;
+    }
+    default: {
+      // Compatibility is explicit above: --key, --daemon, reset --host, and
+      // the no-command init/sync behavior remain supported. Unknown words were
+      // never public commands; failing them avoids typo-triggered side effects.
+      console.error(`Unknown command: ${command}`);
+      console.error('Run `vibe-usage help` to see available commands.');
+      process.exit(1);
     }
   }
 }

package/src/parsers/cursor.js

@@ -210,7 +210,9 @@ export async function parse() {
   } catch (err) {
     // Network/timeout → silent skip (avoid noisy daemon logs every 5 min).
     // Auth failure → bubble up so user sees they need to re-login in Cursor.
-    if (err && err.skip) return { buckets: [], sessions: [] };
+    // Tell sync.js this was not a successful empty snapshot so it preserves
+    // Cursor's incremental state instead of pruning it as dead history.
+    if (err && err.skip) return { buckets: [], sessions: [], skipped: true };
     throw err;
   }
   const rows = parseCsv(csv);

package/src/parsers/grok.js

@@ -0,0 +1,325 @@
+import { createReadStream, existsSync, readdirSync, readFileSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { basename, join } from 'node:path';
+import { findGrokDataDirs, getGrokSessionsDir } from '../tools.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+const SOURCE = 'grok';
+
+/**
+ * Grok (Grok Build TUI / CLI) parser.
+ *
+ * Layout (see ~/.grok/docs/user-guide/17-sessions.md):
+ *   $GROK_HOME/sessions/<url-encoded-cwd>/<session-id>/
+ *     summary.json     — cwd, model, timestamps
+ *     updates.jsonl    — ACP session updates; turn_completed carries exact usage
+ *     events.jsonl     — turn_started / turn_ended timing
+ *
+ * GROK_HOME defaults to ~/.grok. Override with GROK_HOME or
+ * VIBE_USAGE_GROK_SESSIONS (tests / relocated session trees).
+ *
+ * Token usage comes from updates.jsonl `turn_completed.usage` (and per-model
+ * `modelUsage` when present). inputTokens is non-cached prompt (total − cache
+ * reads), matching Codex/Copilot so totalTokens does not double-count cache.
+ */
+
+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';
+}
+
+/** Decode a sessions group dirname; fall back to basename after decode. */
+function projectFromGroupDir(groupName, groupPath) {
+  const cwdFile = join(groupPath, '.cwd');
+  if (existsSync(cwdFile)) {
+    try {
+      const raw = readFileSync(cwdFile, 'utf-8').trim();
+      if (raw) return projectFromPath(raw);
+    } catch {
+      // ignore
+    }
+  }
+  try {
+    const decoded = decodeURIComponent(groupName);
+    if (decoded.includes('/') || decoded.includes('\\')) {
+      return projectFromPath(decoded);
+    }
+  } catch {
+    // not URI-encoded
+  }
+  return groupName || 'unknown';
+}
+
+function toDate(value) {
+  if (value == null) return null;
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    // Unix seconds (Grok updates.jsonl) vs milliseconds
+    const ms = value < 1e12 ? value * 1000 : value;
+    const d = new Date(ms);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  if (typeof value === 'string' && value.trim()) {
+    const d = new Date(value);
+    return Number.isNaN(d.getTime()) ? null : d;
+  }
+  return null;
+}
+
+function pushUsageEntry(entries, { model, project, timestamp, usage }) {
+  if (!usage || typeof usage !== 'object') return;
+  if (!timestamp) return;
+
+  const totalInput = Math.max(0, Number(usage.inputTokens) || 0);
+  const cached = Math.max(0, Number(usage.cachedReadTokens) || 0);
+  const output = Math.max(0, Number(usage.outputTokens) || 0);
+  const reasoning = Math.max(0, Number(usage.reasoningTokens) || 0);
+
+  // Prefer exclusive fields when both are present (Codex-style).
+  const inputTokens = Math.max(0, totalInput - cached);
+  const outputTokens = Math.max(0, output - reasoning);
+
+  if (inputTokens + outputTokens + cached + reasoning === 0) return;
+
+  entries.push({
+    source: SOURCE,
+    model: model || 'unknown',
+    project,
+    timestamp,
+    inputTokens,
+    outputTokens,
+    cachedInputTokens: cached,
+    reasoningOutputTokens: reasoning,
+  });
+}
+
+function emitTurnUsage(entries, { usage, project, timestamp, fallbackModel }) {
+  if (!usage || typeof usage !== 'object') return;
+
+  const modelUsage = usage.modelUsage;
+  if (modelUsage && typeof modelUsage === 'object' && Object.keys(modelUsage).length > 0) {
+    for (const [model, mUsage] of Object.entries(modelUsage)) {
+      pushUsageEntry(entries, {
+        model,
+        project,
+        timestamp,
+        usage: mUsage && typeof mUsage === 'object' ? mUsage : usage,
+      });
+    }
+    return;
+  }
+
+  pushUsageEntry(entries, {
+    model: fallbackModel,
+    project,
+    timestamp,
+    usage,
+  });
+}
+
+async function forEachJsonlLine(filePath, onLine) {
+  if (!existsSync(filePath)) return;
+  let stream;
+  try {
+    stream = createReadStream(filePath, { encoding: 'utf-8' });
+  } catch {
+    return;
+  }
+
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      let obj;
+      try {
+        obj = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      onLine(obj);
+    }
+  } catch {
+    // unreadable / truncated mid-write — keep what we have
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+}
+
+function listSessionDirs(sessionsDir) {
+  const results = [];
+  if (!existsSync(sessionsDir)) return results;
+
+  let groups;
+  try {
+    groups = readdirSync(sessionsDir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+
+  for (const group of groups) {
+    if (!group.isDirectory()) continue;
+    // Skip non-project group dirs (e.g. future index folders).
+    const groupPath = join(sessionsDir, group.name);
+    let children;
+    try {
+      children = readdirSync(groupPath, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    const projectFallback = projectFromGroupDir(group.name, groupPath);
+
+    for (const child of children) {
+      if (!child.isDirectory()) continue;
+      const sessionPath = join(groupPath, child.name);
+      // A real session always has summary.json (or at least updates/chat history).
+      if (
+        !existsSync(join(sessionPath, 'summary.json')) &&
+        !existsSync(join(sessionPath, 'updates.jsonl'))
+      ) {
+        continue;
+      }
+      results.push({
+        sessionId: child.name,
+        sessionPath,
+        projectFallback,
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Parse all Grok sessions under the configured sessions root(s).
+ * @returns {Promise<{ buckets: object[], sessions: object[] }>}
+ */
+export async function parse() {
+  const sessionRoots = findGrokDataDirs();
+  // findGrokDataDirs returns sessions dirs; also allow empty → try default once
+  const roots = sessionRoots.length > 0 ? sessionRoots : [getGrokSessionsDir()].filter(existsSync);
+  if (roots.length === 0) return { buckets: [], sessions: [] };
+
+  const entries = [];
+  const sessionEvents = [];
+
+  for (const sessionsDir of roots) {
+    for (const { sessionId, sessionPath, projectFallback } of listSessionDirs(sessionsDir)) {
+      const summary = readJsonSafe(join(sessionPath, 'summary.json')) || {};
+      const cwd = summary.info?.cwd || summary.git_root_dir || null;
+      const project = cwd ? projectFromPath(cwd) : projectFallback;
+      const fallbackModel = summary.current_model_id || 'unknown';
+
+      // Prefer updates.jsonl turn_completed for exact usage + message timings.
+      let sawUserOrAssistant = false;
+      await forEachJsonlLine(join(sessionPath, 'updates.jsonl'), (obj) => {
+        const update = obj?.params?.update;
+        if (!update || typeof update !== 'object') return;
+
+        const kind = update.sessionUpdate;
+        const timestamp = toDate(obj.timestamp);
+
+        if (kind === 'turn_completed' && timestamp) {
+          emitTurnUsage(entries, {
+            usage: update.usage,
+            project,
+            timestamp,
+            fallbackModel,
+          });
+        }
+
+        if (!timestamp) return;
+
+        if (kind === 'user_message_chunk') {
+          sawUserOrAssistant = true;
+          sessionEvents.push({
+            sessionId,
+            source: SOURCE,
+            project,
+            timestamp,
+            role: 'user',
+          });
+        } else if (kind === 'agent_message_chunk' || kind === 'turn_completed') {
+          sawUserOrAssistant = true;
+          sessionEvents.push({
+            sessionId,
+            source: SOURCE,
+            project,
+            timestamp,
+            role: 'assistant',
+          });
+        }
+      });
+
+      // Fallback timing from events.jsonl when updates lack message chunks
+      // (short/aborted sessions, older builds).
+      if (!sawUserOrAssistant) {
+        await forEachJsonlLine(join(sessionPath, 'events.jsonl'), (obj) => {
+          const timestamp = toDate(obj.ts || obj.timestamp);
+          if (!timestamp) return;
+          if (obj.type === 'turn_started') {
+            sessionEvents.push({
+              sessionId,
+              source: SOURCE,
+              project,
+              timestamp,
+              role: 'user',
+            });
+          } else if (obj.type === 'turn_ended' || obj.type === 'first_token') {
+            sessionEvents.push({
+              sessionId,
+              source: SOURCE,
+              project,
+              timestamp,
+              role: 'assistant',
+            });
+          }
+        });
+      }
+
+      // Last-resort session envelope from summary timestamps so a session with
+      // no parseable turns still appears once usage lands later.
+      if (sessionEvents.every((e) => e.sessionId !== sessionId)) {
+        const created = toDate(summary.created_at || summary.info?.created_at);
+        const updated = toDate(summary.updated_at || summary.last_active_at);
+        if (created) {
+          sessionEvents.push({
+            sessionId,
+            source: SOURCE,
+            project,
+            timestamp: created,
+            role: 'user',
+          });
+        }
+        if (updated && (!created || updated.getTime() !== created.getTime())) {
+          sessionEvents.push({
+            sessionId,
+            source: SOURCE,
+            project,
+            timestamp: updated,
+            role: 'assistant',
+          });
+        }
+      }
+    }
+  }
+
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(sessionEvents),
+  };
+}

package/src/parsers/index.js

@@ -6,6 +6,7 @@ import { parse as parseCopilotCli } from './copilot-cli.js';
 import { parse as parseCursor } from './cursor.js';
 import { parse as parseRooCode } from './roo-code.js';
 import { parse as parseGeminiCli } from './gemini-cli.js';
+import { parse as parseGrok } from './grok.js';
 import { parse as parseOpencode } from './opencode.js';
 import { parse as parseOpenclaw } from './openclaw.js';
 import { parse as parseQwenCode } from './qwen-code.js';
@@ -21,24 +22,25 @@ import { parse as parseTraeCli } from './trae-cli.js';
 
 export const parsers = {
   'claude-code': parseClaudeCode,
-  'cline': parseCline,
   'codex': parseCodex,
+  'grok': parseGrok,
   'copilot-cli': parseCopilotCli,
   'cursor': parseCursor,
-  'roo-code': parseRooCode,
   'gemini-cli': parseGeminiCli,
   'opencode': parseOpencode,
   'openclaw': parseOpenclaw,
+  'pi-coding-agent': parsePiCodingAgent,
   'qwen-code': parseQwenCode,
   'kimi-code': parseKimiCode,
   'amp': parseAmp,
   'droid': parseDroid,
   'antigravity': parseAntigravity,
+  'trae-cli': parseTraeCli,
   'hermes': parseHermes,
   'kiro': parseKiro,
-  'pi-coding-agent': parsePiCodingAgent,
+  'cline': parseCline,
+  'roo-code': parseRooCode,
   'zcode': parseZcode,
-  'trae-cli': parseTraeCli,
 };
 
 

package/src/parsers/kimi-code.js

@@ -33,7 +33,8 @@ import { aggregateToBuckets, extractSessions } from './index.js';
 // Current format: ~/.kimi-code
 // ---------------------------------------------------------------------------
 
-const KIMI_CODE_DIR = join(homedir(), '.kimi-code');
+// VIBE_USAGE_KIMI_CODE_DIR overrides the root (test hook).
+const KIMI_CODE_DIR = process.env.VIBE_USAGE_KIMI_CODE_DIR?.trim() || join(homedir(), '.kimi-code');
 const KIMI_CODE_SESSIONS_DIR = join(KIMI_CODE_DIR, 'sessions');
 const KIMI_CODE_SESSION_INDEX = join(KIMI_CODE_DIR, 'session_index.jsonl');
 
@@ -76,6 +77,11 @@ function projectFromBucketName(name) {
   return m ? m[1] : name;
 }
 
+function usageTokens(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
 // Collect every agents/<id>/wire.jsonl under sessions/wd_<...>/session_<...>/.
 function findKimiCodeWireFiles(baseDir) {
   const results = [];
@@ -148,30 +154,45 @@ function parseKimiCode() {
       try { evt = JSON.parse(line); } catch { continue; }
 
       const type = evt.type;
-      // Top-level `time` is integer milliseconds since epoch.
-      const time = typeof evt.time === 'number' ? evt.time : null;
-
-      // Session timing: a user turn vs. anything the model emits.
-      if (type === 'turn.prompt' && evt.origin?.kind === 'user' && time) {
-        const ts = new Date(time);
-        if (!isNaN(ts.getTime())) {
-          sessionEvents.push({ sessionId: wireFile, source: 'kimi-code', project, timestamp: ts, role: 'user' });
+      // Top-level `time` is integer milliseconds since epoch. Validate it:
+      // JSON numbers can overflow to Infinity (e.g. 1e400 parses fine), and
+      // any out-of-range value yields an Invalid Date that later crashes
+      // aggregateToBuckets() (RangeError from toISOString) — one corrupt line
+      // would take down this tool's entire parse.
+      const time = typeof evt.time === 'number' && Number.isFinite(evt.time) ? evt.time : null;
+      const ts = time !== null ? new Date(time) : null;
+      const tsValid = ts !== null && !isNaN(ts.getTime());
+
+      // Session timing: a user turn vs. anything the model emits. All agent
+      // wires under one sessionDir belong to the same logical user session;
+      // grouping by wireFile would create separate zero-user sessions for
+      // subagents instead of attributing their work to the parent turn.
+      if (type === 'turn.prompt' && evt.origin?.kind === 'user') {
+        if (tsValid) {
+          sessionEvents.push({ sessionId: sessionDir, source: 'kimi-code', project, timestamp: ts, role: 'user' });
         }
         continue;
       }
 
       if (type !== 'usage.record') continue;
+      // Every usage.record is a delta. `turn` is the normal successful-step
+      // scope; `session` is used for other real model calls (for example
+      // retry/compaction work), not for a cumulative summary. Count both.
+      // No valid timestamp → can't bucket accurately. Skip instead of stamping
+      // "now": this parser is stateless, so a "now" fallback would re-key the
+      // same record into a fresh 30-min bucket on every sync (duplicates).
+      if (!tsValid) continue;
 
       const usage = evt.usage;
       if (!usage) continue;
 
-      const inputTokens = usage.inputOther || 0;
-      const outputTokens = usage.output || 0;
-      const cachedInputTokens = usage.inputCacheRead || 0;
+      // Cache creation is billed non-cached input, matching the common bucket
+      // model used by the other parsers; cache reads stay in their own field.
+      const inputTokens = usageTokens(usage.inputOther) + usageTokens(usage.inputCacheCreation);
+      const outputTokens = usageTokens(usage.output);
+      const cachedInputTokens = usageTokens(usage.inputCacheRead);
       if (!inputTokens && !outputTokens && !cachedInputTokens) continue;
 
-      const ts = time ? new Date(time) : new Date();
-
       entries.push({
         source: 'kimi-code',
         model: evt.model || 'unknown',
@@ -185,9 +206,7 @@ function parseKimiCode() {
 
       // Each usage.record marks an assistant step completing — use it as an
       // assistant timing event so active-time math has both sides of a turn.
-      if (time && !isNaN(ts.getTime())) {
-        sessionEvents.push({ sessionId: wireFile, source: 'kimi-code', project, timestamp: ts, role: 'assistant' });
-      }
+      sessionEvents.push({ sessionId: sessionDir, source: 'kimi-code', project, timestamp: ts, role: 'assistant' });
     }
   }
 
@@ -198,7 +217,8 @@ function parseKimiCode() {
 // Legacy format: ~/.kimi  (kept for users who haven't migrated to ~/.kimi-code)
 // ---------------------------------------------------------------------------
 
-const KIMI_DIR = join(homedir(), '.kimi');
+// VIBE_USAGE_KIMI_DIR overrides the legacy root (test hook).
+const KIMI_DIR = process.env.VIBE_USAGE_KIMI_DIR?.trim() || join(homedir(), '.kimi');
 const KIMI_SESSIONS_DIR = join(KIMI_DIR, 'sessions');
 const KIMI_WORKDIRS_JSON = join(KIMI_DIR, 'kimi.json');
 const KIMI_CONFIG_TOML = join(KIMI_DIR, 'config.toml');

package/src/reset.js

@@ -1,8 +1,9 @@
 import { createInterface } from 'node:readline';
 import { hostname as getHostname } from 'node:os';
-import { loadConfig, saveConfig } from './config.js';
+import { loadConfig } from './config.js';
 import { deleteAllData } from './api.js';
 import { runSync } from './sync.js';
+import { clearState } from './state.js';
 import { success, failure, arrow, link, dim } from './output.js';
 
 function prompt(question) {
@@ -15,19 +16,32 @@ function prompt(question) {
   });
 }
 
-export async function runReset(args = []) {
-  const hostOnly = args.includes('--local');
+export async function runReset(args = [], deps = {}) {
+  // Injectable for tests — the production defaults hit readline, the network,
+  // and the real sync pipeline.
+  const ask = deps.prompt ?? prompt;
+  const deleteRemote = deps.deleteAllData ?? deleteAllData;
+  const resync = deps.runSync ?? runSync;
+
+  // --host was the original public spelling before --local replaced it.
+  // Keep the old flag as an alias so existing reset scripts stay safe: losing
+  // the filter would turn a host-only reset into a destructive account-wide
+  // reset.
+  const hostOnly = args.includes('--local') || args.includes('--host');
   const config = loadConfig();
   if (!config?.apiKey) {
     console.error(failure('尚未配置，请先运行 `npx @vibe-cafe/vibe-usage init`。'));
     process.exit(1);
   }
 
-  const currentHost = getHostname().replace(/\.local$/, '');
+  // Target the hostname persisted at init — the same one sync.js uploads
+  // under. A fresh os.hostname() can have drifted since (macOS mDNS adds -2
+  // suffixes), which would delete zero rows, or another machine's rows.
+  const currentHost = config.hostname || getHostname().replace(/\.local$/, '');
   const apiUrl = config.apiUrl || 'https://vibecafe.ai';
 
   if (hostOnly) {
-    const answer = await prompt(`将删除当前机器（${currentHost}）的用量数据并从本地日志重新上传，继续? (y/N) `);
+    const answer = await ask(`将删除当前机器（${currentHost}）的用量数据并从本地日志重新上传，继续? (y/N) `);
     if (answer.toLowerCase() !== 'y') {
       console.log(dim('已取消。'));
       return;
@@ -35,7 +49,7 @@ export async function runReset(args = []) {
 
     console.log(dim(`  正在删除 ${currentHost} 的云端数据...`));
     try {
-      const result = await deleteAllData(apiUrl, config.apiKey, { hostname: currentHost });
+      const result = await deleteRemote(apiUrl, config.apiKey, { hostname: currentHost });
       console.log(success(`已删除 ${result.deleted} buckets · ${result.sessions ?? 0} sessions`));
     } catch (err) {
       if (err.message === 'UNAUTHORIZED') {
@@ -46,7 +60,7 @@ export async function runReset(args = []) {
       process.exit(1);
     }
   } else {
-    const answer = await prompt('将删除所有用量数据并从本地日志重新上传，继续? (y/N) ');
+    const answer = await ask('将删除所有用量数据并从本地日志重新上传，继续? (y/N) ');
     if (answer.toLowerCase() !== 'y') {
       console.log(dim('已取消。'));
       return;
@@ -54,7 +68,7 @@ export async function runReset(args = []) {
 
     console.log(dim('  正在删除所有云端数据...'));
     try {
-      const result = await deleteAllData(apiUrl, config.apiKey);
+      const result = await deleteRemote(apiUrl, config.apiKey);
       console.log(success(`已删除 ${result.deleted} buckets · ${result.sessions ?? 0} sessions`));
     } catch (err) {
       if (err.message === 'UNAUTHORIZED') {
@@ -66,13 +80,15 @@ export async function runReset(args = []) {
     }
   }
 
-  // Clear local state (legacy — no state files needed for current parsers)
-  config.lastSync = null;
-  saveConfig(config);
+  // The remote rows are gone, so every local item must count as "changed" on
+  // the re-sync below. Without this, sync.js's incremental diff matches every
+  // item against state.json and uploads zero bytes — the deleted data would
+  // never come back.
+  clearState();
 
   console.log();
   console.log(dim('  从本地日志重新同步...'));
-  await runSync();
+  await resync();
 
   console.log();
   console.log(`${arrow('Dashboard')} ${link(`${apiUrl}/usage`)}`);

package/src/skill.js

@@ -68,7 +68,7 @@ Track and answer questions about the user's AI coding token spend via [Vibe Usag
 - \`summary\` 读 \`~/.vibe-usage/config.json\` 里已有的 API key，不需要用户额外输入
 - summary 输出已是 markdown，**原样展示，不要复述**
 - 用户没装过 vibe-usage？提示运行 \`npx @vibe-cafe/vibe-usage\` 先用浏览器登录链接账号
-- 支持的工具：Claude Code, Codex CLI, Copilot CLI, Gemini CLI, OpenCode, OpenClaw, Qwen Code, Kimi Code, Amp, Droid 等
+- 支持的工具：Claude Code, Codex, Grok 等
 `;
 
 export async function runSkill(args = []) {

package/src/sync.js

@@ -34,12 +34,23 @@ export async function runSync({ throws = false, quiet = false } = {}) {
   const allBuckets = [];
   const allSessions = [];
   const parserResults = [];
+  // Sources whose parser ran to completion this sync. pruneState() below is
+  // scoped to these so a transient parser failure doesn't evict that tool's
+  // state and force a full re-upload next run.
+  const okSources = new Set();
 
   for (const [source, parse] of Object.entries(parsers)) {
     try {
       const result = 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');
+      }
+      // 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) {
@@ -52,6 +63,14 @@ export async function runSync({ throws = false, quiet = false } = {}) {
   }
 
   if (allBuckets.length === 0 && allSessions.length === 0) {
+    // Successful parsers emitted no live items. Prune their old keys even on
+    // this fast path; otherwise deleting the final local log would leave dead
+    // state entries forever. Failed-parser sources remain protected.
+    const state = loadState();
+    const before = Object.keys(state.buckets).length + Object.keys(state.sessions).length;
+    pruneState(state, new Set(), new Set(), okSources);
+    const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
+    if (pruned > 0) saveState(state);
     if (!quiet) console.log(dim('暂无新数据。'));
     return 0;
   }
@@ -135,7 +154,7 @@ export async function runSync({ throws = false, quiet = false } = {}) {
   // 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);
+  pruneState(state, liveBucketKeys, liveSessionKeys, okSources);
   const pruned = before - (Object.keys(state.buckets).length + Object.keys(state.sessions).length);
   if (pruned > 0) saveState(state);
 
@@ -241,4 +260,3 @@ export async function runSync({ throws = false, quiet = false } = {}) {
     process.exit(1);
   }
 }
-

package/src/tools.js

@@ -136,37 +136,47 @@ export function findTraeCliDataDirs() {
   return [join(xdgCacheHome, 'trae-cli', 'sessions')].filter(existsSync);
 }
 
+/** Grok home: GROK_HOME env (same as the Grok CLI) or ~/.grok. */
+export function getGrokHome() {
+  const envHome = process.env.GROK_HOME?.trim();
+  if (envHome) {
+    return envHome.startsWith('~') ? join(homedir(), envHome.slice(1)) : envHome;
+  }
+  return join(homedir(), '.grok');
+}
+
+export function getGrokSessionsDir() {
+  const testDir = process.env.VIBE_USAGE_GROK_SESSIONS?.trim();
+  if (testDir) return testDir;
+  return join(getGrokHome(), 'sessions');
+}
+
+// Detect Grok when sessions/ exists under GROK_HOME (or the test override).
+export function findGrokDataDirs() {
+  const testDir = process.env.VIBE_USAGE_GROK_SESSIONS?.trim();
+  if (testDir) return [testDir].filter(existsSync);
+  return [join(getGrokHome(), 'sessions')].filter(existsSync);
+}
+
 export const TOOLS = [
-  {
-    name: 'Trae CLI',
-    id: 'trae-cli',
-    dataDir: join(homedir(), 'Library', 'Caches', 'trae-cli', 'sessions'),
-    detectDataDirs: findTraeCliDataDirs,
-  },
-  {
-    name: 'Antigravity',
-    id: 'antigravity',
-    dataDir: join(homedir(), '.gemini', 'antigravity'),
-    detectDataDirs: findAntigravityDataDirs,
-  },
   {
     name: 'Claude Code',
     id: 'claude-code',
     dataDir: join(homedir(), '.claude', 'projects'),
     detectDataDirs: findClaudeCodeDataDirs,
   },
-  {
-    name: 'Cline',
-    id: 'cline',
-    dataDir: join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev'),
-    detectDataDirs: findClineDataDirs,
-  },
   {
     name: 'Codex CLI',
     id: 'codex',
     dataDir: join(homedir(), '.codex', 'sessions'),
     detectDataDirs: findCodexDataDirs,
   },
+  {
+    name: 'Grok',
+    id: 'grok',
+    dataDir: join(homedir(), '.grok', 'sessions'),
+    detectDataDirs: findGrokDataDirs,
+  },
   {
     name: 'GitHub Copilot CLI',
     id: 'copilot-cli',
@@ -221,6 +231,18 @@ export const TOOLS = [
     id: 'droid',
     dataDir: join(homedir(), '.factory', 'sessions'),
   },
+  {
+    name: 'Antigravity',
+    id: 'antigravity',
+    dataDir: join(homedir(), '.gemini', 'antigravity'),
+    detectDataDirs: findAntigravityDataDirs,
+  },
+  {
+    name: 'Trae CLI',
+    id: 'trae-cli',
+    dataDir: join(homedir(), 'Library', 'Caches', 'trae-cli', 'sessions'),
+    detectDataDirs: findTraeCliDataDirs,
+  },
   {
     name: 'Hermes',
     id: 'hermes',
@@ -231,6 +253,12 @@ export const TOOLS = [
     id: 'kiro',
     dataDir: getKiroAgentPath(),
   },
+  {
+    name: 'Cline',
+    id: 'cline',
+    dataDir: join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev'),
+    detectDataDirs: findClineDataDirs,
+  },
   {
     name: 'Roo Code',
     id: 'roo-code',