Vibe Usage

node_modules/
.env
.env.local
*.tgz

#!/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));

{
  "name": "@vibe-cafe/vibe-usage",
  "version": "0.9.2",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "@vibe-cafe/vibe-usage",
      "version": "0.9.2",
      "license": "MIT",
      "bin": {
        "vibe-usage": "bin/vibe-usage.js"
      },
      "engines": {
        "node": ">=20"
      }
    }
  }
}

{
  "name": "@vibe-cafe/vibe-usage",
  "version": "0.9.4",
  "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": {},
  "repository": {
    "type": "git",
    "url": "git+https://github.com/vibe-cafe/vibe-usage.git"
  },
  "homepage": "https://github.com/vibe-cafe/vibe-usage#readme",
  "bugs": {
    "url": "https://github.com/vibe-cafe/vibe-usage/issues"
  },
  "license": "MIT"
}

import https from 'node:https';
import http from 'node:http';
import { URL } from 'node:url';
import { gzipSync } from 'node:zlib';

const MAX_RETRIES = 3;
const INITIAL_DELAY = 1000;
// Always gzip: ingest bodies are repetitive JSON that compresses ~10:1, and
// the few-byte gzip header overhead on a tiny body is irrelevant next to
// guaranteeing no uncompressed request ever leaves the client.
const GZIP_MIN_BYTES = 0;

