@vibe-cafe/vibe-usage 0.10.28 → 0.10.29

package/README.md

@@ -64,6 +64,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | Claude Code + Claude Desktop Code/Cowork | Claude Code data in `~/.claude/projects/` (tokens + sessions) and `~/.claude/transcripts/` (sessions only), plus Claude Desktop Cowork's per-session `.claude/projects/` directories. Also scans `$CLAUDE_CONFIG_DIR` and data-bearing `~/.claude-*` profiles. All variants use the existing `claude-code` source; the parser selects the most complete copy of each session so shared/copied transcripts are not counted twice. Logs are streamed and cache creation tokens are included in input usage. |
 | Cindy | Per-owner SQLite ledgers in the two regional Electron user-data roots: macOS `~/Library/Application Support/{CindyGlobal,Cindy}/cindy-*.db`, Windows `%APPDATA%\{CindyGlobal,Cindy}\cindy-*.db`, Linux `${XDG_CONFIG_HOME:-~/.config}/{CindyGlobal,Cindy}/cindy-*.db` (fixture/relocation override: `VIBE_USAGE_CINDY_DIRS`). Cindy-launched Claude Code already writes ordinary `~/.claude` transcripts, so it remains attributed to **Claude Code** and is not read again. Cindy's otherwise-private Codex and Pi daily/model ledger rows augment the existing **Codex** and **pi** sources. Currency rows are summed and cache creation joins input; chat messages, credentials, costs, and owner ids are never selected. The ledger adds token buckets only, without project or session timing. |
 | Codex CLI | `$CODEX_HOME/sessions/` and `$CODEX_HOME/archived_sessions/` (default `~/.codex`), plus an optional temporary `--extra-codex-home`, legacy `codexExtraHome`, or explicitly added Codex/Multica roots; a versioned local index avoids re-reading unchanged rollouts and reads only safe append tails for ordinary sessions, while fork/sub-agent replay matching, duplicate suppression, and live/archive/cross-root deduplication retain their existing semantics |
+| Cola | `~/.cola/sessions/<scope>/*.jsonl` (or `$COLA_DATA_DIR/sessions/`), verified with Cola 1.4.4. Reads assistant token usage and session timing through the shared Pi reader; cache writes join input, cache reads remain separate, and reasoning is split from output. Copied transcripts with new session headers are deduplicated using the original record metadata and attributed to the earliest available session copy. Project names come from `cwd`, never channel/scope names. |
 | Grok | `$GROK_HOME/sessions/<encoded-cwd>/<session-id>/` (default `~/.grok`) plus explicitly added Grok Homes; token usage from `updates.jsonl` `turn_completed.usage` (per-model `modelUsage`, cache reads, reasoning); project from `summary.json` cwd; copied sessions keep the more complete local record |
 | GitHub Copilot CLI | `~/.copilot/session-state/*/events.jsonl` |
 | CraftAgent | `~/.craft-agent/workspaces/*/sessions/*/.pi-sessions/*.jsonl`; honors `$CRAFT_AGENT_DIR` / `$CRAFTAGENT_DIR`; cache writes are included in input usage |
@@ -81,7 +82,7 @@ npx @vibe-cafe/vibe-usage help --all   # Full help (plain `help` shows the short
 | Amp | `~/.local/share/amp/threads/`; cache-creation tokens are included in input usage |
 | Droid | `~/.factory/sessions/` |
 | DeepSeek Harness | `$DSH_HOME/sessions/` (default `~/.dsh`, fixture/relocation override: `VIBE_USAGE_DSH_SESSIONS`). Reads V0–V3 logs, including `session.v3.jsonl.zstd` from DSH `0.1.5-alpha.2`, with multi-frame Zstandard support (Node ≥ 22.15 built-in, `zstd` CLI fallback) and plain JSONL support. Each session uses its highest `session[.vN].jsonl[.zstd]` generation once, so frozen pre-migration logs are not double-counted. Usage comes from `assistant/message`: cache writes join uncached input, cache reads remain separate, and reasoning is split out of inclusive output. Fork history uses V0/V1 `seedLength` or V2/V3's last `session/end-seed` tagged `inherited: true`, and is skipped only when the parent copy confirms it; missing parents retain the sole local history. Unknown versions warn and protect sync state. |
