@vibe-cafe/vibe-usage 0.1.5 → 0.1.7

package/README.md

@@ -30,7 +30,7 @@ npx vibe-usage status   # Show config & detected tools
 | Claude Code | Yes (session hook) | `~/.claude/projects/` |
 | Codex CLI | Yes (notify hook) | `~/.codex/sessions/` |
 | Gemini CLI | Yes (session hook) | `~/.gemini/tmp/` |
-| OpenCode | Manual only | `~/.local/share/opencode/` |
+| OpenCode | Manual only | `~/.local/share/opencode/opencode.db` (SQLite) |
 | OpenClaw | Manual only | `~/.openclaw/agents/` |
 
 ## How It Works

package/package.json

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

package/src/api.js

@@ -2,15 +2,39 @@ import https from 'node:https';
 import http from 'node:http';
 import { URL } from 'node:url';
 
+const MAX_RETRIES = 3;
+const INITIAL_DELAY = 1000;
+
 /**
  * POST buckets to the vibecafe ingest API.
  * Uses native http/https — zero dependencies.
+ * Retries up to 3 times with exponential backoff on transient failures.
  * @param {string} apiUrl - Base URL (e.g. "https://vibecafe.ai")
  * @param {string} apiKey - Bearer token (vbu_xxx)
  * @param {Array} buckets - Array of usage bucket objects
  * @returns {Promise<{ingested: number}>}
  */