export async function ingest(apiUrl, apiKey, buckets, opts, sessions) {
  let lastError;
  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
    try {
      return await _send(apiUrl, apiKey, buckets, opts?.onProgress, sessions);
    } 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, onProgress, sessions) {
  return new Promise((resolve, reject) => {
    const url = new URL('/api/usage/ingest', apiUrl);
    const payload = { buckets };
    if (sessions && sessions.length > 0) payload.sessions = sessions;
    const raw = Buffer.from(JSON.stringify(payload));
    const useGzip = raw.length >= GZIP_MIN_BYTES;
    const body = useGzip ? gzipSync(raw) : raw;
    const totalBytes = body.length;
    const mod = url.protocol === 'https:' ? https : http;

    const headers = {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${apiKey}`,
      'Content-Length': totalBytes,
    };
    if (useGzip) headers['Content-Encoding'] = 'gzip';

    const req = mod.request(url, {
      method: 'POST',
      timeout: 60_000,
      headers,
    }, (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) {
          const err = new Error(`HTTP ${res.statusCode}: ${data}`);
          err.statusCode = res.statusCode;
          reject(err);
          return;
        }
        try {
          resolve(JSON.parse(data));
        } catch {
          reject(new Error(`Invalid JSON response: ${data}`));
        }
      });
    });

    req.on('error', (err) => reject(err));
    req.on('timeout', () => {
      req.destroy();
      reject(new Error('Request timed out (60s)'));
    });

    // Write body in chunks to report upload progress
    const CHUNK = 16 * 1024;
    let sent = 0;

    function writeNext() {
      let ok = true;
      while (ok && sent < totalBytes) {
        const slice = body.subarray(sent, sent + CHUNK);
        sent += slice.length;
        if (onProgress) onProgress(sent, totalBytes);
        ok = req.write(slice);
      }
      if (sent < totalBytes) {
        req.once('drain', writeNext);
      } else {
        req.end();
      }
    }

    writeNext();
  });
}

/**
 * DELETE usage data for the authenticated user.
 * @param {string} apiUrl
 * @param {string} apiKey
 * @param {{hostname?: string}} [opts]
 * @returns {Promise<{deleted: number}>}
 */
export function deleteAllData(apiUrl, apiKey, opts) {
  return new Promise((resolve, reject) => {
    const url = new URL('/api/usage/ingest', apiUrl);
    if (opts?.hostname) url.searchParams.set('hostname', opts.hostname);
    const mod = url.protocol === 'https:' ? https : http;

    const req = mod.request(url, {
      method: 'DELETE',
      timeout: 60_000,
      headers: {
        'Authorization': `Bearer ${apiKey}`,
      },
    }, (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) {
          const err = new Error(`HTTP ${res.statusCode}: ${data}`);
          err.statusCode = res.statusCode;
          reject(err);
          return;
        }
        try {
          resolve(JSON.parse(data));
        } catch {
          reject(new Error(`Invalid JSON response: ${data}`));
        }
      });
    });

    req.on('error', (err) => reject(err));
    req.on('timeout', () => {
      req.destroy();
      reject(new Error('Request timed out (60s)'));
    });

    req.end();
  });
}

/**
 * Start a device authorization flow.
 * Returns the deviceCode (for polling) + userCode + URLs (for the user).
 */
export function requestDeviceCode(apiUrl, { clientName, hostname }) {
  return _jsonRequest(apiUrl, '/api/usage/device/code', 'POST', { clientName, hostname }, 10_000);
}

/**
 * One poll iteration. Resolves with one of:
 *   { apiKey, apiUrl }                 — approved, key delivered
 *   { error: 'authorization_pending' } — keep polling
 *   { error: 'access_denied' }         — user pressed deny
 *   { error: 'expired_token' }         — code expired or already consumed
 *   { error: 'invalid_grant' | ... }   — unrecoverable
 * Rejects only on network/server errors.
 */
export function pollDeviceCode(apiUrl, deviceCode) {
  return _jsonRequest(apiUrl, '/api/usage/device/poll', 'POST', { deviceCode }, 15_000);
}

function _jsonRequest(apiUrl, path, method, body, timeoutMs) {
  return new Promise((resolve, reject) => {
    const url = new URL(path, apiUrl);
    const mod = url.protocol === 'https:' ? https : http;
    const raw = Buffer.from(JSON.stringify(body));

    const req = mod.request(url, {
      method,
      timeout: timeoutMs,
      headers: {
        'Content-Type': 'application/json',
        'Content-Length': raw.length,
      },
    }, (res) => {
      let data = '';
      res.on('data', (chunk) => { data += chunk; });
      res.on('end', () => {
        if (res.statusCode < 200 || res.statusCode >= 300) {
          const err = new Error(`HTTP ${res.statusCode}: ${data}`);
          err.statusCode = res.statusCode;
          reject(err);
          return;
        }
        try {
          resolve(JSON.parse(data));
        } catch {
          reject(new Error(`Invalid JSON response: ${data}`));
        }
      });
    });
    req.on('error', reject);
    req.on('timeout', () => { req.destroy(); reject(new Error(`Request timed out (${timeoutMs}ms)`)); });
    req.write(raw);
    req.end();
  });
}

/**
 * GET user settings from the vibecafe API.
 * Returns null on any failure (network, auth, timeout) — caller should fail-safe.
 * @param {string} apiUrl
 * @param {string} apiKey
 * @returns {Promise<{uploadProject: boolean} | null>}
 */
export function fetchSettings(apiUrl, apiKey) {
  return new Promise((resolve) => {
    const url = new URL('/api/usage/settings', apiUrl);
    const mod = url.protocol === 'https:' ? https : http;

    const req = mod.request(url, {
      method: 'GET',
      timeout: 10_000,
      headers: {
        'Authorization': `Bearer ${apiKey}`,
      },
    }, (res) => {
      let data = '';
      res.on('data', (chunk) => { data += chunk; });
      res.on('end', () => {
        if (res.statusCode < 200 || res.statusCode >= 300) {
          resolve(null);
          return;
        }
        try {
          resolve(JSON.parse(data));
        } catch {
          resolve(null);
        }
      });
    });

    req.on('error', () => resolve(null));
    req.on('timeout', () => { req.destroy(); resolve(null); });
    req.end();
  });
}

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 isDev = process.env.VIBE_USAGE_DEV === '1';
const CONFIG_FILE = join(CONFIG_DIR, isDev ? 'config.dev.json' : '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');
}

import { execFileSync } from 'node:child_process';
import { writeFileSync, unlinkSync, mkdirSync, existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir, platform } from 'node:os';
import { fileURLToPath } from 'node:url';
import { success, failure, warn, dim } from './output.js';

const SERVICE_NAME = 'vibe-usage';
const LAUNCHD_LABEL = 'ai.vibecafe.vibe-usage';

function detectPlatform() {
  const os = platform();
  if (os === 'linux') {
    if (existsSync('/run/systemd/system')) return 'systemd';
    return null;
  }
  if (os === 'darwin') {
    return 'launchd';
  }
  return null;
}

function resolvePaths() {
  const nodePath = process.execPath;
  const thisFile = fileURLToPath(import.meta.url);
  const binPath = join(thisFile, '..', '..', 'bin', 'vibe-usage.js');

  // npx cache paths are unstable — service will break when cache is cleared
  const isNpxCache = binPath.includes('.npm/_npx');

  return { nodePath, binPath, isNpxCache };
}

function getServicePaths(plat) {
  if (plat === 'systemd') {
    const dir = join(homedir(), '.config', 'systemd', 'user');
    return { dir, file: join(dir, `${SERVICE_NAME}.service`) };
  }
  if (plat === 'launchd') {
    const dir = join(homedir(), 'Library', 'LaunchAgents');
    return { dir, file: join(dir, `${LAUNCHD_LABEL}.plist`) };
  }
  return null;
}

function generateSystemdUnit(nodePath, binPath) {
  return `[Unit]
Description=VibeCafe Usage Tracker
After=network.target

[Service]
Type=simple
ExecStart=${nodePath} ${binPath} daemon
Restart=on-failure
RestartSec=10
Environment=NODE_ENV=production
WorkingDirectory=${homedir()}

[Install]
WantedBy=default.target
`;
}

function generateLaunchdPlist(nodePath, binPath) {
  const logDir = join(homedir(), '.vibe-usage');
  return `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>${LAUNCHD_LABEL}</string>
    <key>ProgramArguments</key>
    <array>
        <string>${nodePath}</string>
        <string>${binPath}</string>
        <string>daemon</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
    <key>WorkingDirectory</key>
    <string>${homedir()}</string>
    <key>StandardOutPath</key>
    <string>${join(logDir, 'daemon.log')}</string>
    <key>StandardErrorPath</key>
    <string>${join(logDir, 'daemon.err')}</string>
    <key>EnvironmentVariables</key>
    <dict>
        <key>NODE_ENV</key>
        <string>production</string>
    </dict>
</dict>
</plist>
`;
}

function run(cmd, args) {
  try {
    const output = execFileSync(cmd, args, {
      encoding: 'utf-8',
      stdio: ['pipe', 'pipe', 'pipe'],
    });
    return { ok: true, output: output.trim() };
  } catch (err) {
    return { ok: false, output: (err.stderr || err.stdout || err.message || '').trim() };
  }
}

function install() {
  const plat = detectPlatform();
  if (!plat) {
    console.log(failure('当前平台不支持 daemon。'));
    console.log(dim('  支持: Linux (systemd) / macOS (launchd)'));
    return;
  }

  const { nodePath, binPath, isNpxCache } = resolvePaths();

  if (isNpxCache) {
    console.log(warn('检测到从 npx 缓存运行 vibe-usage,缓存清理后 daemon 会失效。'));
    console.log(dim('  建议先全局安装:  npm install -g @vibe-cafe/vibe-usage'));
    console.log();
  }

  const paths = getServicePaths(plat);

  if (existsSync(paths.file)) {
    console.log(warn('Daemon 已安装，运行 `vibe-usage daemon restart` 或 `uninstall` 先处理。'));
    return;
  }

  mkdirSync(paths.dir, { recursive: true });

  if (plat === 'systemd') {
    writeFileSync(paths.file, generateSystemdUnit(nodePath, binPath), 'utf-8');
    console.log(dim(`  已写入 ${paths.file}`));

    run('systemctl', ['--user', 'daemon-reload']);
    const result = run('systemctl', ['--user', 'enable', '--now', `${SERVICE_NAME}.service`]);
    if (!result.ok) {
      console.error(failure(`启动服务失败: ${result.output}`));
      return;
    }
    console.log(success('服务已启用并启动。'));
  }

  if (plat === 'launchd') {
    mkdirSync(join(homedir(), '.vibe-usage'), { recursive: true });
    writeFileSync(paths.file, generateLaunchdPlist(nodePath, binPath), 'utf-8');
    console.log(dim(`  已写入 ${paths.file}`));

    const result = run('launchctl', ['load', paths.file]);
    if (!result.ok) {
      console.error(failure(`加载服务失败: ${result.output}`));
      return;
    }
    console.log(success('服务已加载并启动。'));
  }

  console.log();
  console.log(success('Daemon 已安装，用量数据将每 30 分钟自动同步。'));
  console.log(dim('  运行 `vibe-usage daemon status` 查看状态。'));
}

function uninstall() {
  const plat = detectPlatform();
  if (!plat) {
    console.log(failure('未检测到支持的服务平台。'));
    return;
  }

  const paths = getServicePaths(plat);

  if (!existsSync(paths.file)) {
    console.log(dim('未安装 daemon 服务。'));
    return;
  }

  if (plat === 'systemd') {
    run('systemctl', ['--user', 'stop', `${SERVICE_NAME}.service`]);
    run('systemctl', ['--user', 'disable', `${SERVICE_NAME}.service`]);
    unlinkSync(paths.file);
    run('systemctl', ['--user', 'daemon-reload']);
    console.log(success('服务已停止、禁用并删除。'));
  }

  if (plat === 'launchd') {
    run('launchctl', ['unload', paths.file]);
    unlinkSync(paths.file);
    console.log(success('服务已卸载并删除。'));
  }
}

function status() {
  const plat = detectPlatform();
  if (!plat) {
    console.log(failure('未检测到支持的服务平台。'));
    return;
  }

  const paths = getServicePaths(plat);

  if (!existsSync(paths.file)) {
    console.log(dim('未安装 daemon 服务。'));
    console.log(dim('  运行 `vibe-usage daemon install` 安装。'));
    return;
  }

  if (plat === 'systemd') {
    const result = run('systemctl', ['--user', 'status', `${SERVICE_NAME}.service`]);
    console.log(dim(result.output));
  }

  if (plat === 'launchd') {
    const result = run('launchctl', ['list', LAUNCHD_LABEL]);
    if (result.ok) {
      console.log(dim(`Service: ${LAUNCHD_LABEL}`));
      console.log(dim(result.output));
    } else {
      console.log(warn('服务已安装但当前未运行。'));
    }
  }
}

function stop() {
  const plat = detectPlatform();
  if (!plat) {
    console.log(failure('未检测到支持的服务平台。'));
    return;
  }

  if (plat === 'systemd') {
    const result = run('systemctl', ['--user', 'stop', `${SERVICE_NAME}.service`]);
    console.log(result.ok ? success('服务已停止。') : failure(`停止失败: ${result.output}`));
  }

  if (plat === 'launchd') {
    const result = run('launchctl', ['stop', LAUNCHD_LABEL]);
    console.log(result.ok ? success('服务已停止。') : failure(`停止失败: ${result.output}`));
  }
}

function restart() {
  const plat = detectPlatform();
  if (!plat) {
    console.log(failure('未检测到支持的服务平台。'));
    return;
  }

  if (plat === 'systemd') {
    const result = run('systemctl', ['--user', 'restart', `${SERVICE_NAME}.service`]);
    console.log(result.ok ? success('服务已重启。') : failure(`重启失败: ${result.output}`));
  }

  if (plat === 'launchd') {
    run('launchctl', ['stop', LAUNCHD_LABEL]);
    const result = run('launchctl', ['start', LAUNCHD_LABEL]);
    console.log(result.ok ? success('服务已重启。') : failure(`重启失败: ${result.output}`));
  }
}

const SUBCOMMANDS = { install, uninstall, status, stop, restart };

export async function manageDaemon(subcommand) {
  const fn = SUBCOMMANDS[subcommand];
  if (!fn) {
    console.error(failure(`未知 daemon 子命令: ${subcommand}`));
    console.error(dim('  用法: vibe-usage daemon <install|uninstall|status|stop|restart>'));
    process.exit(1);
  }
  fn();
}

import { loadConfig } from './config.js';
import { runSync } from './sync.js';
import { failure, dim } from './output.js';

const INTERVAL = 30 * 60_000; // 30 minutes

function log(msg) {
  const ts = new Date().toLocaleTimeString('en-US', { hour12: false });
  process.stdout.write(dim(`[${ts}] ${msg}\n`));
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

export async function runDaemon() {
  const config = loadConfig();
  if (!config?.apiKey) {
    console.error(failure('尚未配置，请先运行 `npx @vibe-cafe/vibe-usage init`。'));
    process.exit(1);
  }

  log('daemon started (sync every 30m, Ctrl+C to stop)');

  // Why we don't exit on the first 401: launchd KeepAlive / systemd
  // Restart=on-failure relaunch in ~10s, which used to turn a single bad/
  // revoked key into ~360 ingest-401s per hour per machine. Sleeping a full
  // INTERVAL between auth retries collapses that storm to the daemon's normal
  // 30m cadence; only after MAX_AUTH_FAILURES consecutive 401s do we hand
  // off to the supervisor, which by then can't relaunch fast enough to matter.
  const MAX_AUTH_FAILURES = 5;
  let consecutiveAuthFailures = 0;

  // eslint-disable-next-line no-constant-condition
  while (true) {
    try {
      await runSync({ throws: true, quiet: true });
      consecutiveAuthFailures = 0;
    } catch (err) {
      if (err.message === 'UNAUTHORIZED') {
        consecutiveAuthFailures++;
        if (consecutiveAuthFailures >= MAX_AUTH_FAILURES) {
          log(`API key invalid for ${MAX_AUTH_FAILURES} consecutive syncs, exiting.`);
          process.exit(1);
        }
        log(`API key invalid (attempt ${consecutiveAuthFailures}/${MAX_AUTH_FAILURES}), retrying in 30m.`);
      } else {
        log(`sync error: ${err.message}`);
      }
    }
    await sleep(INTERVAL);
  }
}

import { loadConfig, saveConfig, getConfigPath } from './config.js';
import { detectInstalledTools, TOOLS } from './tools.js';
import { existsSync } from 'node:fs';
import { smallHeader } from './output.js';

function printSmallHeader() {
  console.log();
  console.log(smallHeader());
  console.log();
}

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-cafe/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('\n  Detected tools:');
  const detected = detectInstalledTools();
  if (detected.length === 0) {
    console.log('    (none)\n');
  } else {
    for (const tool of detected) {
      console.log(`    ${tool.name}`);
    }
    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();
}

const VALID_CONFIG_KEYS = ['apiKey', 'apiUrl', 'hostname'];

function handleConfig(args) {
  const sub = args[0];

  switch (sub) {
    case 'get': {
      const key = args[1];
      if (!key) {
        console.error('Usage: vibe-usage config get <key>');
        process.exit(1);
      }
      const config = loadConfig();
      if (!config || !(key in config)) {
        // Output nothing — caller checks exit code or empty output
        process.exit(0);
      }
      // Output raw value (no formatting) for machine parsing
      console.log(config[key] ?? '');
      break;
    }
    case 'set': {
      const key = args[1];
      const value = args[2];
      if (!key || value === undefined) {
        console.error('Usage: vibe-usage config set <key> <value>');
        process.exit(1);
      }
      if (!VALID_CONFIG_KEYS.includes(key)) {
        console.error(`Unknown config key: ${key}`);
        console.error(`Valid keys: ${VALID_CONFIG_KEYS.join(', ')}`);
        process.exit(1);
      }
      const config = loadConfig() || {};
      config[key] = value;
      saveConfig(config);
      break;
    }
    case 'show': {
      const config = loadConfig();
      if (!config) {
        console.log('{}');
      } else {
        console.log(JSON.stringify(config, null, 2));
      }
      break;
    }
    default:
      console.error(`Unknown config subcommand: ${sub || '(none)'}`);
      console.error('Usage: vibe-usage config <get|set|show>');
      process.exit(1);
  }
}

function extractOption(args, name) {
  const flag = `--${name}`;
  const idx = args.findIndex(a => a === flag);
  if (idx === -1) return { args, value: undefined };
  const value = args[idx + 1];
  if (value === undefined || value.startsWith('--')) {
    console.error(`Option ${flag} requires a value.`);
    process.exit(1);
  }
  return { args: [...args.slice(0, idx), ...args.slice(idx + 2)], value };
}

export async function run(rawArgs) {
  // --key and --manual-key both mean "skip device flow, take this vbu_ key".
  // --manual-key is the documented name; --key is kept as a legacy alias so
  // existing scripts/docs don't break when device flow becomes the default.
  let stripped;
  let apiKey;
  ({ args: stripped, value: apiKey } = extractOption(rawArgs, 'manual-key'));
  if (apiKey === undefined) {
    ({ args: stripped, value: apiKey } = extractOption(stripped, 'key'));
  }
  const args = stripped;
  const command = args[0];

  switch (command) {
    case 'init': {
      const { runInit } = await import('./init.js');
      await runInit({ apiKey });
      break;
    }
    case 'sync': {
      printSmallHeader();
      const { runSync } = await import('./sync.js');
      await runSync();
      break;
    }
    case 'summary': {
      const { runSummary } = await import('./summary.js');
      await runSummary(args.slice(1));
      break;
    }
    case 'reset': {
      printSmallHeader();
      const { runReset } = await import('./reset.js');
      await runReset(args.slice(1));
      break;
    }
    case 'daemon':
    case '--daemon': {
      const sub = args[1];
      if (sub && ['install', 'uninstall', 'status', 'stop', 'restart'].includes(sub)) {
        printSmallHeader();
        const { manageDaemon } = await import('./daemon-service.js');
        await manageDaemon(sub);
      } else {
        // Foreground daemon loop — no header, just start syncing
        const { runDaemon } = await import('./daemon.js');
        await runDaemon();
      }
      break;
    }
    case 'skill': {
      printSmallHeader();
      const { runSkill } = await import('./skill.js');
      await runSkill(args.slice(1));
      break;
    }
    case 'config': {
      handleConfig(args.slice(1));
      break;
    }
    case 'status': {
      await showStatus();
      break;
    }
    case 'help':
    case '--help':
    case '-h': {
      console.log(`
  vibe-usage - Vibe Usage Tracker by VibeCafé

  Usage:
    npx @vibe-cafe/vibe-usage              Init (first run, browser login) or sync
    npx @vibe-cafe/vibe-usage init         Set up via browser login (default)
    npx @vibe-cafe/vibe-usage init --manual-key <vbu_...>   Skip browser, use a pre-issued key (CI/headless)
    npx @vibe-cafe/vibe-usage sync         Manually sync usage data
    npx @vibe-cafe/vibe-usage summary       Print last 7 days as markdown (cost/tokens/model/project)
    npx @vibe-cafe/vibe-usage summary --days N   Same, but over the last N days (1-90)
    npx @vibe-cafe/vibe-usage daemon       Continuous sync (every 30m, foreground)
    npx @vibe-cafe/vibe-usage daemon install    Install background service (systemd/launchd)
    npx @vibe-cafe/vibe-usage daemon uninstall  Remove background service
    npx @vibe-cafe/vibe-usage daemon status     Show background service status
    npx @vibe-cafe/vibe-usage daemon stop       Stop background service
    npx @vibe-cafe/vibe-usage daemon restart    Restart background service
    npx @vibe-cafe/vibe-usage reset        Delete all data and re-upload
    npx @vibe-cafe/vibe-usage reset --local  Delete data for this host only and re-upload
    npx @vibe-cafe/vibe-usage skill         Install skill for AI coding tools
    npx @vibe-cafe/vibe-usage skill --remove  Remove installed skills
    npx @vibe-cafe/vibe-usage status       Show config and detected tools
    npx @vibe-cafe/vibe-usage config show  Show full config as JSON
    npx @vibe-cafe/vibe-usage config get <key>   Get a config value
    npx @vibe-cafe/vibe-usage config set <key> <value>  Set a config value
    npx @vibe-cafe/vibe-usage help         Show this help
`);
      break;
    }
    default: {
      const config = loadConfig();
      if (!config?.apiKey || apiKey) {
        // First run OR user passed --key for a one-shot setup — init.js prints the big header
        const { runInit } = await import('./init.js');
        await runInit({ apiKey });
      } else {
        // Already configured: small header + sync
        printSmallHeader();
        const { runSync } = await import('./sync.js');
        await runSync();
      }
    }
  }
}

import { createInterface } from 'node:readline';
import { execFile } from 'node:child_process';
import { hostname as osHostname, platform } from 'node:os';
import { loadConfig, saveConfig } from './config.js';
import { ingest, requestDeviceCode, pollDeviceCode } from './api.js';
import { runSync } from './sync.js';
import { detectInstalledTools } from './tools.js';
import { bigHeader, success, failure, warn, arrow, link, dim, divider } from './output.js';

const CLIENT_NAME = 'vibe-usage CLI';

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;
  // Use execFile with args array to avoid shell injection via VIBE_USAGE_API_URL
  execFile(cmd, [url], () => {});
}

function isDaemonPlatform() {
  return process.platform === 'linux' || process.platform === 'darwin';
}

export async function runInit(options = {}) {
  const { apiKey: providedKey } = options;

  console.log(bigHeader());

  const existing = loadConfig();
  if (existing?.apiKey) {
    if (providedKey && existing.apiKey === providedKey) {
      console.log(dim('已配置同一个 Key，直接同步数据。'));
      console.log();
      await runSync();
      return;
    }
    const answer = await prompt('检测到已有配置，是否覆盖? (y/N) ');
    if (answer.toLowerCase() !== 'y') {
      console.log(dim('已取消。'));
      return;
    }
  }

  const apiUrl = process.env.VIBE_USAGE_API_URL || 'https://vibecafe.ai';
  const host = existing?.hostname || osHostname().replace(/\.local$/, '');

  let apiKey;
  if (providedKey) {
    if (!providedKey.startsWith('vbu_')) {
      console.error(failure('API Key 无效，必须以 vbu_ 开头。'));
      process.exit(1);
    }
    apiKey = providedKey;
  } else {
    apiKey = await runDeviceFlow(apiUrl, host);
    if (!apiKey) process.exit(1);
  }

  try {
    await ingest(apiUrl, apiKey, []);
    console.log(success(`验证通过 ${dim(apiKey.slice(0, 12) + '...')}`));
  } catch (err) {
    if (err.message === 'UNAUTHORIZED') {
      console.error(failure('API Key 无效，请检查后重试。'));
      process.exit(1);
    }
    console.log(warn(`网络异常（${err.message}），跳过验证直接保存。`));
  }

  const config = {
    apiKey,
    apiUrl,
    hostname: host,
  };
  saveConfig(config);

  const tools = detectInstalledTools();
  if (tools.length > 0) {
    console.log(success(`检测到 ${tools.length} 款工具: ${dim(tools.map(t => t.name).join(' · '))}`));
  } else {
    console.log(warn('未检测到 AI 编码工具，安装后重新运行即可。'));
  }

  console.log();
  console.log(divider());
  console.log();

  await runSync();

  if (isDaemonPlatform()) {
    if (process.stdin.isTTY) {
      console.log();
      const answer = await prompt(`开启后台自动同步？${dim('(推荐)')} [Y/n] `);
      const normalized = answer.toLowerCase();
      if (normalized === '' || normalized === 'y' || normalized === 'yes') {
        const { manageDaemon } = await import('./daemon-service.js');
        await manageDaemon('install');
      } else {
        console.log();
        console.log(dim('随时运行 `npx @vibe-cafe/vibe-usage daemon install` 开启后台同步。'));
      }
    } else {
      console.log();
      console.log(dim('提示: 运行 `npx @vibe-cafe/vibe-usage daemon install` 开启后台自动同步。'));
    }
  }
}

async function runDeviceFlow(apiUrl, hostname) {
  let device;
  try {
    device = await requestDeviceCode(apiUrl, { clientName: CLIENT_NAME, hostname });
  } catch (err) {
    console.error(failure(`无法连接 ${apiUrl}：${err.message}`));
    return null;
  }

  console.log(`${arrow('登录确认')} ${link(device.verificationUriComplete)}`);
  console.log(`  验证码: ${device.userCode}`);
  console.log(dim('  浏览器会自动打开；如果没反应，请手动复制上方链接。'));
  console.log();
  openBrowser(device.verificationUriComplete);

  const intervalMs = (device.interval || 5) * 1000;
  const deadline = Date.now() + (device.expiresIn || 900) * 1000;

  process.stdout.write(dim('等待审批…'));
  const aborter = new AbortController();
  const onSigint = () => { aborter.abort(); };
  process.on('SIGINT', onSigint);
  try {
    while (Date.now() < deadline) {
      if (aborter.signal.aborted) {
        process.stdout.write('\n');
        console.log(warn('已取消。'));
        return null;
      }
      await sleep(intervalMs);
      let res;
      try {
        res = await pollDeviceCode(apiUrl, device.deviceCode);
      } catch (err) {
        // Transient network blip — keep polling until deadline.
        process.stdout.write(dim('.'));
        continue;
      }
      if (res.apiKey) {
        process.stdout.write('\n');
        console.log(success('已批准，获取到 API Key。'));
        return res.apiKey;
      }
      if (res.error === 'authorization_pending') {
        process.stdout.write(dim('.'));
        continue;
      }
      if (res.error === 'access_denied') {
        process.stdout.write('\n');
        console.error(failure('请求被拒绝。'));
        return null;
      }
      if (res.error === 'expired_token') {
        process.stdout.write('\n');
        console.error(failure('验证码已过期，请重跑 init。'));
        return null;
      }
      process.stdout.write('\n');
      console.error(failure(`服务端返回未知错误：${res.error}`));
      return null;
    }
    process.stdout.write('\n');
    console.error(failure('验证码已过期，请重跑 init。'));
    return null;
  } finally {
    process.removeListener('SIGINT', onSigint);
  }
}

function sleep(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

// Terminal output helpers: colors, status markers, OSC 8 clickable links.
// Falls back to plain text when NO_COLOR is set or stdout is not a TTY.

const NO_COLOR = !!process.env.NO_COLOR || !process.stdout.isTTY;

const CODES = {
  reset: '\x1b[0m',
  bold: '\x1b[1m',
  dim: '\x1b[2m',
  underline: '\x1b[4m',
  red: '\x1b[31m',
  green: '\x1b[32m',
  yellow: '\x1b[33m',
  cyan: '\x1b[36m',
  gray: '\x1b[90m',
};

function wrap(code, text) {
  if (NO_COLOR) return String(text);
  return `${code}${text}${CODES.reset}`;
}

export const bold = (t) => wrap(CODES.bold, t);
export const dim = (t) => wrap(CODES.dim, t);
export const red = (t) => wrap(CODES.red, t);
export const green = (t) => wrap(CODES.green, t);
export const yellow = (t) => wrap(CODES.yellow, t);
export const cyan = (t) => wrap(CODES.cyan, t);
export const gray = (t) => wrap(CODES.gray, t);

/** OSC 8 hyperlink — supported by modern terminals (iTerm2, Kitty, Warp, VSCode, macOS Terminal 14+). */
export function link(url, text = url) {
  if (NO_COLOR) return url === text ? url : `${text} (${url})`;
  return `\x1b]8;;${url}\x1b\\${CODES.cyan}${CODES.underline}${text}${CODES.reset}\x1b]8;;\x1b\\`;
}

export const success = (msg) => `${green('✓')} ${msg}`;
export const failure = (msg) => `${red('✗')} ${msg}`;
export const warn = (msg) => `${yellow('!')} ${msg}`;
export const arrow = (msg) => `${cyan('→')} ${msg}`;

export const divider = () => dim('─'.repeat(48));

/** Print a blank line. */
export const nl = () => console.log();

const LOGO_LINES = [
  '██╗   ██╗██╗██████╗ ███████╗    ██╗   ██╗███████╗ █████╗  ██████╗ ███████╗',
  '██║   ██║██║██╔══██╗██╔════╝    ██║   ██║██╔════╝██╔══██╗██╔════╝ ██╔════╝',
  '██║   ██║██║██████╔╝█████╗      ██║   ██║███████╗███████║██║  ███╗█████╗  ',
  '╚██╗ ██╔╝██║██╔══██╗██╔══╝      ██║   ██║╚════██║██╔══██║██║   ██║██╔══╝  ',
  ' ╚████╔╝ ██║██████╔╝███████╗    ╚██████╔╝███████║██║  ██║╚██████╔╝███████╗',
  '  ╚═══╝  ╚═╝╚═════╝ ╚══════╝     ╚═════╝ ╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚══════╝',
];

/** Big ASCII logo — used once at the top of `init` / first-run. */
export function bigHeader() {
  const logo = NO_COLOR
    ? LOGO_LINES.join('\n')
    : LOGO_LINES.map(l => `${CODES.cyan}${l}${CODES.reset}`).join('\n');
  return `\n${logo}\n${dim('  Vibe Usage · by VibeCafé')}\n`;
}

/** Compact one-line header — used for `sync`, `daemon`, `reset`, `skill`. */
export function smallHeader() {
  return `${bold('Vibe Usage')} ${dim('· by VibeCafé')}`;
}

import { readdirSync, readFileSync, existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import { aggregateToBuckets, extractSessions } from './index.js';

function resolveThreadsDir() {
  if (process.env.AMP_DATA_DIR) return process.env.AMP_DATA_DIR;
  if (process.env.XDG_DATA_HOME) return join(process.env.XDG_DATA_HOME, 'amp', 'threads');
  return join(homedir(), '.local', 'share', 'amp', 'threads');
}

function findThreadFiles(dir) {
  const results = [];
  if (!existsSync(dir)) return results;

  try {
    for (const entry of readdirSync(dir, { withFileTypes: true })) {
      const fullPath = join(dir, entry.name);
      if (entry.isDirectory()) {
        results.push(...findThreadFiles(fullPath));
      } else if (entry.isFile() && entry.name.startsWith('T-') && entry.name.endsWith('.json')) {
        results.push(fullPath);
      }
    }
  } catch {
  }

  return results;
}

function setMessageTimestamp(map, messageId, timestamp) {
  if (!Number.isInteger(messageId)) return;
  const current = map.get(messageId);
  if (!current || timestamp < current) {
    map.set(messageId, timestamp);
  }
}

function buildMessageTimestampMap(events) {
  const map = new Map();
  if (!Array.isArray(events)) return map;

  for (const event of events) {
    const ts = new Date(event?.timestamp);
    if (isNaN(ts.getTime())) continue;

    setMessageTimestamp(map, event.fromMessageId, ts);
    setMessageTimestamp(map, event.toMessageId, ts);
  }

  return map;
}

export async function parse() {
  const threadsDir = resolveThreadsDir();
  const threadFiles = findThreadFiles(threadsDir);
  if (threadFiles.length === 0) return { buckets: [], sessions: [] };

  const entries = [];
  const sessionEvents = [];

  for (const filePath of threadFiles) {
    let thread;
    try {
      thread = JSON.parse(readFileSync(filePath, 'utf-8'));
    } catch {
      continue;
    }

    const sessionId = thread?.id || filePath;
    const messages = Array.isArray(thread?.messages) ? thread.messages : [];
    const ledgerEvents = Array.isArray(thread?.usageLedger?.events) ? thread.usageLedger.events : [];
    const hasLedger = ledgerEvents.length > 0;

    if (hasLedger) {
      for (const event of ledgerEvents) {
        const ts = new Date(event?.timestamp);
        if (isNaN(ts.getTime())) continue;

        const inputTokens = event?.tokens?.input || 0;
        const outputTokens = event?.tokens?.output || 0;
        if (inputTokens === 0 && outputTokens === 0) continue;

        const toMessage = Number.isInteger(event.toMessageId) ? messages[event.toMessageId] : null;
        const cacheReadInputTokens = toMessage?.usage?.cacheReadInputTokens || 0;

        entries.push({
          source: 'amp',
          model: event?.model || 'unknown',
          project: 'unknown',
          timestamp: ts,
          inputTokens,
          outputTokens,
          cachedInputTokens: cacheReadInputTokens,
          reasoningOutputTokens: 0,
        });
      }
    } else {
      for (const message of messages) {
        const usage = message?.usage;
        if (!usage) continue;

        const ts = new Date(message?.timestamp || thread?.created);
        if (isNaN(ts.getTime())) continue;

        const inputTokens = usage.inputTokens || 0;
        const outputTokens = usage.outputTokens || 0;
        if (inputTokens === 0 && outputTokens === 0 && (usage.cacheReadInputTokens || 0) === 0) continue;

        entries.push({
          source: 'amp',
          model: usage.model || 'unknown',
          project: 'unknown',
          timestamp: ts,
          inputTokens,
          outputTokens,
          cachedInputTokens: usage.cacheReadInputTokens || 0,
          reasoningOutputTokens: 0,
        });
      }
    }

    const messageTsMap = buildMessageTimestampMap(ledgerEvents);
    const baseTimestamp = new Date(thread?.created);
    const hasBaseTimestamp = !isNaN(baseTimestamp.getTime());

    for (let i = 0; i < messages.length; i++) {
      const message = messages[i];
      const mappedTs = messageTsMap.get(i);
      const ts = mappedTs || (hasBaseTimestamp ? baseTimestamp : null);
      if (!ts || isNaN(ts.getTime())) continue;

      sessionEvents.push({
        sessionId,
        source: 'amp',
        project: 'unknown',
        timestamp: ts,
        role: message?.role === 'user' ? 'user' : 'assistant',
      });
    }
  }

  return { buckets: aggregateToBuckets(entries), sessions: extractSessions(sessionEvents) };
}

import { execSync } from 'node:child_process';
import { readdirSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import { aggregateToBuckets, extractSessions } from './index.js';



/**
 * Antigravity parser (file-based).
 * Scans .pb files in ~/.gemini/antigravity/conversations/ to discover cascade IDs.
 * Calls GetCascadeTrajectory via a running language server to extract token usage
 * (from generatorMetadata) and session events (from trajectory steps).
 */

const SOURCE = 'antigravity';
const CONVERSATIONS_DIR = join(homedir(), '.gemini', 'antigravity', 'conversations');

// User sources → role 'user'; Model source → role 'assistant'; System sources → skip
const USER_SOURCES = new Set([
  'CORTEX_STEP_SOURCE_USER_EXPLICIT',
  'CORTEX_STEP_SOURCE_USER_IMPLICIT',
]);
const ASSISTANT_SOURCES = new Set([
  'CORTEX_STEP_SOURCE_MODEL',
]);

// ── Process discovery (single instance) ──────────────────────────────

const IS_WIN = process.platform === 'win32';

/**
 * Find ONE running language server process with a CSRF token.
 * Returns { pid, csrfToken } or null.
 */
function findLanguageServer() {
  try {
    return IS_WIN ? findLanguageServerWin() : findLanguageServerUnix();
  } catch {
    return null;
  }
}

function findLanguageServerUnix() {
  const out = execSync("ps aux | grep 'antigravity/bin/language_server_'", { encoding: 'utf-8', timeout: 5000 });
  for (const line of out.split('\n')) {
    if (!line.trim()) continue;
    if (line.includes('grep')) continue;
    const parts = line.trim().split(/\s+/);
    if (parts.length < 2) continue;
    const pid = parts[1];
    const csrfMatch = line.match(/--csrf_token\s+([0-9a-f-]+)/);
    const csrfToken = csrfMatch ? csrfMatch[1] : '';
    if (csrfToken) return { pid, csrfToken };
  }
  return null;
}

function findLanguageServerWin() {
  // Prefer PowerShell/CIM: wmic is disabled by default on Windows 11 23H2+
  // and removed entirely from 25H2 onward. Fall back to wmic for old/stripped
  // environments without PowerShell. Each probe is independently time-boxed and
  // failures are swallowed, so a missing/hung tool never blocks the next one or
  // the parsers that run after antigravity.
  const out = queryProcessesWinPowerShell() ?? queryProcessesWinWmic();
  if (!out) return null;
  return parseWinProcessList(out);
}

/**
 * Query language_server processes via PowerShell + CIM.
 * Emits "ProcessId=..." / "CommandLine=..." lines (wmic /format:list shape)
 * so parseWinProcessList handles either source. Returns null on failure.
 */
function queryProcessesWinPowerShell() {
  // Filter is applied in PowerShell so the LIKE wildcards stay server-side.
  // A "---" separator before each process's ProcessId/CommandLine lines keeps
  // fields grouped even when multiple processes match.
  const script =
    "Get-CimInstance Win32_Process -Filter \"CommandLine LIKE '%antigravity%language_server%'\" | " +
    'ForEach-Object { "---"; "ProcessId=" + $_.ProcessId; "CommandLine=" + $_.CommandLine }';
  for (const exe of ['powershell.exe', 'pwsh.exe']) {
    try {
      const out = execSync(
        `${exe} -NoProfile -NonInteractive -Command "${script.replace(/"/g, '\\"')}"`,
        { encoding: 'utf-8', timeout: 4000, windowsHide: true },
      );
      if (out && out.trim()) return out;
      // Empty (no matching process) — no point trying another shell.
      return null;
    } catch {
      // Try next shell (pwsh on systems without legacy powershell.exe).
    }
  }
  return null;
}