-| Hermes | `$HERMES_HOME/state.db` (default `~/.hermes/state.db`) + `profiles/<name>/state.db` (SQLite, multi-profile). Cache writes join input; reasoning is separated from inclusive output. Usage is currently a cumulative session total attributed to session start: a session spanning several days does **not** yet provide an accurate daily breakdown. |
+| Hermes (CLI / Desktop) | `<home>/state.db` + `<home>/profiles/<name>/state.db` (SQLite, multi-profile). Home: `$HERMES_HOME`, otherwise `~/.hermes` on macOS/Linux or `%LOCALAPPDATA%\hermes` on Windows (falls back to an existing `~/.hermes` only when the Windows native root is absent). Cache writes join input; reasoning is separated from inclusive output. Usage is currently a cumulative session total attributed to session start: a session spanning several days does **not** yet provide an accurate daily breakdown. |
 | Kiro | Kiro CLI native event streams `~/.kiro/sessions/cli/*.jsonl` (estimated tokens from message text: input = prompt + tool results, output = reply + tool calls, reasoning = thinking, cacheRead = re-sent context; thinking-block signatures excluded). Falls back to `~/Library/Application Support/kiro-cli/data.sqlite3` / `~/.local/share/kiro-cli/data.sqlite3` + optional `~/.kiro_sessions/*.json` archives, then IDE `q-client.log` whole-credit deltas as `kiro-credits` (floored cumulative diff — the server stores token counts as bigint); legacy IDE `dev_data/devdata.sqlite` token telemetry is opt-in with `VIBE_USAGE_KIRO_LEGACY_TOKENS=1` |
 | Cline | Standalone `~/.cline/` plus `<host>/User/globalStorage/saoudrizwan.claude-dev/` across VSCode-fork hosts; migrated copies are deduplicated and empty leftover extension stores no longer count as installed |
 | Roo Code | `<host>/User/globalStorage/rooveterinaryinc.roo-cline/{tasks/_index.json,tasks/<id>/{history_item,ui_messages}.json}` (walks all VSCode-fork hosts) |

package/package.json

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

package/src/cola-roots.js

@@ -0,0 +1,16 @@
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function getColaSessionsDir() {
+  return join(process.env.COLA_DATA_DIR ?? join(homedir(), '.cola'), 'sessions');
+}
+
+export function findColaDataDirs() {
+  const dir = getColaSessionsDir();
+  try {
+    return statSync(dir).isDirectory() ? [dir] : [];
+  } catch {
+    return [];
+  }
+}

package/src/daemon-service.js

