vibeusage 0.2.8

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 = 'vibeusage-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/init-flow.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const { formatSummaryLine, renderBox, underline } = require('./cli-ui');
+
+const DIVIDER = '----------------------------------------------';
+
+function renderLocalReport({ summary, isDryRun }) {
+  const header = isDryRun
+    ? 'Dry run complete. Preview only; no changes were applied.'
+    : 'Local configuration complete.';
+  const lines = [header, '', 'Integration Status:'];
+  for (const item of summary || []) lines.push(formatSummaryLine(item));
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function renderAuthTransition({ authUrl, canAutoOpen }) {
+  const lines = ['', DIVIDER, '', 'Next: Registering device...'];
+  if (canAutoOpen) {
+    lines.push('Opening your browser to link account...');
+    if (authUrl) lines.push(`If it does not open, visit: ${underline(authUrl)}`);
+  } else {
+    lines.push('Open the link below to sign in.');
+    if (authUrl) lines.push(`Visit: ${underline(authUrl)}`);
+  }
+  lines.push('');
+  process.stdout.write(`${lines.join('\n')}\n`);
+}
+
+function renderSuccessBox({ configPath, dashboardUrl }) {
+  const identityLine = 'Account linked.';
+  const lines = [
+    'You are all set!',
+    '',
+    identityLine,
+    `Token saved to: ${configPath}`,
+    ''
+  ];
+  if (dashboardUrl) lines.push(`View your stats at: ${dashboardUrl}`);
+  lines.push('You can close this terminal window.');
+  process.stdout.write(`${renderBox(lines)}\n`);
+}
+
+module.exports = {
+  DIVIDER,
+  renderLocalReport,
+  renderAuthTransition,
+  renderSuccessBox
+};

package/src/lib/insforge-client.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const { createClient } = require('@insforge/sdk');
+
+function getAnonKey({ env = process.env } = {}) {
+  return (
+    env.VIBEUSAGE_INSFORGE_ANON_KEY ||
+    env.VIBESCORE_INSFORGE_ANON_KEY ||
+    env.INSFORGE_ANON_KEY ||
+    ''
+  );
+}
+
+function getHttpTimeoutMs({ env = process.env } = {}) {
+  const raw = readEnvValue(env, ['VIBEUSAGE_HTTP_TIMEOUT_MS', 'VIBESCORE_HTTP_TIMEOUT_MS']);
+  if (raw == null || raw === '') return 20_000;
+  const n = Number(raw);
+  if (!Number.isFinite(n)) return 20_000;
+  if (n <= 0) return 0;
+  return clampInt(n, 1000, 120_000);
+}
+
+function createTimeoutFetch(baseFetch) {
+  if (!baseFetch) return baseFetch;
+  return async (input, init = {}) => {
+    const timeoutMs = getHttpTimeoutMs();
+    if (!timeoutMs) return baseFetch(input, init);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      return await baseFetch(input, { ...init, signal: controller.signal });
+    } catch (err) {
+      if (controller.signal.aborted) {
+        const timeoutErr = new Error(`Request timeout after ${timeoutMs}ms`);
+        timeoutErr.cause = err;
+        throw timeoutErr;
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  };
+}
+
+function createInsforgeClient({ baseUrl, accessToken } = {}) {
+  if (!baseUrl) throw new Error('Missing baseUrl');
+  const anonKey = getAnonKey();
+  return createClient({
+    baseUrl,
+    anonKey: anonKey || undefined,
+    edgeFunctionToken: accessToken || undefined,
+    fetch: createTimeoutFetch(globalThis.fetch)
+  });
+}
+
+function clampInt(value, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return min;
+  return Math.min(max, Math.max(min, Math.floor(n)));
+}
+
+function readEnvValue(env, keys) {
+  if (!env || !Array.isArray(keys)) return undefined;
+  for (const key of keys) {
+    const value = env?.[key];
+    if (value != null && value !== '') return value;
+  }
+  return undefined;
+}
+
+module.exports = {
+  createInsforgeClient,
+  getAnonKey,
+  getHttpTimeoutMs
+};

package/src/lib/insforge.js

@@ -0,0 +1,23 @@
+const { exchangeLinkCode, issueDeviceToken, signInWithPassword } = require('./vibescore-api');
+
+async function issueDeviceTokenWithPassword({ baseUrl, email, password, deviceName }) {
+  const accessToken = await signInWithPassword({ baseUrl, email, password });
+  const issued = await issueDeviceToken({ baseUrl, accessToken, deviceName });
+  return issued;
+}
+
+async function issueDeviceTokenWithAccessToken({ baseUrl, accessToken, deviceName }) {
+  const issued = await issueDeviceToken({ baseUrl, accessToken, deviceName });
+  return issued;
+}
+
+async function issueDeviceTokenWithLinkCode({ baseUrl, linkCode, requestId, deviceName, platform }) {
+  const issued = await exchangeLinkCode({ baseUrl, linkCode, requestId, deviceName, platform });
+  return { token: issued.token, deviceId: issued.deviceId };
+}
+
+module.exports = {
+  issueDeviceTokenWithPassword,
+  issueDeviceTokenWithAccessToken,
+  issueDeviceTokenWithLinkCode
+};

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 = 'vibeusage-tracker.js';
+const PLUGIN_MARKER = 'VIBEUSAGE_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 VibeUsagePlugin = 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/progress.js

@@ -0,0 +1,77 @@
+function createProgress({ stream } = {}) {
+  const out = stream || process.stdout;
+  const enabled = Boolean(out && out.isTTY);
+  const frames = ['|', '/', '-', '\\'];
+  const intervalMs = 90;
+
+  let timer = null;
+  let text = '';
+  let frame = 0;
+  let lastLen = 0;
+
+  function render() {
+    if (!enabled) return;
+    const line = `${frames[frame++ % frames.length]} ${text}`;
+    const pad = lastLen > line.length ? ' '.repeat(lastLen - line.length) : '';
+    lastLen = line.length;
+    out.write(`\r${line}${pad}`);
+  }
+
+  function start(initialText) {
+    if (!enabled) return;
+    text = initialText || '';
+    if (timer) clearInterval(timer);
+    timer = setInterval(render, intervalMs);
+    render();
+  }
+
+  function update(nextText) {
+    text = nextText || '';
+    render();
+  }
+
+  function stop() {
+    if (!enabled) return;
+    if (timer) clearInterval(timer);
+    timer = null;
+    out.write(`\r${' '.repeat(lastLen)}\r`);
+    lastLen = 0;
+  }
+
+  return { enabled, start, update, stop };
+}
+
+function renderBar(progress, width = 20) {
+  const p = Number.isFinite(progress) ? Math.min(1, Math.max(0, progress)) : 0;
+  const filled = Math.round(p * width);
+  const empty = Math.max(0, width - filled);
+  return `[${'='.repeat(filled)}${'-'.repeat(empty)}] ${Math.round(p * 100)}%`;
+}
+
+function formatNumber(n) {
+  const v = Number(n);
+  if (!Number.isFinite(v)) return '0';
+  return Math.trunc(v).toLocaleString('en-US');
+}
+
+function formatBytes(bytes) {
+  const n = Number(bytes);
+  if (!Number.isFinite(n) || n <= 0) return '0 B';
+  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+  let v = n;
+  let i = 0;
+  while (v >= 1024 && i < units.length - 1) {
+    v /= 1024;
+    i += 1;
+  }
+  const fixed = i === 0 ? String(Math.trunc(v)) : v.toFixed(v >= 10 ? 1 : 2);
+  return `${fixed} ${units[i]}`;
+}
+
+module.exports = {
+  createProgress,
+  renderBar,
+  formatNumber,
+  formatBytes
+};
+

package/src/lib/prompt.js

@@ -0,0 +1,20 @@
+const readline = require('node:readline');
+
+async function prompt(label) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const value = await new Promise((resolve) => rl.question(label, resolve));
+  rl.close();
+  return String(value || '').trim();
+}
+
+async function promptHidden(label) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+  const value = await new Promise((resolve) => {
+    rl._writeToOutput = function _writeToOutput() {};
+    rl.question(label, (answer) => resolve(answer));
+  });
+  rl.close();
+  return String(value || '').trim();
+}
+
+module.exports = { prompt, promptHidden };