/** Legacy fallback: wmic /format:list. Returns null on failure. */
function queryProcessesWinWmic() {
  try {
    return execSync(
      'wmic process where "CommandLine like \'%antigravity%language_server%\'" get ProcessId,CommandLine /format:list',
      { encoding: 'utf-8', timeout: 4000, shell: 'cmd.exe' },
    );
  } catch {
    return null;
  }
}

/**
 * Parse "ProcessId=..." / "CommandLine=..." records (from either PowerShell or
 * wmic /format:list) and return the first language_server that carries a
 * --csrf_token, or null. PowerShell emits an explicit "---" separator per
 * process; wmic does not and may emit the two fields in either order, so a
 * record also ends whenever a field we've already captured reappears.
 */
function parseWinProcessList(out) {
  let pid = '';
  let cmdLine = '';
  const finish = () => {
    if (pid && cmdLine && !/WMIC\.exe|powershell\.exe|pwsh\.exe/i.test(cmdLine)) {
      const csrfMatch = cmdLine.match(/--csrf_token\s+([0-9a-f-]+)/);
      if (csrfMatch) return { pid, csrfToken: csrfMatch[1] };
    }
    return null;
  };
  const reset = () => { pid = ''; cmdLine = ''; };
  for (const line of out.split('\n')) {
    const trimmed = line.trim();
    const isPid = trimmed.startsWith('ProcessId=');
    const isCmd = trimmed.startsWith('CommandLine=');
    // Record boundary: explicit "---", or a field that would overwrite one we
    // already hold (next process began without a separator, e.g. wmic output).
    if (trimmed === '---' || (isPid && pid) || (isCmd && cmdLine)) {
      const found = finish();
      if (found) return found;
      reset();
    }
    if (isPid) pid = trimmed.slice('ProcessId='.length);
    else if (isCmd) cmdLine = trimmed.slice('CommandLine='.length);
  }
  return finish();
}

