@vibe-cafe/vibe-usage 0.1.0

package/README.md

@@ -0,0 +1,49 @@
+# vibe-usage
+
+Track your AI coding tool token usage and sync to [vibecafe.ai](https://vibecafe.ai).
+
+## Quick Start
+
+```bash
+npx vibe-usage
+```
+
+This will:
+1. Ask for your API key (get one at https://vibecafe.ai/usage/setup)
+2. Detect installed AI coding tools
+3. Install session-end hooks for automatic syncing
+4. Run an initial sync of your usage data
+
+## Commands
+
+```bash
+npx vibe-usage          # Init (first run) or sync (subsequent runs)
+npx vibe-usage init     # Re-run setup
+npx vibe-usage sync     # Manual sync
+npx vibe-usage status   # Show config & detected tools
+```
+
+## Supported Tools
+
+| Tool | Auto-sync | Data Location |
+|------|-----------|---------------|
+| 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/` |
+| OpenClaw | Manual only | `~/.openclaw/agents/` |
+
+## How It Works
+
+- Parses local session logs from each AI coding tool
+- Aggregates token usage into 30-minute buckets
+- Uploads to your vibecafe.ai dashboard
+- Only syncs new data since last sync (incremental)
+
+## Config
+
+Config stored at `~/.vibe-usage/config.json`. Contains your API key and last sync timestamp.
+
+## License
+
+MIT

package/bin/vibe-usage.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+/**
+ * vibe-usage CLI entry point.
+ * Routes to the appropriate command handler.
+ */
+
+import { run } from '../src/index.js';
+
+run(process.argv.slice(2));

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@vibe-cafe/vibe-usage",
+  "version": "0.1.0",
+  "description": "Track your AI coding tool token usage and sync to vibecafe.ai",
+  "type": "module",
+  "bin": {
+    "vibe-usage": "./bin/vibe-usage.js"
+  },
+  "files": ["bin/", "src/"],
+  "engines": { "node": ">=20" },
+  "keywords": ["ai", "coding", "usage", "tokens", "claude", "codex", "gemini"],
+  "dependencies": {
+    "ccusage": "18.0.5"
+  },
+  "license": "MIT"
+}

package/src/api.js

@@ -0,0 +1,50 @@
+import https from 'node:https';
+import http from 'node:http';
+import { URL } from 'node:url';
+
+/**
+ * POST buckets to the vibecafe ingest API.
+ * Uses native http/https — zero dependencies.
+ * @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) {
+  return new Promise((resolve, reject) => {
+    const url = new URL('/api/usage/ingest', apiUrl);
+    const body = JSON.stringify({ buckets });
+    const mod = url.protocol === 'https:' ? https : http;
+
+    const req = mod.request(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        if (res.statusCode === 401) {
+          reject(new Error('UNAUTHORIZED'));
+          return;
+        }
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          reject(new Error(`HTTP ${res.statusCode}: ${data}`));
+          return;
+        }
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          reject(new Error(`Invalid JSON response: ${data}`));
+        }
+      });
+    });
+
+    req.on('error', (err) => reject(err));
+    req.write(body);
+    req.end();
+  });
+}

package/src/config.js

@@ -0,0 +1,24 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CONFIG_DIR = join(homedir(), '.vibe-usage');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+export function getConfigPath() {
+  return CONFIG_FILE;
+}
+
+export function loadConfig() {
+  if (!existsSync(CONFIG_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+export function saveConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}

package/src/hooks.js

@@ -0,0 +1,116 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+
+const SYNC_CMD = 'npx vibe-usage sync 2>/dev/null &';
+
+function hasVibeUsageHook(hooks) {
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some(h => h.command && h.command.includes('vibe-usage'));
+}
+
+export function injectClaudeCode() {
+  const settingsPath = join(homedir(), '.claude', 'settings.json');
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try { settings = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch { settings = {}; }
+  } else {
+    mkdirSync(dirname(settingsPath), { recursive: true });
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.SessionEnd) settings.hooks.SessionEnd = [];
+
+  if (hasVibeUsageHook(settings.hooks.SessionEnd)) {
+    return { injected: false, reason: 'already installed' };
+  }
+
+  settings.hooks.SessionEnd.push({ type: 'command', command: SYNC_CMD });
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  return { injected: true };
+}
+
+export function injectCodex() {
+  const configPath = join(homedir(), '.codex', 'config.toml');
+  let content = '';
+  if (existsSync(configPath)) {
+    content = readFileSync(configPath, 'utf-8');
+  } else {
+    mkdirSync(dirname(configPath), { recursive: true });
+  }
+
+  if (content.includes('vibe-usage')) {
+    return { injected: false, reason: 'already installed' };
+  }
+
+  const notifySection = `\n[notify]\ncommand = "${SYNC_CMD}"\n`;
+  const notifyIdx = content.indexOf('[notify]');
+  if (notifyIdx !== -1) {
+    const nextSection = content.indexOf('\n[', notifyIdx + 1);
+    const sectionEnd = nextSection === -1 ? content.length : nextSection;
+    content = content.slice(0, notifyIdx) + `[notify]\ncommand = "${SYNC_CMD}"` + content.slice(sectionEnd);
+  } else {
+    content += notifySection;
+  }
+
+  writeFileSync(configPath, content, 'utf-8');
+  return { injected: true };
+}
+
+export function injectGeminiCli() {
+  const settingsPath = join(homedir(), '.gemini', 'settings.json');
+  let settings = {};
+  if (existsSync(settingsPath)) {
+    try { settings = JSON.parse(readFileSync(settingsPath, 'utf-8')); } catch { settings = {}; }
+  } else {
+    mkdirSync(dirname(settingsPath), { recursive: true });
+  }
+
+  if (!settings.hooks) settings.hooks = {};
+  if (!settings.hooks.SessionEnd) settings.hooks.SessionEnd = [];
+
+  if (hasVibeUsageHook(settings.hooks.SessionEnd)) {
+    return { injected: false, reason: 'already installed' };
+  }
+
+  settings.hooks.SessionEnd.push({ type: 'command', command: SYNC_CMD });
+  writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+  return { injected: true };
+}
+
+export const TOOLS = [
+  {
+    name: 'Claude Code',
+    id: 'claude-code',
+    dataDir: join(homedir(), '.claude', 'projects'),
+    inject: injectClaudeCode,
+  },
+  {
+    name: 'Codex CLI',
+    id: 'codex',
+    dataDir: join(homedir(), '.codex', 'sessions'),
+    inject: injectCodex,
+  },
+  {
+    name: 'Gemini CLI',
+    id: 'gemini-cli',
+    dataDir: join(homedir(), '.gemini', 'tmp'),
+    inject: injectGeminiCli,
+  },
+  {
+    name: 'OpenCode',
+    id: 'opencode',
+    dataDir: join(homedir(), '.local', 'share', 'opencode'),
+    inject: null,
+  },
+  {
+    name: 'OpenClaw',
+    id: 'openclaw',
+    dataDir: join(homedir(), '.openclaw', 'agents'),
+    inject: null,
+  },
+];
+
+export function detectInstalledTools() {
+  return TOOLS.filter(t => existsSync(t.dataDir));
+}

package/src/index.js

@@ -0,0 +1,83 @@
+import { loadConfig, getConfigPath } from './config.js';
+import { detectInstalledTools, TOOLS } from './hooks.js';
+import { existsSync } from 'node:fs';
+
+async function showStatus() {
+  const config = loadConfig();
+  console.log('\nvibe-usage status\n');
+
+  if (!config?.apiKey) {
+    console.log('  Config: not configured');
+    console.log(`  Run \`npx vibe-usage init\` to set up.\n`);
+  } else {
+    console.log(`  Config: ${getConfigPath()}`);
+    console.log(`  API key: ${config.apiKey.slice(0, 8)}...`);
+    console.log(`  API URL: ${config.apiUrl || 'https://vibecafe.ai'}`);
+    console.log(`  Last sync: ${config.lastSync || 'never'}`);
+  }
+
+  console.log('\n  Detected tools:');
+  const detected = detectInstalledTools();
+  if (detected.length === 0) {
+    console.log('    (none)\n');
+  } else {
+    for (const tool of detected) {
+      const hookStatus = tool.inject ? 'auto-sync' : 'manual only';
+      console.log(`    ${tool.name} (${hookStatus})`);
+    }
+    console.log();
+  }
+
+  console.log('  All supported tools:');
+  for (const tool of TOOLS) {
+    const installed = existsSync(tool.dataDir) ? 'installed' : 'not found';
+    console.log(`    ${tool.name}: ${installed}`);
+  }
+  console.log();
+}
+
+export async function run(args) {
+  const command = args[0];
+
+  switch (command) {
+    case 'init': {
+      const { runInit } = await import('./init.js');
+      await runInit();
+      break;
+    }
+    case 'sync': {
+      const { runSync } = await import('./sync.js');
+      await runSync();
+      break;
+    }
+    case 'status': {
+      await showStatus();
+      break;
+    }
+    case 'help':
+    case '--help':
+    case '-h': {
+      console.log(`
+  vibe-usage - Vibe Usage Tracker by VibeCaf\u00e9
+
+  Usage:
+    npx vibe-usage          Init (first run) or sync
+    npx vibe-usage init     Set up API key and hooks
+    npx vibe-usage sync     Manually sync usage data
+    npx vibe-usage status   Show config and detected tools
+    npx vibe-usage help     Show this help
+`);
+      break;
+    }
+    default: {
+      const config = loadConfig();
+      if (!config?.apiKey) {
+        const { runInit } = await import('./init.js');
+        await runInit();
+      } else {
+        const { runSync } = await import('./sync.js');
+        await runSync();
+      }
+    }
+  }
+}