@@ -115,6 +115,8 @@ function escapeXml(value) {
 // launchd/systemd unit that inherits nothing, so anything the parsers read for
 // discovery has to be captured into the unit at install time.
 const PRESERVED_SERVICE_ENV = [
+  'COLA_DATA_DIR',
+  'HERMES_HOME',
   'MCODE_HOME',
   'MIMOCODE_HOME',
   'MIMOCODE_DB',

package/src/hermes-roots.js

@@ -0,0 +1,59 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+// Match the Hermes CLI/Desktop layout. Windows installers use LOCALAPPDATA;
+// Desktop falls back to an existing ~/.hermes only before that native root exists.
+export function getHermesHome({ onError = () => {} } = {}) {
+  const explicit = process.env.HERMES_HOME?.trim();
+  if (explicit) return explicit;
+
+  const legacy = join(homedir(), '.hermes');
+  if (process.platform !== 'win32') return legacy;
+
+  const localAppData = process.env.LOCALAPPDATA?.trim() || join(homedir(), 'AppData', 'Local');
+  const native = join(localAppData, 'hermes');
+  return !statIfPresent(native, onError)?.isDirectory()
+    && statIfPresent(legacy, onError)?.isDirectory() ? legacy : native;
+}
+
+function statIfPresent(path, onError) {
+  try {
+    return statSync(path);
+  } catch (err) {
+    if (err.code !== 'ENOENT') onError(err);
+    return null;
+  }
+}
+
+// Parsing must fail on unreadable stores: a partial result would allow sync
+// to prune that profile's previous state. Detection alone is best-effort.
+export function discoverHermesDatabases({ onError = err => { throw err; } } = {}) {
+  const home = getHermesHome({ onError });
+  const dbs = [];
+
+  const defaultDb = join(home, 'state.db');
+  if (statIfPresent(defaultDb, onError)) dbs.push({ path: defaultDb, profile: 'default' });
+
+  const profilesDir = join(home, 'profiles');
+  let entries;
+  try {
+    entries = readdirSync(profilesDir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code !== 'ENOENT') onError(err);
+    return dbs;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const profileDb = join(profilesDir, entry.name, 'state.db');
+    if (statIfPresent(profileDb, onError)?.isFile()) {
+      dbs.push({ path: profileDb, profile: entry.name });
+    }
+  }
+
+  return dbs;
+}
+
+export function findHermesDataDirs() {
+  return discoverHermesDatabases({ onError: () => {} }).map(db => db.path);
+}

package/src/parsers/cola.js

@@ -0,0 +1,17 @@
+import { getColaSessionsDir } from '../cola-roots.js';
+import { parsePiSessionJsonl } from './pi-session-jsonl.js';
+
+/** Cola 1.4.4 writes Pi-compatible transcripts under sessions/<scope>/. */
+export async function parse() {
+  const result = await parsePiSessionJsonl({
+    source: 'cola',
+    sessionsDirs: [getColaSessionsDir()],
+    // Scope slugs may identify channels or people, not projects. The session
+    // header's cwd supplies a project when present; otherwise keep unknown.
+    projectFromPath: () => 'unknown',
+    deduplicateCopiedSessions: true,
+  });
+  // A missing part of the store must not overwrite a complete uploaded bucket
+  // with a partial sum, even when several projects are hidden behind unknown.
+  return result.skipped ? { ...result, buckets: [], sessions: [] } : result;
+}

package/src/parsers/hermes.js

@@ -1,24 +1,22 @@
-import { existsSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
+import { discoverHermesDatabases } from '../hermes-roots.js';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { toCount } from './fs-utils.js';
 import { queryDbJson, sqliteUnavailableError, isSqliteUnavailableError } from './sqlite.js';
 
-const HERMES_HOME = process.env.HERMES_HOME || join(homedir(), '.hermes');
-
 /**
  * Parse Hermes Agent usage data from its SQLite databases.
  *
  * Hermes supports multiple profiles — the default profile lives at
- * ~/.hermes/state.db, while named profiles live at ~/.hermes/profiles/<name>/state.db.
+ * <home>/state.db, while named profiles live at <home>/profiles/<name>/state.db.
+ * The home is shared by CLI/Desktop: ~/.hermes on macOS/Linux, LOCALAPPDATA/hermes
+ * on Windows, or an explicit HERMES_HOME.
  * Each profile is an independent HERMES_HOME with its own state.db, so we scan all of them.
  *
  * Token buckets come from the sessions table (cumulative per-session totals).
  * Session timing comes from the messages table (per-message role + timestamp).
  */
 export async function parse() {
-  const dbs = discoverDbPaths(HERMES_HOME);
+  const dbs = discoverHermesDatabases();
   if (dbs.length === 0) return { buckets: [], sessions: [] };
 
   const entries = [];
@@ -68,19 +66,15 @@ export async function parse() {
       });
     }
 
-    let messageRows;
-    try {
-      messageRows = queryDb(dbPath, `SELECT
-        session_id as sessionId,
-        role,
-        timestamp
-        FROM messages
-        WHERE role IN ('user', 'assistant')
-        ORDER BY timestamp`);
-    } catch {
-      // Messages query failed for this profile — skip its session events
-      continue;
-    }
+    // A failed query is not an empty session history. Let sync protect this
+    // source's previous state instead of uploading/pruning a partial result.
+    const messageRows = queryDb(dbPath, `SELECT
+      session_id as sessionId,
+      role,
+      timestamp
+      FROM messages
+      WHERE role IN ('user', 'assistant')
+      ORDER BY timestamp`);
 
     for (const row of messageRows) {
       const timestamp = new Date(row.timestamp * 1000);
@@ -99,34 +93,6 @@ export async function parse() {
   return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }
 
-function discoverDbPaths(home) {
-  const dbs = [];
-
-  const defaultDb = join(home, 'state.db');
-  if (existsSync(defaultDb)) dbs.push({ path: defaultDb, profile: 'default' });
-
-  const profilesDir = join(home, 'profiles');
-  if (existsSync(profilesDir)) {
-    let entries;
-    try {
-      entries = readdirSync(profilesDir, { withFileTypes: true });
-    } catch {
-      return dbs;
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const profileDb = join(profilesDir, entry.name, 'state.db');
-      try {
-        if (statSync(profileDb).isFile()) dbs.push({ path: profileDb, profile: entry.name });
-      } catch {
-        // missing or unreadable — skip
-      }
-    }
-  }
-
-  return dbs;
-}
-
 function queryDb(dbPath, sql) {
   return queryDbJson(dbPath, sql);
 }

package/src/parsers/index.js

@@ -23,6 +23,7 @@ import { parse as parseKiro } from './kiro.js';
 import { parse as parseMcode } from './mcode.js';
 import { parse as parseMimocode } from './mimocode.js';
 import { parse as parsePiCodingAgent } from './pi-coding-agent.js';
+import { parse as parseCola } from './cola.js';
 import { parse as parseZcode } from './zcode.js';
 import { parse as parseTraeCli } from './trae-cli.js';
 import { parse as parseWorkbuddy } from './workbuddy.js';
@@ -31,6 +32,7 @@ import { parseQoder, parseQoderCn } from './qoder.js';
 export const parsers = {
   'claude-code': parseClaudeCode,
   'codex': parseCodex,
+  'cola': parseCola,
   'grok': parseGrok,
   'copilot-cli': parseCopilotCli,
   'craft-agent': parseCraftAgent,

package/src/parsers/pi-session-jsonl.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
+import { readdirSync, readFileSync, realpathSync } from 'node:fs';
 import { basename, join, relative } from 'node:path';
 import { aggregateToBuckets, extractSessions } from './aggregate.js';
 import { projectFromCwd, toCount } from './fs-utils.js';
@@ -11,12 +11,13 @@ function warn(ctx, message) {
 }
 
 function findJsonlFiles(dir, includeFile, ctx) {
-  if (!existsSync(dir)) return [];
   let children;
   try {
     children = readdirSync(dir, { withFileTypes: true });
   } catch (err) {
-    warn(ctx, `${ctx.source}: cannot read directory ${dir}: ${err.message}`);
+    if (err.code !== 'ENOENT') {
+      warn(ctx, `${ctx.source}: cannot read directory ${dir}: ${err.message}`);
+    }
     return [];
   }
 
@@ -56,6 +57,7 @@ export async function parsePiSessionJsonl({
   sessionsDirs,
   includeFile = () => true,
   projectFromPath = projectFromFirstDir,
+  deduplicateCopiedSessions = false,
 }) {
   const ctx = { source, warnings: [], incomplete: false };
   const entriesById = new Map();
@@ -63,6 +65,7 @@ export async function parsePiSessionJsonl({
   const eventsById = new Map();
   const anonymousEvents = [];
   const seenFiles = new Set();
+  const recordOwners = new Map();
 
   for (const sessionsDir of sessionsDirs) {
     for (const filePath of findJsonlFiles(sessionsDir, includeFile, ctx)) {
@@ -80,6 +83,8 @@ export async function parsePiSessionJsonl({
 
       let sessionId = basename(filePath, '.jsonl');
       let project = projectFromPath(filePath, sessionsDir) || 'unknown';
+      let sessionStartedAt = Infinity;
+      let seenHeader = false;
 
       for (const line of content.split('\n')) {
         if (!line.trim()) continue;
@@ -89,18 +94,40 @@ export async function parsePiSessionJsonl({
         } catch {
           continue;
         }
+        if (!obj || typeof obj !== 'object') continue;
 
         if (obj.type === 'session') {
+          if (deduplicateCopiedSessions && seenHeader) continue;
+          seenHeader = true;
           if (obj.id) sessionId = String(obj.id);
           if (obj.cwd) project = projectFromCwd(obj.cwd);
+          const startedAt = new Date(obj.timestamp).getTime();
+          sessionStartedAt = Number.isFinite(startedAt) ? startedAt : Infinity;
           continue;
         }
         if (obj.type !== 'message' || !obj.message) continue;
 
         const message = obj.message;
-        const timestamp = new Date(obj.timestamp || message.timestamp || 0);
+        const rawTimestamp = obj.timestamp || message.timestamp;
+        const timestamp = new Date(rawTimestamp || 0);
         if (Number.isNaN(timestamp.getTime())) continue;
-        const recordId = obj.id ? `${sessionId}:${obj.id}` : null;
+        const model = message.model || message.modelId || obj.model || obj.modelId || 'unknown';
+        // Cola copies a transcript with a new session header but unchanged
+        // records. Its short message ids are only unique within a session, so
+        // cross-session dedup also requires time, parent, role, and model.
+        // All existing Pi-family callers retain sessionId:id identities.
+        const recordId = !obj.id ? null : deduplicateCopiedSessions && rawTimestamp
+          ? JSON.stringify([obj.id, timestamp.getTime(), obj.parentId ?? null, message.role, model])
+          : `${sessionId}:${obj.id}`;
+
+        if (deduplicateCopiedSessions && recordId) {
+          const owner = recordOwners.get(recordId);
+          if (!owner || sessionStartedAt < owner.startedAt
+            || (sessionStartedAt === owner.startedAt && sessionId < owner.sessionId)
+            || (sessionStartedAt === owner.startedAt && sessionId === owner.sessionId && canonical < owner.filePath)) {
+            recordOwners.set(recordId, { sessionId, project, startedAt: sessionStartedAt, filePath: canonical });
+          }
+        }
 
         if (message.role === 'user' || message.role === 'assistant' || message.role === 'toolResult') {
           const event = {
@@ -130,7 +157,7 @@ export async function parsePiSessionJsonl({
 
         const entry = {
           source,
-          model: message.model || message.modelId || obj.model || obj.modelId || 'unknown',
+          model,
           project,
           timestamp,
           inputTokens,
@@ -150,9 +177,18 @@ export async function parsePiSessionJsonl({
 
   const entries = [
     ...anonymousEntries,
-    ...[...entriesById.values()].map(({ entry }) => entry),
+    ...[...entriesById].map(([id, { entry }]) => {
+      const owner = recordOwners.get(id);
+      return owner ? { ...entry, project: owner.project } : entry;
+    }),
+  ];
+  const events = [
+    ...anonymousEvents,
+    ...[...eventsById].map(([id, event]) => {
+      const owner = recordOwners.get(id);
+      return owner ? { ...event, sessionId: owner.sessionId, project: owner.project } : event;
+    }),
   ];
-  const events = [...anonymousEvents, ...eventsById.values()];
   return {
     buckets: aggregateToBuckets(entries),
     sessions: extractSessions(events),

package/src/tools.js

@@ -11,7 +11,9 @@ import {
   grokSessionsDir,
 } from './extra-roots.js';
 import { findClineDataDirs } from './cline-roots.js';
+import { findColaDataDirs, getColaSessionsDir } from './cola-roots.js';
 import { findCraftDataDirs } from './craft-roots.js';
+import { findHermesDataDirs, getHermesHome } from './hermes-roots.js';
 import { findOmpDataDirs, findPiDataDirs } from './pi-roots.js';
 import { findQoderDataDirs, getQoderProjectsDir } from './qoder-roots.js';
 import { findWorkbuddyDataDirs } from './workbuddy-roots.js';
@@ -266,6 +268,12 @@ export const TOOLS = [
       findCodexDataDirs(codexExtraHome, extraRootList(extraRoots?.codex))
     ),
   },
+  {
+    name: 'Cola',
+    id: 'cola',
+    dataDir: getColaSessionsDir(),
+    detectDataDirs: findColaDataDirs,
+  },
   {
     name: 'Grok',
     id: 'grok',
@@ -396,7 +404,8 @@ export const TOOLS = [
   {
     name: 'Hermes',
     id: 'hermes',
-    dataDir: join(homedir(), '.hermes', 'state.db'),
+    dataDir: join(getHermesHome(), 'state.db'),
+    detectDataDirs: findHermesDataDirs,
   },
   {
     name: 'Kiro',