function findListeningPorts(pid) {
  try {
    return IS_WIN ? findListeningPortsWin(pid) : findListeningPortsUnix(pid);
  } catch {
    return [];
  }
}

function findListeningPortsUnix(pid) {
  const out = execSync(`lsof -iTCP -sTCP:LISTEN -nP -a -p ${pid}`, {
    encoding: 'utf-8',
    timeout: 5000,
  });
  const ports = [];
  for (const line of out.split('\n')) {
    const match = line.match(/:(\d+)\s+\(LISTEN\)/);
    if (match) ports.push(parseInt(match[1], 10));
  }
  return ports;
}

function findListeningPortsWin(pid) {
  // netstat output: TCP  127.0.0.1:49327  0.0.0.0:0  LISTENING  12345
  const out = execSync('netstat -ano', { encoding: 'utf-8', timeout: 5000 });
  const ports = [];
  for (const line of out.split('\n')) {
    if (!line.includes('LISTENING')) continue;
    const parts = line.trim().split(/\s+/);
    // parts: [TCP, local_addr:port, foreign_addr, LISTENING, pid]
    const linePid = parts[parts.length - 1];
    if (linePid !== String(pid)) continue;
    const addrMatch = parts[1]?.match(/:(\d+)$/);
    if (addrMatch) ports.push(parseInt(addrMatch[1], 10));
  }
  return ports;
}

