@vibescore/tracker 0.2.1 → 0.2.3

package/README.md

@@ -64,6 +64,7 @@ npx --yes @vibescore/tracker init
 ```
 
 Note: If `~/.code/config.toml` exists (or `CODE_HOME`), `init` also configures Every Code `notify` automatically. No further user intervention is required for data sync.
+Note: If Gemini CLI home exists, `init` installs a `SessionEnd` hook in `~/.gemini/settings.json` and sets `tools.enableHooks = true` so hooks execute. This enables all Gemini hooks; disable by setting `tools.enableHooks = false` (or disabling the `vibescore-tracker` hook).
 
 ### Sync & Status
 

package/README.zh-CN.md

@@ -64,6 +64,7 @@ npx --yes @vibescore/tracker init
 ```
 
 说明：若存在 `~/.code/config.toml`（或 `CODE_HOME`），`init` 会自动配置 Every Code 的 `notify`。配置完成后，数据同步完全自动化，无需后续人工干预。
+说明：若检测到 Gemini CLI home，`init` 会在 `~/.gemini/settings.json` 安装 `SessionEnd` hook，并将 `tools.enableHooks = true` 以确保 hook 生效。这会启用所有 Gemini hooks；如需关闭，可将 `tools.enableHooks = false`（或禁用 `vibescore-tracker` hook）。
 
 ### 同步与状态查看
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibescore/tracker",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Codex CLI token usage tracker (macOS-first, notify-driven).",
   "license": "MIT",
   "publishConfig": {

package/src/commands/init.js

@@ -14,6 +14,13 @@ const {
   loadEveryCodeNotifyOriginal
 } = require('../lib/codex-config');
 const { upsertClaudeHook, buildClaudeHookCommand } = require('../lib/claude-config');
+const {
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  buildGeminiHookCommand,
+  upsertGeminiHook
+} = require('../lib/gemini-config');
+const { resolveOpencodeConfigDir, upsertOpencodePlugin } = require('../lib/opencode-config');
 const { beginBrowserAuth } = require('../lib/browser-auth');
 const {
   issueDeviceTokenWithPassword,
@@ -162,6 +169,24 @@ async function cmdInit(argv) {
     });
   }
 