-export function ingest(apiUrl, apiKey, buckets) {
+export async function ingest(apiUrl, apiKey, buckets) {
+  let lastError;
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      return await _send(apiUrl, apiKey, buckets);
+    } catch (err) {
+      lastError = err;
+      // Don't retry auth errors or client errors
+      if (err.message === 'UNAUTHORIZED' || err.statusCode >= 400 && err.statusCode < 500) {
+        throw err;
+      }
+      if (attempt < MAX_RETRIES - 1) {
+        const delay = INITIAL_DELAY * 2 ** attempt;
+        await new Promise(r => setTimeout(r, delay));
+      }
+    }
+  }
+  throw lastError;
+}
+
+function _send(apiUrl, apiKey, buckets) {
   return new Promise((resolve, reject) => {
     const url = new URL('/api/usage/ingest', apiUrl);
     const body = JSON.stringify({ buckets });
@@ -33,7 +57,9 @@ export function ingest(apiUrl, apiKey, buckets) {
           return;
         }
         if (res.statusCode < 200 || res.statusCode >= 300) {
-          reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+          const err = new Error(`HTTP ${res.statusCode}: ${data}`);
+          err.statusCode = res.statusCode;
+          reject(err);
           return;
         }
         try {

package/src/parsers/opencode.js

@@ -1,12 +1,103 @@
+import { execFileSync } from 'node:child_process';
 import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { aggregateToBuckets } from './index.js';
 
 const DATA_DIR = join(homedir(), '.local', 'share', 'opencode');
+const DB_PATH = join(DATA_DIR, 'opencode.db');
 const MESSAGES_DIR = join(DATA_DIR, 'storage', 'message');
 
+/**
+ * Parse opencode usage data.
+ * Tries SQLite database first (opencode >= v0.2), falls back to legacy JSON files.
+ */
 export async function parse(lastSync) {
+  if (existsSync(DB_PATH)) {
+    try {
+      return parseFromSqlite(lastSync);
+    } catch (err) {
+      process.stderr.write(`warn: opencode sqlite parse failed (${err.message}), trying legacy json...\n`);
+    }
+  }
+  return parseFromJson(lastSync);
+}
+
+function parseFromSqlite(lastSync) {
+  // Build WHERE clause: only messages with token data
+  const conditions = [
+    "(json_extract(data, '$.tokens.input') > 0 OR json_extract(data, '$.tokens.output') > 0)",
+  ];
+  if (lastSync) {
+    const sinceMs = new Date(lastSync).getTime();
+    conditions.push(`time_created > ${sinceMs}`);
+  }
+
+  const query = `SELECT data FROM message WHERE ${conditions.join(' AND ')}`;
+
+  let output;
+  try {
+    output = execFileSync('sqlite3', [
+      '-json',
+      DB_PATH,
+      query,
+    ], { encoding: 'utf-8', maxBuffer: 100 * 1024 * 1024, timeout: 30000 });
+  } catch (err) {
+    if (err.status === 127 || (err.message && err.message.includes('ENOENT'))) {
+      throw new Error('sqlite3 CLI not found. Install sqlite3 to sync opencode data.');
+    }
+    throw err;
+  }
+
+  output = output.trim();
+  if (!output || output === '[]') return [];
+
+  let rows;
+  try {
+    rows = JSON.parse(output);
+  } catch {
+    throw new Error('Failed to parse sqlite3 JSON output');
+  }
+
+  const entries = [];
+  for (const row of rows) {
+    let data;
+    try {
+      data = JSON.parse(row.data);
+    } catch {
+      continue;
+    }
+
+    if (!data.modelID) continue;
+
+    const tokens = data.tokens;
+    if (!tokens) continue;
+    if (!tokens.input && !tokens.output) continue;
+
+    const timestamp = new Date(data.time?.created);
+    if (isNaN(timestamp.getTime())) continue;
+    if (lastSync && timestamp <= new Date(lastSync)) continue;
+
+    const rootPath = data.path?.root;
+    const project = rootPath ? basename(rootPath) : 'unknown';
+
+    entries.push({
+      source: 'opencode',
+      model: data.modelID || 'unknown',
+      project,
+      timestamp,
+      inputTokens: tokens.input || 0,
+      outputTokens: tokens.output || 0,
+      cachedInputTokens: tokens.cache?.read || 0,
+      reasoningOutputTokens: tokens.reasoning || 0,
+    });
+  }
+
+  return aggregateToBuckets(entries);
+}
+
+/** Legacy parser: reads JSON files from storage/message directories. */
+function parseFromJson(lastSync) {
   if (!existsSync(MESSAGES_DIR)) return [];
 
   const entries = [];
@@ -45,10 +136,8 @@ export async function parse(lastSync) {
         continue;
       }
 
-
       if (!data.modelID) continue;
 
-
       const tokens = data.tokens;
       if (!tokens) continue;
       if (!tokens.input && !tokens.output) continue;
@@ -57,7 +146,6 @@ export async function parse(lastSync) {
       if (isNaN(timestamp.getTime())) continue;
       if (lastSync && timestamp <= new Date(lastSync)) continue;
 
-
       const rootPath = data.path?.root;
       const project = rootPath ? basename(rootPath) : 'unknown';
 

package/src/sync.js

@@ -32,22 +32,31 @@ export async function runSync() {
 
   const apiUrl = config.apiUrl || 'https://vibecafe.ai';
   let totalIngested = 0;
+  const totalBatches = Math.ceil(allBuckets.length / BATCH_SIZE);
+
+  console.log(`Uploading ${allBuckets.length} buckets (${totalBatches} batch${totalBatches > 1 ? 'es' : ''})...`);
 
   try {
     for (let i = 0; i < allBuckets.length; i += BATCH_SIZE) {
       const batch = allBuckets.slice(i, i + BATCH_SIZE);
+      const batchNum = Math.floor(i / BATCH_SIZE) + 1;
+      const uploaded = Math.min(i + BATCH_SIZE, allBuckets.length);
+
+      if (totalBatches > 1) {
+        process.stdout.write(`  [${batchNum}/${totalBatches}] ${uploaded}/${allBuckets.length} buckets...\r`);
+      }
+
       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`);
-      }
     }
 
+    if (totalBatches > 1) {
+      process.stdout.write('\n');
+    }
     console.log(`Synced ${totalIngested} buckets.`);
     return totalIngested;
   } catch (err) {