async function rpcPost(baseUrl, path, body, csrfToken, timeoutMs = 10000) {
  const url = new URL(path, baseUrl);
  const headers = {
    'Content-Type': 'application/json',
    'Connect-Protocol-Version': '1',
  };
  if (csrfToken) headers['X-Codeium-Csrf-Token'] = csrfToken;

  const res = await fetch(url, {
    method: 'POST',
    headers,
    body: JSON.stringify(body),
    signal: AbortSignal.timeout(timeoutMs),
  });
  if (!res.ok) throw new Error(`HTTP ${res.status} from ${path}`);
  return res.json();
}

async function probeHttpPort(ports, csrfToken) {
  for (const port of ports) {
    const baseUrl = `http://127.0.0.1:${port}`;
    try {
      await rpcPost(
        baseUrl,
        '/exa.language_server_pb.LanguageServerService/GetWorkspaceInfos',
        {},
        csrfToken,
        3000,
      );
      return baseUrl;
    } catch {
      // Not the right port, try next
    }
  }
  return null;
}

// ── Helpers ──────────────────────────────────────────────────────────

/**
 * Normalize model names to canonical forms.
 */
const MODEL_NORMALIZE_MAP = {
  'claude-opus-4-6-thinking': 'claude-opus-4-6',
  'claude-sonnet-4-6-thinking': 'claude-sonnet-4-6',
  'gemini-3-flash-c': 'gemini-3-flash',
  "gemini-3.1-pro-high": "gemini-3.1-pro",
  "gemini-3.1-pro-low": "gemini-3.1-pro",
  "gemini-3-pro-high": "gemini-3-pro",
  "gemini-3-pro-low": "gemini-3-pro",
};