package/src/init.js

@@ -0,0 +1,99 @@
+import { createInterface } from 'node:readline';
+import { exec } from 'node:child_process';
+import { platform } from 'node:os';
+import { existsSync } from 'node:fs';
+import { loadConfig, saveConfig } from './config.js';
+import { detectInstalledTools } from './hooks.js';
+import { ingest } from './api.js';
+import { runSync } from './sync.js';
+
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function openBrowser(url) {
+  const cmds = { darwin: 'open', linux: 'xdg-open', win32: 'start' };
+  const cmd = cmds[platform()] || cmds.linux;
+  exec(`${cmd} ${url}`, () => {});
+}
+
+export async function runInit() {
+  console.log('\n  vibe-usage - Vibe Usage Tracker by VibeCaf\u00e9\n');
+
+  const existing = loadConfig();
+  if (existing?.apiKey) {
+    const answer = await prompt('Config already exists. Overwrite? (y/N) ');
+    if (answer.toLowerCase() !== 'y') {
+      console.log('Cancelled.');
+      return;
+    }
+  }
+
+  const apiUrl = process.env.VIBE_USAGE_API_URL || 'https://vibecafe.ai';
+  console.log(`Get your API key at: ${apiUrl}/usage/setup\n`);
+  openBrowser(`${apiUrl}/usage/setup`);
+
+  let apiKey;
+  while (true) {
+    apiKey = await prompt('Paste your API key: ');
+    if (apiKey.startsWith('vbu_')) break;
+    console.log('Invalid key — must start with "vbu_". Try again.');
+  }
+
+  console.log(`\nVerifying key ${apiKey.slice(0, 8)}...`);
+  try {
+    await ingest(apiUrl, apiKey, []);
+    console.log('Key verified.\n');
+  } catch (err) {
+    if (err.message === 'UNAUTHORIZED') {
+      console.error('Invalid API key. Please check and try again.');
+      process.exit(1);
+    }
+    console.log('Could not verify key (network error). Saving anyway.\n');
+  }
+
+  const config = {
+    apiKey,
+    apiUrl,
+    lastSync: null,
+  };
+  saveConfig(config);
+
+  const tools = detectInstalledTools();
+  const hooked = [];
+  const manualOnly = [];
+
+  for (const tool of tools) {
+    if (tool.inject) {
+      try {
+        const result = tool.inject();
+        hooked.push(tool.name + (result.injected ? '' : ' (already installed)'));
+      } catch (err) {
+        console.error(`  warn: Failed to inject hook for ${tool.name}: ${err.message}`);
+      }
+    } else {
+      manualOnly.push(tool.name);
+    }
+  }
+
+  if (hooked.length > 0) {
+    console.log(`Hooks installed for: ${hooked.join(', ')}`);
+  }
+  for (const name of manualOnly) {
+    console.log(`${name} detected — use \`npx vibe-usage sync\` to sync manually.`);
+  }
+  if (tools.length === 0) {
+    console.log('No AI coding tools detected. Install one and re-run init.');
+  }
+
+  console.log('\nRunning initial sync...');
+  await runSync();
+
+  console.log('\nSetup complete! Usage data will sync automatically after each session.');
+}

