@vibe-cafe/vibe-usage 0.7.7 → 0.7.9

package/README.md

@@ -57,14 +57,14 @@ npx @vibe-cafe/vibe-usage status       # Show config & detected tools
 | Kimi Code | `~/.kimi/sessions/` |
 | Amp | `~/.local/share/amp/threads/` |
 | Droid | `~/.factory/sessions/` |
-| Hermes | `~/.hermes/state.db` (SQLite) |
+| Hermes | `~/.hermes/state.db` + `~/.hermes/profiles/<name>/state.db` (SQLite, multi-profile) |
 
 ## How It Works
 
 - 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
+- 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)
 - For continuous syncing, use `npx @vibe-cafe/vibe-usage daemon` or the [Vibe Usage Mac app](https://github.com/vibe-cafe/vibe-usage-app)
 

package/package.json

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

package/src/api.js

@@ -1,9 +1,11 @@
 import https from 'node:https';
 import http from 'node:http';
 import { URL } from 'node:url';
+import { gzipSync } from 'node:zlib';
 
 const MAX_RETRIES = 3;
 const INITIAL_DELAY = 1000;
+const GZIP_MIN_BYTES = 1024;
 
 export async function ingest(apiUrl, apiKey, buckets, opts, sessions) {
   let lastError;
@@ -30,18 +32,23 @@ function _send(apiUrl, apiKey, buckets, onProgress, sessions) {
     const url = new URL('/api/usage/ingest', apiUrl);
     const payload = { buckets };
     if (sessions && sessions.length > 0) payload.sessions = sessions;
-    const body = Buffer.from(JSON.stringify(payload));
+    const raw = Buffer.from(JSON.stringify(payload));
+    const useGzip = raw.length >= GZIP_MIN_BYTES;
+    const body = useGzip ? gzipSync(raw) : raw;
     const totalBytes = body.length;
     const mod = url.protocol === 'https:' ? https : http;
 
+    const headers = {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Length': totalBytes,
+    };
+    if (useGzip) headers['Content-Encoding'] = 'gzip';
+
     const req = mod.request(url, {
       method: 'POST',
       timeout: 60_000,
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-        'Content-Length': totalBytes,
-      },
+      headers,
     }, (res) => {
       let data = '';
       res.on('data', (chunk) => { data += chunk; });

package/src/parsers/hermes.js

@@ -1,95 +1,129 @@
 import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets, extractSessions } from './index.js';
 
 const HERMES_HOME = process.env.HERMES_HOME || join(homedir(), '.hermes');
-const DB_PATH = join(HERMES_HOME, 'state.db');
 
 /**
- * Parse Hermes Agent usage data from its SQLite database (~/.hermes/state.db).
+ * 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.
+ * 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() {
-  if (!existsSync(DB_PATH)) return { buckets: [], sessions: [] };
-
-  let sessionRows;
-  try {
-    sessionRows = queryDb(`SELECT
-      id,
-      model,
-      started_at as startedAt,
-      input_tokens as inputTokens,
-      output_tokens as outputTokens,
-      cache_read_tokens as cacheReadTokens,
-      reasoning_tokens as reasoningTokens
-      FROM sessions
-      WHERE input_tokens > 0 OR output_tokens > 0`);
-  } catch (err) {
-    if (err.message && err.message.includes('ENOENT')) {
-      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Hermes data.');
-    }
-    throw err;
-  }
+  const dbs = discoverDbPaths(HERMES_HOME);
+  if (dbs.length === 0) return { buckets: [], sessions: [] };
 
   const entries = [];
-  for (const row of sessionRows) {
-    // started_at is a Unix timestamp (float)
-    const timestamp = new Date(row.startedAt * 1000);
-    if (isNaN(timestamp.getTime())) continue;
-
-    // Hermes stores input_tokens exclusive of cache (Anthropic-style semantics)
-    entries.push({
-      source: 'hermes',
-      model: row.model || 'unknown',
-      project: 'unknown',
-      timestamp,
-      inputTokens: row.inputTokens || 0,
-      outputTokens: row.outputTokens || 0,
-      cachedInputTokens: row.cacheReadTokens || 0,
-      reasoningOutputTokens: row.reasoningTokens || 0,
-    });
-  }
+  const sessionEvents = [];
 
-  // Session events from messages table for active time calculation
-  let messageRows;
-  try {
-    messageRows = queryDb(`SELECT
-      session_id as sessionId,
-      role,
-      timestamp
-      FROM messages
-      WHERE role IN ('user', 'assistant')
-      ORDER BY timestamp`);
-  } catch {
-    // Messages query failed — return buckets only
-    return { buckets: aggregateToBuckets(entries), sessions: [] };
-  }
+  for (const { path: dbPath, profile } of dbs) {
+    let sessionRows;
+    try {
+      sessionRows = queryDb(dbPath, `SELECT
+        id,
+        model,
+        started_at as startedAt,
+        input_tokens as inputTokens,
+        output_tokens as outputTokens,
+        cache_read_tokens as cacheReadTokens,
+        reasoning_tokens as reasoningTokens
+        FROM sessions
+        WHERE input_tokens > 0 OR output_tokens > 0`);
+    } catch (err) {
+      if (err.message && err.message.includes('ENOENT')) {
+        throw new Error('sqlite3 CLI not found. Install sqlite3 to sync Hermes data.');
+      }
+      throw err;
+    }
 
-  const sessionEvents = [];
-  for (const row of messageRows) {
-    const timestamp = new Date(row.timestamp * 1000);
-    if (isNaN(timestamp.getTime())) continue;
-
-    sessionEvents.push({
-      sessionId: row.sessionId,
-      source: 'hermes',
-      project: 'unknown',
-      timestamp,
-      role: row.role === 'user' ? 'user' : 'assistant',
-    });
+    for (const row of sessionRows) {
+      // started_at is a Unix timestamp (float)
+      const timestamp = new Date(row.startedAt * 1000);
+      if (isNaN(timestamp.getTime())) continue;
+
+      // Hermes stores input_tokens exclusive of cache (Anthropic-style semantics)
+      entries.push({
+        source: 'hermes',
+        model: row.model || 'unknown',
+        project: profile,
+        timestamp,
+        inputTokens: row.inputTokens || 0,
+        outputTokens: row.outputTokens || 0,
+        cachedInputTokens: row.cacheReadTokens || 0,
+        reasoningOutputTokens: row.reasoningTokens || 0,
+      });
+    }
+
+    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;
+    }
+
+    for (const row of messageRows) {
+      const timestamp = new Date(row.timestamp * 1000);
+      if (isNaN(timestamp.getTime())) continue;
+
+      sessionEvents.push({
+        sessionId: row.sessionId,
+        source: 'hermes',
+        project: profile,
+        timestamp,
+        role: row.role === 'user' ? 'user' : 'assistant',
+      });
+    }
   }
 
   return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
 }
 
-function queryDb(sql) {
+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) {
   const output = execFileSync('sqlite3', [
     '-json',
-    DB_PATH,
+    dbPath,
     sql,
   ], { encoding: 'utf-8', maxBuffer: 100 * 1024 * 1024, timeout: 30000 });