/**
 * Map internal placeholder model IDs to canonical names.
 * Used when responseModel is empty and only chatModel.model is available.
 */
const PLACEHOLDER_MODEL_MAP = {
  'MODEL_PLACEHOLDER_M37': 'gemini-3.1-pro',
  'MODEL_PLACEHOLDER_M36': 'gemini-3.1-pro',
  'MODEL_PLACEHOLDER_M47': 'gemini-3-flash',
  'MODEL_PLACEHOLDER_M35': 'claude-sonnet-4-6',
  'MODEL_PLACEHOLDER_M26': 'claude-opus-4-6',
  'MODEL_OPENAI_GPT_OSS_120B_MEDIUM': 'gpt-oss-120b',
};

function normalizeModel(raw) {
  return MODEL_NORMALIZE_MAP[raw] || raw;
}

/**
 * Resolve model name: prefer responseModel, fall back to placeholder map.
 */
function resolveModel(chatModel) {
  if (chatModel.responseModel) return normalizeModel(chatModel.responseModel);
  const placeholder = chatModel.model || '';
  if (PLACEHOLDER_MODEL_MAP[placeholder]) return PLACEHOLDER_MODEL_MAP[placeholder];
  return 'unknown';
}

function toSafeNumber(value) {
  if (value == null) return 0;
  const n = Number(value);
  return Number.isFinite(n) ? n : 0;
}

