@vibe-cafe/vibe-usage 0.1.2 → 0.1.4

package/package.json

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

package/src/api.js

@@ -18,6 +18,7 @@ export function ingest(apiUrl, apiKey, buckets) {
 
     const req = mod.request(url, {
       method: 'POST',
+      timeout: 30_000,
       headers: {
         'Content-Type': 'application/json',
         'Authorization': `Bearer ${apiKey}`,
@@ -44,6 +45,10 @@ export function ingest(apiUrl, apiKey, buckets) {
     });
 
     req.on('error', (err) => reject(err));
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('Request timed out (30s)'));
+    });
     req.write(body);
     req.end();
   });

package/src/init.js

@@ -1,5 +1,5 @@
 import { createInterface } from 'node:readline';
-import { exec } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import { platform } from 'node:os';
 import { existsSync } from 'node:fs';
 import { loadConfig, saveConfig } from './config.js';
@@ -20,7 +20,8 @@ function prompt(question) {
 function openBrowser(url) {
   const cmds = { darwin: 'open', linux: 'xdg-open', win32: 'start' };
   const cmd = cmds[platform()] || cmds.linux;
-  exec(`${cmd} ${url}`, () => {});
+  // Use execFile with args array to avoid shell injection via VIBE_USAGE_API_URL
+  execFile(cmd, [url], () => {});
 }
 
 export async function runInit() {

package/src/parsers/claude-code.js

@@ -14,7 +14,7 @@ export async function parse(lastSync) {
   const entries = [];
 
   for (const session of sessions) {
-    if (lastSync && session.lastActivity <= lastSync) continue;
+    if (lastSync && new Date(session.lastActivity) <= new Date(lastSync)) continue;
 
     for (const breakdown of session.modelBreakdowns || []) {
       entries.push({

package/src/parsers/codex.js

@@ -36,6 +36,9 @@ export async function parse(lastSync) {
       continue;
     }
 
+    // Track previous cumulative totals per model to compute deltas when only total_token_usage is available
+    const prevTotal = new Map();
+
     for (const line of content.split('\n')) {
       if (!line.trim()) continue;
       try {
@@ -54,8 +57,25 @@ export async function parse(lastSync) {
         if (!timestamp || isNaN(timestamp.getTime())) continue;
         if (lastSync && timestamp <= new Date(lastSync)) continue;
 
-
-        const usage = info.last_token_usage || info.total_token_usage;
+        // Prefer incremental per-request usage; compute delta from cumulative total as fallback
+        let usage = info.last_token_usage;
+        if (!usage && info.total_token_usage) {
+          const totalKey = `${info.model || payload.model || ''}`;
+          const prev = prevTotal.get(totalKey);
+          const curr = info.total_token_usage;
+          if (prev) {
+            usage = {
+              input_tokens: (curr.input_tokens || 0) - (prev.input_tokens || 0),
+              output_tokens: (curr.output_tokens || 0) - (prev.output_tokens || 0),
+              cached_input_tokens: (curr.cached_input_tokens || 0) - (prev.cached_input_tokens || 0),
+              reasoning_output_tokens: (curr.reasoning_output_tokens || 0) - (prev.reasoning_output_tokens || 0),
+            };
+          } else {
+            // First cumulative entry — use as-is (it's the first event's total)
+            usage = curr;
+          }
+          prevTotal.set(totalKey, { ...curr });
+        }
         if (!usage) continue;
 
         const model = info.model || payload.model || 'unknown';

package/src/parsers/openclaw.js

@@ -3,76 +3,100 @@ import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets } from './index.js';
 
-const AGENTS_DIR = join(homedir(), '.openclaw', 'agents');
+// OpenClaw stores data at ~/.openclaw/agents/<agentId>/sessions/*.jsonl
+// Legacy paths: ~/.clawdbot, ~/.moltbot, ~/.moldbot
+const POSSIBLE_ROOTS = [
+  join(homedir(), '.openclaw'),
+  join(homedir(), '.clawdbot'),
+  join(homedir(), '.moltbot'),
+  join(homedir(), '.moldbot'),
+];
 
-export async function parse(lastSync) {
-  if (!existsSync(AGENTS_DIR)) return [];
+/** Normalize usage fields — OpenClaw supports multiple naming conventions */
+function getTokens(usage, ...keys) {
+  for (const key of keys) {
+    if (usage[key] != null && usage[key] > 0) return usage[key];
+  }
+  return 0;
+}
 
+export async function parse(lastSync) {
   const entries = [];
-  let agentDirs;
-  try {
-    agentDirs = readdirSync(AGENTS_DIR, { withFileTypes: true })
-      .filter(d => d.isDirectory());
-  } catch {
-    return [];
-  }
 
-  for (const agentDir of agentDirs) {
-    const project = agentDir.name;
-    const sessionsDir = join(AGENTS_DIR, agentDir.name, 'sessions');
-    if (!existsSync(sessionsDir)) continue;
+  for (const root of POSSIBLE_ROOTS) {
+    const agentsDir = join(root, 'agents');
+    if (!existsSync(agentsDir)) continue;
 
-    let files;
+    let agentDirs;
     try {
-      files = readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl'));
+      agentDirs = readdirSync(agentsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory());
     } catch {
       continue;
     }
 
-    for (const file of files) {
-      const filePath = join(sessionsDir, file);
-      if (lastSync) {
-        try {
-          const stat = statSync(filePath);
-          if (stat.mtime <= new Date(lastSync)) continue;
-        } catch {
-          continue;
-        }
-      }
+    for (const agentDir of agentDirs) {
+      const project = agentDir.name;
+      const sessionsDir = join(agentsDir, agentDir.name, 'sessions');
+      if (!existsSync(sessionsDir)) continue;
 
-      let content;
+      let files;
       try {
-        content = readFileSync(filePath, 'utf-8');
+        files = readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl'));
       } catch {
         continue;
       }
 
-      for (const line of content.split('\n')) {
-        if (!line.trim()) continue;
+      for (const file of files) {
+        const filePath = join(sessionsDir, file);
+        if (lastSync) {
+          try {
+            const stat = statSync(filePath);
+            if (stat.mtime <= new Date(lastSync)) continue;
+          } catch {
+            continue;
+          }
+        }
+
+        let content;
         try {
-          const obj = JSON.parse(line);
+          content = readFileSync(filePath, 'utf-8');
+        } catch {
+          continue;
+        }
 
-          const usage = obj.usage || obj.message?.usage;
-          if (!usage) continue;
+        for (const line of content.split('\n')) {
+          if (!line.trim()) continue;
+          try {
+            const obj = JSON.parse(line);
 
-          const timestamp = obj.timestamp || obj.created_at;
-          if (!timestamp) continue;
-          const ts = new Date(timestamp);
-          if (isNaN(ts.getTime())) continue;
-          if (lastSync && ts <= new Date(lastSync)) continue;
+            // Only process message entries with assistant role
+            if (obj.type !== 'message') continue;
+            const msg = obj.message;
+            if (!msg || msg.role !== 'assistant') continue;
 
-          entries.push({
-            source: 'openclaw',
-            model: obj.model || obj.message?.model || 'unknown',
-            project,
-            timestamp: ts,
-            inputTokens: usage.input_tokens || 0,
-            outputTokens: usage.output_tokens || 0,
-            cachedInputTokens: usage.cache_read_input_tokens || 0,
-            reasoningOutputTokens: 0,
-          });
-        } catch {
-          continue;
+            const usage = msg.usage;
+            if (!usage) continue;
+
+            const timestamp = obj.timestamp || msg.timestamp;
+            if (!timestamp) continue;
+            const ts = new Date(typeof timestamp === 'number' ? timestamp : timestamp);
+            if (isNaN(ts.getTime())) continue;
+            if (lastSync && ts <= new Date(lastSync)) continue;
+
+            entries.push({
+              source: 'openclaw',
+              model: msg.model || obj.model || 'unknown',
+              project,
+              timestamp: ts,
+              inputTokens: getTokens(usage, 'input', 'inputTokens', 'input_tokens', 'promptTokens', 'prompt_tokens'),
+              outputTokens: getTokens(usage, 'output', 'outputTokens', 'output_tokens', 'completionTokens', 'completion_tokens'),
+              cachedInputTokens: getTokens(usage, 'cacheRead', 'cache_read', 'cache_read_input_tokens'),
+              reasoningOutputTokens: 0,
+            });
+          } catch {
+            continue;
+          }
         }
       }
     }

package/src/sync.js

@@ -39,13 +39,15 @@ export async function runSync() {
       const result = await ingest(apiUrl, config.apiKey, batch);
       totalIngested += result.ingested ?? batch.length;
 
+      // Save progress after each successful batch so partial uploads survive interruptions
+      config.lastSync = new Date().toISOString();
+      saveConfig(config);
+
       if (allBuckets.length > BATCH_SIZE) {
         process.stdout.write(`  ${Math.min(i + BATCH_SIZE, allBuckets.length)}/${allBuckets.length} buckets...\r`);
       }
     }
 
-    config.lastSync = new Date().toISOString();
-    saveConfig(config);
     console.log(`Synced ${totalIngested} buckets.`);
     return totalIngested;
   } catch (err) {
@@ -53,7 +55,12 @@ export async function runSync() {
       console.error('Invalid API key. Run `npx @vibe-cafe/vibe-usage init` to reconfigure.');
       process.exit(1);
     }
-    console.error(`Sync failed: ${err.message}`);
+    // Progress already saved per-batch — report partial success
+    if (totalIngested > 0) {
+      console.error(`Sync partially completed (${totalIngested} buckets uploaded). ${err.message}`);
+    } else {
+      console.error(`Sync failed: ${err.message}`);
+    }
     process.exit(1);
   }
 }