+  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
+  const geminiConfigExists = await isDir(geminiConfigDir);
+  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
+  let geminiResult = null;
+  if (geminiConfigExists) {
+    const geminiHookCommand = buildGeminiHookCommand(notifyPath);
+    geminiResult = await upsertGeminiHook({
+      settingsPath: geminiSettingsPath,
+      hookCommand: geminiHookCommand
+    });
+  }
+
+  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
+  const opencodeResult = await upsertOpencodePlugin({
+    configDir: opencodeConfigDir,
+    notifyPath
+  });
+
   process.stdout.write(
     [
       'Installed:',
@@ -186,6 +211,16 @@ async function cmdInit(argv) {
           ? `- Claude hooks: updated (${claudeSettingsPath})`
           : `- Claude hooks: already set (${claudeSettingsPath})`
         : '- Claude hooks: skipped (~/.claude not found)',
+      geminiConfigExists
+        ? geminiResult?.changed
+          ? `- Gemini hooks: updated (${geminiSettingsPath})`
+          : `- Gemini hooks: already set (${geminiSettingsPath})`
+        : `- Gemini hooks: skipped (${geminiConfigDir} not found)`,
+      opencodeResult?.skippedReason === 'config-missing'
+        ? '- Opencode plugin: skipped (config dir missing)'
+        : opencodeResult?.changed
+          ? `- Opencode plugin: updated (${opencodeConfigDir})`
+          : `- Opencode plugin: already set (${opencodeConfigDir})`,
       deviceToken ? `- Device token: stored (${maskSecret(deviceToken)})` : '- Device token: not configured (set VIBESCORE_DEVICE_TOKEN and re-run init)',
       ''
     ].join('\n')
@@ -306,7 +341,12 @@ try {
 
 // Chain the original notify if present (Codex/Every Code only).
 try {
-  const originalPath = source === 'every-code' ? codeOriginalPath : source === 'claude' ? null : codexOriginalPath;
+  const originalPath =
+    source === 'every-code'
+      ? codeOriginalPath
+      : source === 'claude' || source === 'opencode' || source === 'gemini'
+        ? null
+        : codexOriginalPath;
   if (originalPath) {
     const original = JSON.parse(fs.readFileSync(originalPath, 'utf8'));
     const cmd = Array.isArray(original?.notify) ? original.notify : null;

package/src/commands/status.js

@@ -5,6 +5,13 @@ const fs = require('node:fs/promises');
 const { readJson } = require('../lib/fs');
 const { readCodexNotify, readEveryCodeNotify } = require('../lib/codex-config');
 const { isClaudeHookConfigured, buildClaudeHookCommand } = require('../lib/claude-config');
+const {
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  isGeminiHookConfigured,
+  buildGeminiHookCommand
+} = require('../lib/gemini-config');
+const { resolveOpencodeConfigDir, isOpencodePluginInstalled } = require('../lib/opencode-config');
 const { normalizeState: normalizeUploadState } = require('../lib/upload-throttle');
 const { collectTrackerDiagnostics } = require('../lib/diagnostics');
 
@@ -31,7 +38,11 @@ async function cmdStatus(argv = []) {
   const codeHome = process.env.CODE_HOME || path.join(home, '.code');
   const codeConfigPath = path.join(codeHome, 'config.toml');
   const claudeSettingsPath = path.join(home, '.claude', 'settings.json');
+  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
+  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
+  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
   const claudeHookCommand = buildClaudeHookCommand(path.join(home, '.vibescore', 'bin', 'notify.cjs'));
+  const geminiHookCommand = buildGeminiHookCommand(path.join(home, '.vibescore', 'bin', 'notify.cjs'));
 
   const config = await readJson(configPath);
   const cursors = await readJson(cursorsPath);
@@ -53,6 +64,11 @@ async function cmdStatus(argv = []) {
     settingsPath: claudeSettingsPath,
     hookCommand: claudeHookCommand
   });
+  const geminiHookConfigured = await isGeminiHookConfigured({
+    settingsPath: geminiSettingsPath,
+    hookCommand: geminiHookCommand
+  });
+  const opencodePluginConfigured = await isOpencodePluginInstalled({ configDir: opencodeConfigDir });
 
   const lastUpload = uploadThrottle.lastSuccessMs
     ? parseEpochMsToIso(uploadThrottle.lastSuccessMs)
@@ -88,6 +104,8 @@ async function cmdStatus(argv = []) {
       `- Codex notify: ${notifyConfigured ? JSON.stringify(codexNotify) : 'unset'}`,
       `- Every Code notify: ${everyCodeConfigured ? JSON.stringify(everyCodeNotify) : 'unset'}`,
       `- Claude hooks: ${claudeHookConfigured ? 'set' : 'unset'}`,
+      `- Gemini hooks: ${geminiHookConfigured ? 'set' : 'unset'}`,
+      `- Opencode plugin: ${opencodePluginConfigured ? 'set' : 'unset'}`,
       ''
     ]
       .filter(Boolean)

package/src/commands/sync.js

@@ -8,9 +8,11 @@ const {
   listRolloutFiles,
   listClaudeProjectFiles,
   listGeminiSessionFiles,
+  listOpencodeMessageFiles,
   parseRolloutIncremental,
   parseClaudeIncremental,
-  parseGeminiIncremental
+  parseGeminiIncremental,
+  parseOpencodeIncremental
 } = require('../lib/rollout');
 const { drainQueueToCloud } = require('../lib/uploader');
 const { createProgress, renderBar, formatNumber, formatBytes } = require('../lib/progress');
@@ -54,6 +56,9 @@ async function cmdSync(argv) {
     const claudeProjectsDir = path.join(home, '.claude', 'projects');
     const geminiHome = process.env.GEMINI_HOME || path.join(home, '.gemini');
     const geminiTmpDir = path.join(geminiHome, 'tmp');
+    const xdgDataHome = process.env.XDG_DATA_HOME || path.join(home, '.local', 'share');
+    const opencodeHome = process.env.OPENCODE_HOME || path.join(xdgDataHome, 'opencode');
+    const opencodeStorageDir = path.join(opencodeHome, 'storage');
 
     const sources = [
       { source: 'codex', sessionsDir: path.join(codexHome, 'sessions') },
@@ -136,6 +141,29 @@ async function cmdSync(argv) {
       });
     }
 
+    const opencodeFiles = await listOpencodeMessageFiles(opencodeStorageDir);
+    let opencodeResult = { filesProcessed: 0, eventsAggregated: 0, bucketsQueued: 0 };
+    if (opencodeFiles.length > 0) {
+      if (progress?.enabled) {
+        progress.start(`Parsing Opencode ${renderBar(0)} 0/${formatNumber(opencodeFiles.length)} files | buckets 0`);
+      }
+      opencodeResult = await parseOpencodeIncremental({
+        messageFiles: opencodeFiles,
+        cursors,
+        queuePath,
+        onProgress: (p) => {
+          if (!progress?.enabled) return;
+          const pct = p.total > 0 ? p.index / p.total : 1;
+          progress.update(
+            `Parsing Opencode ${renderBar(pct)} ${formatNumber(p.index)}/${formatNumber(
+              p.total
+            )} files | buckets ${formatNumber(p.bucketsQueued)}`
+          );
+        },
+        source: 'opencode'
+      });
+    }
+
     cursors.updatedAt = new Date().toISOString();
     await writeJson(cursorsPath, cursors);
 
@@ -261,8 +289,16 @@ async function cmdSync(argv) {
     });
 
     if (!opts.auto) {
-      const totalParsed = parseResult.filesProcessed + claudeResult.filesProcessed + geminiResult.filesProcessed;
-      const totalBuckets = parseResult.bucketsQueued + claudeResult.bucketsQueued + geminiResult.bucketsQueued;
+      const totalParsed =
+        parseResult.filesProcessed +
+        claudeResult.filesProcessed +
+        geminiResult.filesProcessed +
+        opencodeResult.filesProcessed;
+      const totalBuckets =
+        parseResult.bucketsQueued +
+        claudeResult.bucketsQueued +
+        geminiResult.bucketsQueued +
+        opencodeResult.bucketsQueued;
       process.stdout.write(
         [
           'Sync finished:',

package/src/commands/uninstall.js

@@ -4,6 +4,13 @@ const fs = require('node:fs/promises');
 
 const { restoreCodexNotify, restoreEveryCodeNotify } = require('../lib/codex-config');
 const { removeClaudeHook, buildClaudeHookCommand } = require('../lib/claude-config');
+const {
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  buildGeminiHookCommand,
+  removeGeminiHook
+} = require('../lib/gemini-config');
+const { resolveOpencodeConfigDir, removeOpencodePlugin } = require('../lib/opencode-config');
 
 async function cmdUninstall(argv) {
   const opts = parseArgs(argv);
@@ -14,16 +21,22 @@ async function cmdUninstall(argv) {
   const codeHome = process.env.CODE_HOME || path.join(home, '.code');
   const codeConfigPath = path.join(codeHome, 'config.toml');
   const claudeSettingsPath = path.join(home, '.claude', 'settings.json');
+  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
+  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
+  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
   const notifyPath = path.join(binDir, 'notify.cjs');
   const notifyOriginalPath = path.join(trackerDir, 'codex_notify_original.json');
   const codeNotifyOriginalPath = path.join(trackerDir, 'code_notify_original.json');
   const codexNotifyCmd = ['/usr/bin/env', 'node', notifyPath];
   const codeNotifyCmd = ['/usr/bin/env', 'node', notifyPath, '--source=every-code'];
   const claudeHookCommand = buildClaudeHookCommand(notifyPath);
+  const geminiHookCommand = buildGeminiHookCommand(notifyPath);
 
   const codexConfigExists = await isFile(codexConfigPath);
   const codeConfigExists = await isFile(codeConfigPath);
   const claudeConfigExists = await isFile(claudeSettingsPath);
+  const geminiConfigExists = await isDir(geminiConfigDir);
+  const opencodeConfigExists = await isDir(opencodeConfigDir);
   const codexRestore = codexConfigExists
     ? await restoreCodexNotify({
         codexConfigPath,
@@ -41,6 +54,12 @@ async function cmdUninstall(argv) {
   const claudeRemove = claudeConfigExists
     ? await removeClaudeHook({ settingsPath: claudeSettingsPath, hookCommand: claudeHookCommand })
     : { removed: false, skippedReason: 'config-missing' };
+  const geminiRemove = geminiConfigExists
+    ? await removeGeminiHook({ settingsPath: geminiSettingsPath, hookCommand: geminiHookCommand })
+    : { removed: false, skippedReason: 'config-missing' };
+  const opencodeRemove = opencodeConfigExists
+    ? await removeOpencodePlugin({ configDir: opencodeConfigDir })
+    : { removed: false, skippedReason: 'config-missing' };
 
   // Remove installed notify handler.
   await fs.unlink(notifyPath).catch(() => {});
@@ -76,6 +95,22 @@ async function cmdUninstall(argv) {
             ? '- Claude hooks: no change'
             : '- Claude hooks: skipped'
         : '- Claude hooks: skipped (settings.json not found)',
+      geminiConfigExists
+        ? geminiRemove?.removed
+          ? `- Gemini hooks removed: ${geminiSettingsPath}`
+          : geminiRemove?.skippedReason === 'hook-missing'
+            ? '- Gemini hooks: no change'
+            : '- Gemini hooks: skipped'
+        : `- Gemini hooks: skipped (${geminiConfigDir} not found)`,
+      opencodeConfigExists
+        ? opencodeRemove?.removed
+          ? `- Opencode plugin removed: ${opencodeConfigDir}`
+          : opencodeRemove?.skippedReason === 'plugin-missing'
+            ? '- Opencode plugin: no change'
+            : opencodeRemove?.skippedReason === 'unexpected-content'
+              ? '- Opencode plugin: skipped (unexpected content)'
+              : '- Opencode plugin: skipped'
+        : `- Opencode plugin: skipped (${opencodeConfigDir} not found)`,
       opts.purge ? `- Purged: ${path.join(home, '.vibescore')}` : '- Purge: skipped (use --purge)',
       ''
     ].join('\n')
@@ -102,3 +137,12 @@ async function isFile(p) {
     return false;
   }
 }
+
+async function isDir(p) {
+  try {
+    const st = await fs.stat(p);
+    return st.isDirectory();
+  } catch (_e) {
+    return false;
+  }
+}

package/src/lib/browser-auth.js

@@ -7,10 +7,13 @@ const DEFAULT_BASE_URL = 'https://5tmappuk.us-east.insforge.app';
 async function beginBrowserAuth({ baseUrl, dashboardUrl, timeoutMs, open }) {
   const nonce = crypto.randomBytes(16).toString('hex');
   const callbackPath = `/vibescore/callback/${nonce}`;
-
-  const { callbackUrl, waitForCallback } = await startLocalCallbackServer({ callbackPath, timeoutMs });
-
   const authUrl = dashboardUrl ? new URL('/', dashboardUrl) : new URL('/auth/sign-up', baseUrl);
+  const postAuthRedirect = resolvePostAuthRedirect({ dashboardUrl, authUrl });
+  const { callbackUrl, waitForCallback } = await startLocalCallbackServer({
+    callbackPath,
+    timeoutMs,
+    redirectUrl: postAuthRedirect
+  });
   authUrl.searchParams.set('redirect', callbackUrl);
   if (dashboardUrl && baseUrl && baseUrl !== DEFAULT_BASE_URL) authUrl.searchParams.set('base_url', baseUrl);
 
@@ -19,7 +22,7 @@ async function beginBrowserAuth({ baseUrl, dashboardUrl, timeoutMs, open }) {
   return { authUrl: authUrl.toString(), waitForCallback };
 }
 
-async function startLocalCallbackServer({ callbackPath, timeoutMs }) {
+async function startLocalCallbackServer({ callbackPath, timeoutMs, redirectUrl }) {
   let resolved = false;
   let resolveResult;
   let rejectResult;
@@ -58,17 +61,34 @@ async function startLocalCallbackServer({ callbackPath, timeoutMs }) {
     }
 
     resolved = true;
-    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-    res.end(
-      [
-        '<!doctype html>',
-        '<html><head><meta charset="utf-8"><title>VibeScore</title></head>',
-        '<body>',
-        '<h2>Login succeeded</h2>',
-        '<p>You can close this tab and return to the CLI.</p>',
-        '</body></html>'
-      ].join('')
-    );
+    if (redirectUrl) {
+      res.writeHead(302, {
+        Location: redirectUrl,
+        'Content-Type': 'text/html; charset=utf-8'
+      });
+      res.end(
+        [
+          '<!doctype html>',
+          '<html><head><meta charset="utf-8"><title>VibeScore</title></head>',
+          '<body>',
+          '<h2>Login succeeded</h2>',
+          `<p>Redirecting to <a href="${redirectUrl}">dashboard</a>...</p>`,
+          '</body></html>'
+        ].join('')
+      );
+    } else {
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(
+        [
+          '<!doctype html>',
+          '<html><head><meta charset="utf-8"><title>VibeScore</title></head>',
+          '<body>',
+          '<h2>Login succeeded</h2>',
+          '<p>You can close this tab and return to the CLI.</p>',
+          '</body></html>'
+        ].join('')
+      );
+    }
 
     resolveResult({
       accessToken,
@@ -134,6 +154,21 @@ function openInBrowser(url) {
   } catch (_e) {}
 }
 
+function resolvePostAuthRedirect({ dashboardUrl, authUrl }) {
+  try {
+    if (dashboardUrl) {
+      const target = new URL('/', dashboardUrl);
+      if (target.protocol === 'http:' || target.protocol === 'https:') {
+        return target.toString();
+      }
+      return null;
+    }
+  } catch (_e) {
+    return null;
+  }
+  return null;
+}
+
 module.exports = {
   beginBrowserAuth
 };

package/src/lib/diagnostics.js

@@ -5,6 +5,13 @@ const fs = require('node:fs/promises');
 const { readJson } = require('./fs');
 const { readCodexNotify, readEveryCodeNotify } = require('./codex-config');
 const { isClaudeHookConfigured, buildClaudeHookCommand } = require('./claude-config');
+const {
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  buildGeminiHookCommand,
+  isGeminiHookConfigured
+} = require('./gemini-config');
+const { resolveOpencodeConfigDir, isOpencodePluginInstalled } = require('./opencode-config');
 const { normalizeState: normalizeUploadState } = require('./upload-throttle');
 
 async function collectTrackerDiagnostics({
@@ -24,6 +31,9 @@ async function collectTrackerDiagnostics({
   const codexConfigPath = path.join(codexHome, 'config.toml');
   const codeConfigPath = path.join(codeHome, 'config.toml');
   const claudeConfigPath = path.join(home, '.claude', 'settings.json');
+  const geminiConfigDir = resolveGeminiConfigDir({ home, env: process.env });
+  const geminiSettingsPath = resolveGeminiSettingsPath({ configDir: geminiConfigDir });
+  const opencodeConfigDir = resolveOpencodeConfigDir({ home, env: process.env });
 
   const config = await readJson(configPath);
   const cursors = await readJson(cursorsPath);
@@ -49,6 +59,12 @@ async function collectTrackerDiagnostics({
     settingsPath: claudeConfigPath,
     hookCommand: claudeHookCommand
   });
+  const geminiHookCommand = buildGeminiHookCommand(path.join(home, '.vibescore', 'bin', 'notify.cjs'));
+  const geminiHookConfigured = await isGeminiHookConfigured({
+    settingsPath: geminiSettingsPath,
+    hookCommand: geminiHookCommand
+  });
+  const opencodePluginConfigured = await isOpencodePluginInstalled({ configDir: opencodeConfigDir });
 
   const lastSuccessAt = uploadThrottle.lastSuccessMs ? new Date(uploadThrottle.lastSuccessMs).toISOString() : null;
   const autoRetryAt = parseEpochMsToIso(autoRetry?.retryAtMs);
@@ -68,7 +84,9 @@ async function collectTrackerDiagnostics({
       codex_config: redactValue(codexConfigPath, home),
       code_home: redactValue(codeHome, home),
       code_config: redactValue(codeConfigPath, home),
-      claude_config: redactValue(claudeConfigPath, home)
+      claude_config: redactValue(claudeConfigPath, home),
+      gemini_config: redactValue(geminiSettingsPath, home),
+      opencode_config: redactValue(opencodeConfigDir, home)
     },
     config: {
       base_url: typeof config?.baseUrl === 'string' ? config.baseUrl : null,
@@ -93,7 +111,9 @@ async function collectTrackerDiagnostics({
       codex_notify: codexNotify,
       every_code_notify_configured: everyCodeConfigured,
       every_code_notify: everyCodeNotify,
-      claude_hook_configured: claudeHookConfigured
+      claude_hook_configured: claudeHookConfigured,
+      gemini_hook_configured: geminiHookConfigured,
+      opencode_plugin_configured: opencodePluginConfigured
     },
     upload: {
       last_success_at: lastSuccessAt,

package/src/lib/gemini-config.js

@@ -0,0 +1,284 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+const { ensureDir, readJson, writeJson } = require('./fs');
+
+const DEFAULT_EVENT = 'SessionEnd';
+const DEFAULT_HOOK_NAME = 'vibescore-tracker';
+const DEFAULT_MATCHER = 'exit|clear|logout|prompt_input_exit|other';
+
+function resolveGeminiConfigDir({ home = os.homedir(), env = process.env } = {}) {
+  const explicit = typeof env.GEMINI_HOME === 'string' ? env.GEMINI_HOME.trim() : '';
+  if (explicit) return path.resolve(explicit);
+  return path.join(home, '.gemini');
+}
+
+function resolveGeminiSettingsPath({ configDir }) {
+  return path.join(configDir, 'settings.json');
+}
+
+async function upsertGeminiHook({
+  settingsPath,
+  hookCommand,
+  hookName = DEFAULT_HOOK_NAME,
+  matcher = DEFAULT_MATCHER,
+  event = DEFAULT_EVENT
+}) {
+  const existing = await readJson(settingsPath);
+  const settings = normalizeSettings(existing);
+  const enableResult = ensureHooksEnabled(settings);
+  const baseSettings = enableResult.settings;
+  const hooks = normalizeHooks(settings.hooks);
+  const entries = normalizeEntries(hooks[event]);
+
+  const normalized = normalizeEntriesForHook(entries, { hookCommand, hookName });
+  let nextEntries = normalized.entries;
+  let changed = normalized.changed || enableResult.changed;
+
+  if (!hasHook(nextEntries, { hookCommand, hookName })) {
+    nextEntries = nextEntries.concat([buildHookEntry({ hookCommand, hookName, matcher })]);
+    changed = true;
+  }
+
+  if (!changed) return { changed: false, backupPath: null };
+
+  const nextHooks = { ...hooks, [event]: nextEntries };
+  const nextSettings = { ...baseSettings, hooks: nextHooks };
+  const backupPath = await writeGeminiSettings({ settingsPath, settings: nextSettings });
+  return { changed: true, backupPath };
+}
+
+async function removeGeminiHook({
+  settingsPath,
+  hookCommand,
+  hookName = DEFAULT_HOOK_NAME,
+  event = DEFAULT_EVENT
+}) {
+  const existing = await readJson(settingsPath);
+  if (!existing) return { removed: false, skippedReason: 'settings-missing' };
+
+  const settings = normalizeSettings(existing);
+  const hooks = normalizeHooks(settings.hooks);
+  const entries = normalizeEntries(hooks[event]);
+  if (entries.length === 0) return { removed: false, skippedReason: 'hook-missing' };
+
+  let removed = false;
+  const nextEntries = [];
+  for (const entry of entries) {
+    const res = stripHookFromEntry(entry, { hookCommand, hookName });
+    if (res.removed) removed = true;
+    if (res.entry) nextEntries.push(res.entry);
+  }
+
+  if (!removed) return { removed: false, skippedReason: 'hook-missing' };
+
+  const nextHooks = { ...hooks };
+  if (nextEntries.length > 0) nextHooks[event] = nextEntries;
+  else delete nextHooks[event];
+
+  const nextSettings = { ...settings };
+  if (Object.keys(nextHooks).length > 0) nextSettings.hooks = nextHooks;
+  else delete nextSettings.hooks;
+
+  const backupPath = await writeGeminiSettings({ settingsPath, settings: nextSettings });
+  return { removed: true, skippedReason: null, backupPath };
+}
+
+async function isGeminiHookConfigured({
+  settingsPath,
+  hookCommand,
+  hookName = DEFAULT_HOOK_NAME,
+  event = DEFAULT_EVENT
+}) {
+  const settings = await readJson(settingsPath);
+  if (!settings || typeof settings !== 'object') return false;
+  const hooks = settings.hooks;
+  if (!hooks || typeof hooks !== 'object') return false;
+  const entries = normalizeEntries(hooks[event]);
+  return hasHook(entries, { hookCommand, hookName });
+}
+
+function buildGeminiHookCommand(notifyPath) {
+  const cmd = typeof notifyPath === 'string' ? notifyPath : '';
+  return `/usr/bin/env node ${quoteArg(cmd)} --source=gemini`;
+}
+
+function buildHookEntry({ hookCommand, hookName, matcher }) {
+  const hook = {
+    name: hookName,
+    type: 'command',
+    command: hookCommand
+  };
+  const entry = { hooks: [hook] };
+  if (typeof matcher === 'string' && matcher.length > 0) entry.matcher = matcher;
+  return entry;
+}
+
+function normalizeSettings(raw) {
+  return raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+}
+
+function normalizeHooks(raw) {
+  return raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+}
+
+function normalizeTools(raw) {
+  return raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+}
+
+function normalizeEntries(raw) {
+  return Array.isArray(raw) ? raw.slice() : [];
+}
+
+function normalizeCommand(cmd) {
+  if (Array.isArray(cmd)) return cmd.map((v) => String(v)).join('\u0000');
+  if (typeof cmd === 'string') return cmd.trim();
+  return null;
+}
+
+function normalizeName(name) {
+  if (typeof name !== 'string') return null;
+  const trimmed = name.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function ensureHooksEnabled(settings) {
+  const tools = normalizeTools(settings.tools);
+  if (tools.enableHooks === true) return { settings, changed: false };
+  const nextTools = { ...tools, enableHooks: true };
+  return { settings: { ...settings, tools: nextTools }, changed: true };
+}
+
+function hookMatches(hook, { hookCommand, hookName, requireCommand = false }) {
+  if (!hook || typeof hook !== 'object') return false;
+  const name = normalizeName(hook.name);
+  const targetName = normalizeName(hookName);
+  const cmd = normalizeCommand(hook.command);
+  const targetCmd = normalizeCommand(hookCommand);
+  const commandMatches = Boolean(cmd && targetCmd && cmd === targetCmd);
+  if (requireCommand) return commandMatches;
+  const nameMatches = Boolean(name && targetName && name === targetName);
+  return Boolean(commandMatches || nameMatches);
+}
+
+function entryMatches(entry, { hookCommand, hookName, requireCommand = false }) {
+  if (!entry || typeof entry !== 'object') return false;
+  if (entry.command || entry.name) return hookMatches(entry, { hookCommand, hookName, requireCommand });
+  if (!Array.isArray(entry.hooks)) return false;
+  return entry.hooks.some((hook) => hookMatches(hook, { hookCommand, hookName, requireCommand }));
+}
+
+function hasHook(entries, { hookCommand, hookName }) {
+  return entries.some((entry) => entryMatches(entry, { hookCommand, hookName }));
+}
+
+function normalizeEntriesForHook(entries, { hookCommand, hookName }) {
+  let changed = false;
+  const nextEntries = entries.map((entry) => {
+    if (!entry || typeof entry !== 'object') return entry;
+
+    if (entry.command || entry.name) {
+      if (hookMatches(entry, { hookCommand, hookName })) {
+        const next = normalizeHookObject(entry, { hookCommand, hookName });
+        if (next !== entry) changed = true;
+        return next;
+      }
+      return entry;
+    }
+
+    const hooks = Array.isArray(entry.hooks) ? entry.hooks : null;
+    if (!hooks) return entry;
+
+    let hooksChanged = false;
+    const nextHooks = hooks.map((hook) => {
+      if (hookMatches(hook, { hookCommand, hookName })) {
+        const next = normalizeHookObject(hook, { hookCommand, hookName });
+        if (next !== hook) hooksChanged = true;
+        return next;
+      }
+      return hook;
+    });
+
+    if (!hooksChanged) return entry;
+    changed = true;
+    return { ...entry, hooks: nextHooks };
+  });
+
+  return { entries: nextEntries, changed };
+}
+
+function normalizeHookObject(hook, { hookCommand, hookName }) {
+  const next = { ...hook };
+  let changed = false;
+
+  if (next.type !== 'command') {
+    next.type = 'command';
+    changed = true;
+  }
+
+  if (hookCommand && next.command !== hookCommand) {
+    next.command = hookCommand;
+    changed = true;
+  }
+
+  if (hookName && next.name !== hookName) {
+    next.name = hookName;
+    changed = true;
+  }
+
+  return changed ? next : hook;
+}
+
+function stripHookFromEntry(entry, { hookCommand, hookName }) {
+  if (!entry || typeof entry !== 'object') return { entry, removed: false };
+
+  if (entry.command || entry.name) {
+    if (hookMatches(entry, { hookCommand, hookName, requireCommand: true })) return { entry: null, removed: true };
+    return { entry, removed: false };
+  }
+
+  const hooks = Array.isArray(entry.hooks) ? entry.hooks : null;
+  if (!hooks) return { entry, removed: false };
+
+  const nextHooks = hooks.filter((hook) => !hookMatches(hook, { hookCommand, hookName, requireCommand: true }));
+  if (nextHooks.length === hooks.length) return { entry, removed: false };
+  if (nextHooks.length === 0) return { entry: null, removed: true };
+
+  return { entry: { ...entry, hooks: nextHooks }, removed: true };
+}
+
+function quoteArg(value) {
+  const v = typeof value === 'string' ? value : '';
+  if (!v) return '""';
+  if (/^[A-Za-z0-9_\-./:@]+$/.test(v)) return v;
+  return `"${v.replace(/"/g, '\\"')}"`;
+}
+
+async function writeGeminiSettings({ settingsPath, settings }) {
+  await ensureDir(path.dirname(settingsPath));
+  let backupPath = null;
+  try {
+    const st = await fs.stat(settingsPath);
+    if (st && st.isFile()) {
+      backupPath = `${settingsPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
+      await fs.copyFile(settingsPath, backupPath);
+    }
+  } catch (_e) {
+    // Ignore missing file.
+  }
+  await writeJson(settingsPath, settings);
+  return backupPath;
+}
+
+module.exports = {
+  DEFAULT_EVENT,
+  DEFAULT_HOOK_NAME,
+  DEFAULT_MATCHER,
+  resolveGeminiConfigDir,
+  resolveGeminiSettingsPath,
+  buildGeminiHookCommand,
+  upsertGeminiHook,
+  removeGeminiHook,
+  isGeminiHookConfigured
+};

package/src/lib/opencode-config.js

@@ -0,0 +1,98 @@
+const os = require('node:os');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+
+const { ensureDir } = require('./fs');
+
+const DEFAULT_PLUGIN_NAME = 'vibescore-tracker.js';
+const PLUGIN_MARKER = 'VIBESCORE_TRACKER_PLUGIN';
+const DEFAULT_EVENT = 'session.idle';
+
+function resolveOpencodeConfigDir({ home = os.homedir(), env = process.env } = {}) {
+  const explicit = typeof env.OPENCODE_CONFIG_DIR === 'string' ? env.OPENCODE_CONFIG_DIR.trim() : '';
+  if (explicit) return path.resolve(explicit);
+  const xdg = typeof env.XDG_CONFIG_HOME === 'string' ? env.XDG_CONFIG_HOME.trim() : '';
+  const base = xdg || path.join(home, '.config');
+  return path.join(base, 'opencode');
+}
+
+function resolveOpencodePluginDir({ configDir }) {
+  return path.join(configDir, 'plugin');
+}
+
+function buildOpencodePlugin({ notifyPath }) {
+  const safeNotifyPath = typeof notifyPath === 'string' ? notifyPath : '';
+  return `// ${PLUGIN_MARKER}\n` +
+    `const notifyPath = ${JSON.stringify(safeNotifyPath)};\n` +
+    `export const VibeScorePlugin = async ({ $ }) => {\n` +
+    `  return {\n` +
+    `    event: async ({ event }) => {\n` +
+    `      if (!event || event.type !== ${JSON.stringify(DEFAULT_EVENT)}) return;\n` +
+    `      try {\n` +
+    `        if (!notifyPath) return;\n` +
+    `        const proc = $\`/usr/bin/env node ${'${notifyPath}'} --source=opencode\`;\n` +
+    `        if (proc && typeof proc.catch === 'function') proc.catch(() => {});\n` +
+    `      } catch (_) {}\n` +
+    `    }\n` +
+    `  };\n` +
+    `};\n`;
+}
+
+async function upsertOpencodePlugin({
+  configDir,
+  notifyPath,
+  pluginName = DEFAULT_PLUGIN_NAME
+}) {
+  if (!configDir) return { changed: false, pluginPath: null, skippedReason: 'config-missing' };
+  const pluginDir = resolveOpencodePluginDir({ configDir });
+  const pluginPath = path.join(pluginDir, pluginName);
+  const next = buildOpencodePlugin({ notifyPath });
+  const existing = await fs.readFile(pluginPath, 'utf8').catch(() => null);
+
+  if (existing === next) {
+    return { changed: false, pluginPath, skippedReason: null };
+  }
+
+  await ensureDir(pluginDir);
+
+  let backupPath = null;
+  if (existing != null) {
+    backupPath = `${pluginPath}.bak.${new Date().toISOString().replace(/[:.]/g, '-')}`;
+    await fs.copyFile(pluginPath, backupPath).catch(() => {});
+  }
+
+  await fs.writeFile(pluginPath, next, 'utf8');
+  return { changed: true, pluginPath, backupPath, skippedReason: null };
+}
+
+async function removeOpencodePlugin({ configDir, pluginName = DEFAULT_PLUGIN_NAME }) {
+  if (!configDir) return { removed: false, skippedReason: 'config-missing' };
+  const pluginPath = path.join(resolveOpencodePluginDir({ configDir }), pluginName);
+  const existing = await fs.readFile(pluginPath, 'utf8').catch(() => null);
+  if (existing == null) return { removed: false, skippedReason: 'plugin-missing' };
+  if (!hasPluginMarker(existing)) return { removed: false, skippedReason: 'unexpected-content' };
+  await fs.unlink(pluginPath).catch(() => {});
+  return { removed: true, skippedReason: null };
+}
+
+async function isOpencodePluginInstalled({ configDir, pluginName = DEFAULT_PLUGIN_NAME }) {
+  if (!configDir) return false;
+  const pluginPath = path.join(resolveOpencodePluginDir({ configDir }), pluginName);
+  const existing = await fs.readFile(pluginPath, 'utf8').catch(() => null);
+  if (!existing) return false;
+  return hasPluginMarker(existing);
+}
+
+function hasPluginMarker(text) {
+  return typeof text === 'string' && text.includes(PLUGIN_MARKER);
+}
+
+module.exports = {
+  DEFAULT_PLUGIN_NAME,
+  resolveOpencodeConfigDir,
+  resolveOpencodePluginDir,
+  buildOpencodePlugin,
+  upsertOpencodePlugin,
+  removeOpencodePlugin,
+  isOpencodePluginInstalled
+};

package/src/lib/rollout.js

@@ -61,6 +61,14 @@ async function listGeminiSessionFiles(tmpDir) {
   return out;
 }
 
+async function listOpencodeMessageFiles(storageDir) {
+  const out = [];
+  const messageDir = path.join(storageDir, 'message');
+  await walkOpencodeMessages(messageDir, out);
+  out.sort((a, b) => a.localeCompare(b));
+  return out;
+}
+
 async function parseRolloutIncremental({ rolloutFiles, cursors, queuePath, onProgress, source }) {
   await ensureDir(path.dirname(queuePath));
   let filesProcessed = 0;
@@ -270,6 +278,91 @@ async function parseGeminiIncremental({ sessionFiles, cursors, queuePath, onProg
   return { filesProcessed, eventsAggregated, bucketsQueued };
 }
 
+async function parseOpencodeIncremental({ messageFiles, cursors, queuePath, onProgress, source }) {
+  await ensureDir(path.dirname(queuePath));
+  let filesProcessed = 0;
+  let eventsAggregated = 0;
+
+  const cb = typeof onProgress === 'function' ? onProgress : null;
+  const files = Array.isArray(messageFiles) ? messageFiles : [];
+  const totalFiles = files.length;
+  const hourlyState = normalizeHourlyState(cursors?.hourly);
+  const touchedBuckets = new Set();
+  const defaultSource = normalizeSourceInput(source) || 'opencode';
+
+  if (!cursors.files || typeof cursors.files !== 'object') {
+    cursors.files = {};
+  }
+
+  for (let idx = 0; idx < files.length; idx++) {
+    const entry = files[idx];
+    const filePath = typeof entry === 'string' ? entry : entry?.path;
+    if (!filePath) continue;
+    const fileSource =
+      typeof entry === 'string' ? defaultSource : normalizeSourceInput(entry?.source) || defaultSource;
+    const st = await fs.stat(filePath).catch(() => null);
+    if (!st || !st.isFile()) continue;
+
+    const key = filePath;
+    const prev = cursors.files[key] || null;
+    const inode = st.ino || 0;
+    const size = Number.isFinite(st.size) ? st.size : 0;
+    const mtimeMs = Number.isFinite(st.mtimeMs) ? st.mtimeMs : 0;
+    const unchanged = prev && prev.inode === inode && prev.size === size && prev.mtimeMs === mtimeMs;
+    if (unchanged) {
+      filesProcessed += 1;
+      if (cb) {
+        cb({
+          index: idx + 1,
+          total: totalFiles,
+          filePath,
+          filesProcessed,
+          eventsAggregated,
+          bucketsQueued: touchedBuckets.size
+        });
+      }
+      continue;
+    }
+
+    const lastTotals = prev && prev.inode === inode ? prev.lastTotals || null : null;
+    const result = await parseOpencodeMessageFile({
+      filePath,
+      lastTotals,
+      hourlyState,
+      touchedBuckets,
+      source: fileSource
+    });
+
+    cursors.files[key] = {
+      inode,
+      size,
+      mtimeMs,
+      lastTotals: result.lastTotals,
+      updatedAt: new Date().toISOString()
+    };
+
+    filesProcessed += 1;
+    eventsAggregated += result.eventsAggregated;
+
+    if (cb) {
+      cb({
+        index: idx + 1,
+        total: totalFiles,
+        filePath,
+        filesProcessed,
+        eventsAggregated,
+        bucketsQueued: touchedBuckets.size
+      });
+    }
+  }
+
+  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
+  hourlyState.updatedAt = new Date().toISOString();
+  cursors.hourly = hourlyState;
+
+  return { filesProcessed, eventsAggregated, bucketsQueued };
+}
+
 async function parseRolloutFile({
   filePath,
   startOffset,
@@ -457,6 +550,37 @@ async function parseGeminiFile({
   };
 }
 
+async function parseOpencodeMessageFile({ filePath, lastTotals, hourlyState, touchedBuckets, source }) {
+  const raw = await fs.readFile(filePath, 'utf8').catch(() => '');
+  if (!raw.trim()) return { lastTotals, eventsAggregated: 0 };
+
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch (_e) {
+    return { lastTotals, eventsAggregated: 0 };
+  }
+
+  const currentTotals = normalizeOpencodeTokens(msg?.tokens);
+  if (!currentTotals) return { lastTotals, eventsAggregated: 0 };
+
+  const delta = diffGeminiTotals(currentTotals, lastTotals);
+  if (!delta || isAllZeroUsage(delta)) return { lastTotals: currentTotals, eventsAggregated: 0 };
+
+  const timestampMs = coerceEpochMs(msg?.time?.completed) || coerceEpochMs(msg?.time?.created);
+  if (!timestampMs) return { lastTotals, eventsAggregated: 0 };
+
+  const tsIso = new Date(timestampMs).toISOString();
+  const bucketStart = toUtcHalfHourStart(tsIso);
+  if (!bucketStart) return { lastTotals, eventsAggregated: 0 };
+
+  const model = normalizeModelInput(msg?.modelID) || DEFAULT_MODEL;
+  const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
+  addTotals(bucket.totals, delta);
+  touchedBuckets.add(bucketKey(source, model, bucketStart));
+  return { lastTotals: currentTotals, eventsAggregated: 1 };
+}
+
 async function enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets }) {
   if (!touchedBuckets || touchedBuckets.size === 0) return 0;
 
@@ -984,6 +1108,23 @@ function normalizeGeminiTokens(tokens) {
   };
 }
 
+function normalizeOpencodeTokens(tokens) {
+  if (!tokens || typeof tokens !== 'object') return null;
+  const input = toNonNegativeInt(tokens.input);
+  const output = toNonNegativeInt(tokens.output);
+  const reasoning = toNonNegativeInt(tokens.reasoning);
+  const cached = toNonNegativeInt(tokens.cache?.read);
+  const total = input + output + reasoning;
+
+  return {
+    input_tokens: input,
+    cached_input_tokens: cached,
+    output_tokens: output,
+    reasoning_output_tokens: reasoning,
+    total_tokens: total
+  };
+}
+
 function sameGeminiTotals(a, b) {
   if (!a || !b) return false;
   return (
@@ -1125,6 +1266,13 @@ function toNonNegativeInt(v) {
   return Math.floor(n);
 }
 
+function coerceEpochMs(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  if (n < 1e12) return Math.floor(n * 1000);
+  return Math.floor(n);
+}
+
 async function safeReadDir(dir) {
   try {
     return await fs.readdir(dir, { withFileTypes: true });
@@ -1145,11 +1293,25 @@ async function walkClaudeProjects(dir, out) {
   }
 }
 
+async function walkOpencodeMessages(dir, out) {
+  const entries = await safeReadDir(dir);
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkOpencodeMessages(fullPath, out);
+      continue;
+    }
+    if (entry.isFile() && entry.name.startsWith('msg_') && entry.name.endsWith('.json')) out.push(fullPath);
+  }
+}
+
 module.exports = {
   listRolloutFiles,
   listClaudeProjectFiles,
   listGeminiSessionFiles,
+  listOpencodeMessageFiles,
   parseRolloutIncremental,
   parseClaudeIncremental,
-  parseGeminiIncremental
+  parseGeminiIncremental,
+  parseOpencodeIncremental
 };