/**
 * Extract project name from a workspace URI (e.g. "file:///Users/x/myproject" → "myproject").
 */
function projectFromUri(uri) {
  if (!uri) return null;
  const parts = uri.replace(/\/$/, '').split('/');
  return parts[parts.length - 1] || null;
}

/**
 * List cascade IDs from .pb files in the conversations directory.
 */
function listCascades() {
  try {
    const files = readdirSync(CONVERSATIONS_DIR);
    const results = [];
    for (const f of files) {
      if (!f.endsWith('.pb')) continue;
      results.push(f.slice(0, -3)); // strip .pb → cascadeId
    }
    return results;
  } catch {
    return [];
  }
}

// ── Main parse ───────────────────────────────────────────────────────

export async function parse() {
  // Step 1: List cascade .pb files
  const cascadeIds = listCascades();
  if (cascadeIds.length === 0) return { buckets: [], sessions: [] };

  // Step 2: Find a running language server to make RPC calls
  const server = findLanguageServer();
  if (!server) return { buckets: [], sessions: [] };

  const ports = findListeningPorts(server.pid);
  if (ports.length === 0) return { buckets: [], sessions: [] };

  const baseUrl = await probeHttpPort(ports, server.csrfToken);
  if (!baseUrl) return { buckets: [], sessions: [] };

  const rpc = (method, body) =>
    rpcPost(
      baseUrl,
      `/exa.language_server_pb.LanguageServerService/${method}`,
      body,
      server.csrfToken,
    );

  // Step 3: Fetch trajectory for each changed cascade
  const entries = [];
  const sessionEvents = [];
  const seenResponseIds = new Set();

  for (const cascadeId of cascadeIds) {
    let resp;
    try {
      resp = await rpc('GetCascadeTrajectory', { cascadeId });
    } catch {
      continue; // skip this cascade if RPC fails
    }

    const trajectory = resp?.trajectory;
    if (!trajectory) continue;

    const steps = trajectory.steps || [];
    const metadataList = trajectory.generatorMetadata || [];


    // Extract project from trajectory metadata workspaces
    let project = 'unknown';
    const workspaces = trajectory.metadata?.workspaces || [];
    if (workspaces.length > 0) {
      project = workspaces[0].repository?.computedName || projectFromUri(workspaces[0].workspaceFolderAbsoluteUri) || 'unknown';
    }

    // ── Token entries from generatorMetadata ──
    for (const meta of metadataList) {
      const chatModel = meta?.chatModel;
      if (!chatModel) continue;

      const responseModel = resolveModel(chatModel);
      const createdAt = chatModel?.chatStartMetadata?.createdAt;
      const ts = createdAt ? new Date(createdAt) : null;
      if (!ts || isNaN(ts.getTime())) continue;

      const retryInfos = chatModel.retryInfos || [];
      for (const retry of retryInfos) {
        const usage = retry.usage;
        if (!usage) continue;

        const responseId = usage.responseId || '';
        if (responseId && seenResponseIds.has(responseId)) continue;
        if (responseId) seenResponseIds.add(responseId);

        entries.push({
          source: SOURCE,
          model: responseModel,
          project,
          timestamp: ts,
          inputTokens: toSafeNumber(usage.inputTokens),
          outputTokens: toSafeNumber(usage.outputTokens),
          cachedInputTokens: toSafeNumber(usage.cacheReadTokens),
          reasoningOutputTokens: toSafeNumber(usage.thinkingOutputTokens),
        });
      }
    }

    // ── Session events from trajectory steps ──
    for (const step of steps) {
      const stepSource = step?.metadata?.source || '';
      let role;
      if (USER_SOURCES.has(stepSource)) {
        role = 'user';
      } else if (ASSISTANT_SOURCES.has(stepSource)) {
        role = 'assistant';
      } else {
        continue; // skip SYSTEM / SYSTEM_SDK / UNSPECIFIED
      }

      const createdAt = step?.metadata?.createdAt;
      const ts = createdAt ? new Date(createdAt) : null;
      if (!ts || isNaN(ts.getTime())) continue;

      sessionEvents.push({
        sessionId: cascadeId,
        source: SOURCE,
        project,
        timestamp: ts,
        role,
      });
    }

  }

  return {
    buckets: aggregateToBuckets(entries),
    sessions: extractSessions(sessionEvents),
  };
}