package/src/parsers/claude-code.js

@@ -0,0 +1,34 @@
+import { loadSessionData } from 'ccusage/data-loader';
+import { aggregateToBuckets } from './index.js';
+
+export async function parse(lastSync) {
+  let sessions;
+  try {
+    sessions = await loadSessionData({ mode: 'display' });
+  } catch {
+    return [];
+  }
+
+  if (!sessions || sessions.length === 0) return [];
+
+  const entries = [];
+
+  for (const session of sessions) {
+    if (lastSync && session.lastActivity <= lastSync) continue;
+
+    for (const breakdown of session.modelBreakdowns || []) {
+      entries.push({
+        source: 'claude-code',
+        model: breakdown.modelName,
+        project: session.projectPath || 'unknown',
+        timestamp: new Date(session.lastActivity),
+        inputTokens: breakdown.inputTokens,
+        outputTokens: breakdown.outputTokens,
+        cachedInputTokens: breakdown.cacheReadTokens,
+        reasoningOutputTokens: 0,
+      });
+    }
+  }
+
+  return aggregateToBuckets(entries);
+}

package/src/parsers/codex.js

@@ -0,0 +1,80 @@
+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 SESSIONS_DIR = join(homedir(), '.codex', 'sessions');
+
+export async function parse(lastSync) {
+  if (!existsSync(SESSIONS_DIR)) return [];
+
+  const entries = [];
+  let files;
+  try {
+    files = readdirSync(SESSIONS_DIR).filter(f => f.endsWith('.jsonl'));
+  } catch {
+    return [];
+  }
+
+  for (const file of files) {
+    const filePath = join(SESSIONS_DIR, file);
+    if (lastSync) {
+      try {
+        const stat = statSync(filePath);
+        if (stat.mtime <= new Date(lastSync)) continue;
+      } catch {
+        continue;
+      }
+    }
+
+    const project = basename(file, '.jsonl');
+
+    let content;
+    try {
+      content = readFileSync(filePath, 'utf-8');
+    } catch {
+      continue;
+    }
+
+    for (const line of content.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+
+
+        if (obj.type !== 'event_msg') continue;
+
+        const payload = obj.payload;
+        if (!payload || payload.type !== 'token_count') continue;
+
+        const info = payload.info;
+        if (!info) continue;
+
+        const timestamp = obj.timestamp ? new Date(obj.timestamp) : null;
+        if (!timestamp || isNaN(timestamp.getTime())) continue;
+        if (lastSync && timestamp <= new Date(lastSync)) continue;
+
+
+        const usage = info.last_token_usage || info.total_token_usage;
+        if (!usage) continue;
+
+        const model = info.model || payload.model || 'unknown';
+
+        entries.push({
+          source: 'codex',
+          model,
+          project,
+          timestamp,
+          inputTokens: usage.input_tokens || 0,
+          outputTokens: usage.output_tokens || 0,
+          cachedInputTokens: usage.cached_input_tokens || usage.cache_read_input_tokens || 0,
+          reasoningOutputTokens: usage.reasoning_output_tokens || 0,
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  return aggregateToBuckets(entries);
+}

package/src/parsers/gemini-cli.js

@@ -0,0 +1,81 @@
+import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets } from './index.js';
+
+const TMP_DIR = join(homedir(), '.gemini', 'tmp');
+
+function findSessionFiles(baseDir) {
+  const results = [];
+  if (!existsSync(baseDir)) return results;
+
+  try {
+    for (const entry of readdirSync(baseDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const chatsDir = join(baseDir, entry.name, 'chats');
+      if (!existsSync(chatsDir)) continue;
+      try {
+        for (const f of readdirSync(chatsDir)) {
+          if (f.startsWith('session-') && f.endsWith('.json')) {
+            results.push(join(chatsDir, f));
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return results;
+  }
+  return results;
+}
+
+export async function parse(lastSync) {
+  const sessionFiles = findSessionFiles(TMP_DIR);
+  if (sessionFiles.length === 0) return [];
+
+  const entries = [];
+
+  for (const filePath of sessionFiles) {
+    if (lastSync) {
+      try {
+        const stat = statSync(filePath);
+        if (stat.mtime <= new Date(lastSync)) continue;
+      } catch {
+        continue;
+      }
+    }
+
+    let data;
+    try {
+      data = JSON.parse(readFileSync(filePath, 'utf-8'));
+    } catch {
+      continue;
+    }
+
+    const messages = data.messages || data.history || [];
+    for (const msg of messages) {
+      const usage = msg.usage || msg.usageMetadata || msg.token_count;
+      if (!usage) continue;
+
+      const timestamp = msg.timestamp || msg.createTime || data.createTime;
+      if (!timestamp) continue;
+      const ts = new Date(timestamp);
+      if (isNaN(ts.getTime())) continue;
+      if (lastSync && ts <= new Date(lastSync)) continue;
+
+      entries.push({
+        source: 'gemini-cli',
+        model: msg.model || data.model || 'unknown',
+        project: 'unknown',
+        timestamp: ts,
+        inputTokens: usage.promptTokenCount || usage.input_tokens || 0,
+        outputTokens: usage.candidatesTokenCount || usage.output_tokens || 0,
+        cachedInputTokens: usage.cachedContentTokenCount || 0,
+        reasoningOutputTokens: usage.thoughtsTokenCount || 0,
+      });
+    }
+  }
+
+  return aggregateToBuckets(entries);
+}

package/src/parsers/index.js

@@ -0,0 +1,51 @@
+import { parse as parseClaudeCode } from './claude-code.js';
+import { parse as parseCodex } from './codex.js';
+import { parse as parseGeminiCli } from './gemini-cli.js';
+import { parse as parseOpencode } from './opencode.js';
+import { parse as parseOpenclaw } from './openclaw.js';
+
+export const parsers = {
+  'claude-code': parseClaudeCode,
+  'codex': parseCodex,
+  'gemini-cli': parseGeminiCli,
+  'opencode': parseOpencode,
+  'openclaw': parseOpenclaw,
+};
+
+export function roundToHalfHour(date) {
+  const d = new Date(date);
+  d.setMinutes(d.getMinutes() < 30 ? 0 : 30, 0, 0);
+  return d;
+}
+
+export function aggregateToBuckets(entries) {
+  const map = new Map();
+
+  for (const e of entries) {
+    const bucketStart = roundToHalfHour(e.timestamp).toISOString();
+    const key = `${e.source}|${e.model}|${e.project}|${bucketStart}`;
+
+    if (!map.has(key)) {
+      map.set(key, {
+        source: e.source,
+        model: e.model,
+        project: e.project,
+        bucketStart,
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedInputTokens: 0,
+        reasoningOutputTokens: 0,
+        totalTokens: 0,
+      });
+    }
+
+    const b = map.get(key);
+    b.inputTokens += e.inputTokens || 0;
+    b.outputTokens += e.outputTokens || 0;
+    b.cachedInputTokens += e.cachedInputTokens || 0;
+    b.reasoningOutputTokens += e.reasoningOutputTokens || 0;
+    b.totalTokens += (e.inputTokens || 0) + (e.outputTokens || 0);
+  }
+
+  return Array.from(map.values());
+}

package/src/parsers/openclaw.js

@@ -0,0 +1,82 @@
+import { readdirSync, readFileSync, statSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { aggregateToBuckets } from './index.js';
+
+const AGENTS_DIR = join(homedir(), '.openclaw', 'agents');
+
+export async function parse(lastSync) {
+  if (!existsSync(AGENTS_DIR)) return [];
+
+  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;
+
+    let files;
+    try {
+      files = readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl'));
+    } 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;
+        }
+      }
+
+      let content;
+      try {
+        content = readFileSync(filePath, 'utf-8');
+      } catch {
+        continue;
+      }
+
+      for (const line of content.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          const obj = JSON.parse(line);
+
+          const usage = obj.usage || obj.message?.usage;
+          if (!usage) continue;
+
+          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;
+
+          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;
+        }
+      }
+    }
+  }
+
+  return aggregateToBuckets(entries);
+}

package/src/parsers/opencode.js

@@ -0,0 +1,78 @@
+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 MESSAGES_DIR = join(DATA_DIR, 'storage', 'message');
+
+export async function parse(lastSync) {
+  if (!existsSync(MESSAGES_DIR)) return [];
+
+  const entries = [];
+  let sessionDirs;
+  try {
+    sessionDirs = readdirSync(MESSAGES_DIR, { withFileTypes: true })
+      .filter(d => d.isDirectory() && d.name.startsWith('ses_'));
+  } catch {
+    return [];
+  }
+
+  for (const sessionDir of sessionDirs) {
+    const sessionPath = join(MESSAGES_DIR, sessionDir.name);
+    let msgFiles;
+    try {
+      msgFiles = readdirSync(sessionPath).filter(f => f.endsWith('.json'));
+    } catch {
+      continue;
+    }
+
+    for (const file of msgFiles) {
+      const filePath = join(sessionPath, file);
+      if (lastSync) {
+        try {
+          const stat = statSync(filePath);
+          if (stat.mtime <= new Date(lastSync)) continue;
+        } catch {
+          continue;
+        }
+      }
+
+      let data;
+      try {
+        data = JSON.parse(readFileSync(filePath, 'utf-8'));
+      } 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);
+}

package/src/sync.js

@@ -0,0 +1,49 @@
+import { loadConfig, saveConfig } from './config.js';
+import { ingest } from './api.js';
+import { parsers } from './parsers/index.js';
+
+export async function runSync() {
+  const config = loadConfig();
+  if (!config?.apiKey) {
+    console.error('Not configured. Run `npx vibe-usage init` first.');
+    process.exit(1);
+  }
+
+  const lastSync = config.lastSync || null;
+  const allBuckets = [];
+
+  for (const [source, parse] of Object.entries(parsers)) {
+    try {
+      const buckets = await parse(lastSync);
+      if (buckets.length > 0) {
+        allBuckets.push(...buckets);
+      }
+    } catch (err) {
+      process.stderr.write(`warn: ${source} parser failed: ${err.message}\n`);
+    }
+  }
+
+  if (allBuckets.length === 0) {
+    console.log('No new usage data found.');
+    return 0;
+  }
+
+  try {
+    const result = await ingest(
+      config.apiUrl || 'https://vibecafe.ai',
+      config.apiKey,
+      allBuckets
+    );
+    config.lastSync = new Date().toISOString();
+    saveConfig(config);
+    console.log(`Synced ${result.ingested ?? allBuckets.length} buckets.`);
+    return result.ingested ?? allBuckets.length;
+  } catch (err) {
+    if (err.message === 'UNAUTHORIZED') {
+      console.error('Invalid API key. Run `npx vibe-usage init` to reconfigure.');
+      process.exit(1);
+    }
+    console.error(`Sync failed: ${err.message}`);
+    process.exit(1);
+  }
+}