memhouse 0.0.1 → 0.3.0

package/editors/zed.js

@@ -0,0 +1,213 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const Database = require('better-sqlite3');
+
+// Zed stores data in different locations depending on the platform
+// - Windows: %LOCALAPPDATA%\Zed (not Roaming)
+// - macOS: ~/Library/Application Support/Zed
+// - Linux: ~/.config/Zed
+function getZedDataPath() {
+  const home = os.homedir();
+  switch (process.platform) {
+    case 'win32':
+      return path.join(home, 'AppData', 'Local', 'Zed');
+    case 'darwin':
+      return path.join(home, 'Library', 'Application Support', 'Zed');
+    default: // linux, etc.
+      return path.join(home, '.config', 'Zed');
+  }
+}
+
+const THREADS_DB = path.join(getZedDataPath(), 'threads', 'threads.db');
+
+// ============================================================
+// Decompress zstd blob via CLI (with cross-platform support)
+// ============================================================
+
+function decompressZstd(buf) {
+  const tmpIn = path.join(os.tmpdir(), `zed_thread_${Date.now()}.zst`);
+  const tmpOut = tmpIn.replace('.zst', '.json');
+  try {
+    fs.writeFileSync(tmpIn, buf);
+
+    // Try zstd CLI first
+    try {
+      const { execFileSync } = require('child_process');
+      const zstdCmd = process.platform === 'win32' ? 'zstd.exe' : 'zstd';
+      execFileSync(zstdCmd, ['-d', '-f', '-q', tmpIn, '-o', tmpOut], { stdio: ['pipe', 'pipe', 'pipe'] });
+    } catch {
+      // Fallback: try using Node.js zstd library if available
+      try {
+        const zlib = require('zlib');
+        // Check if Node version supports zstd natively (v22+)
+        if (zlib.createZstdDecompress) {
+          const decompressed = zlib.zstdDecompressSync(buf);
+          fs.writeFileSync(tmpOut, decompressed);
+        } else {
+          throw new Error('zstd not available');
+        }
+      } catch {
+        throw new Error('zstd decompression not available on this system');
+      }
+    }
+
+    const data = fs.readFileSync(tmpOut, 'utf-8');
+    return data;
+  } finally {
+    try { fs.unlinkSync(tmpIn); } catch {}
+    try { fs.unlinkSync(tmpOut); } catch {}
+  }
+}
+
+// ============================================================
+// Query SQLite using better-sqlite3 (cross-platform)
+// ============================================================
+
+function queryDb(sql) {
+  if (!fs.existsSync(THREADS_DB)) return [];
+  try {
+    const db = new Database(THREADS_DB, { readonly: true });
+    const rows = db.prepare(sql).all();
+    db.close();
+    return rows;
+  } catch (e) {
+    // Silently fail if database is locked or inaccessible
+    return [];
+  }
+}
+
+function queryBlob(id) {
+  if (!fs.existsSync(THREADS_DB)) return null;
+  try {
+    const db = new Database(THREADS_DB, { readonly: true });
+    const row = db.prepare('SELECT data FROM threads WHERE id = ?').get(id);
+    db.close();
+    return row ? row.data : null;
+  } catch {
+    return null;
+  }
+}
+
+// ============================================================
+// Adapter interface
+// ============================================================
+
+const name = 'zed';
+
+function getChats() {
+  const rows = queryDb(
+    'SELECT id, summary, updated_at, data_type, length(data) as data_size, parent_id, worktree_branch FROM threads ORDER BY updated_at DESC'
+  );
+
+  return rows.map(row => ({
+    source: 'zed',
+    composerId: row.id,
+    name: row.summary || null,
+    createdAt: row.updated_at ? new Date(row.updated_at).getTime() : null,
+    lastUpdatedAt: row.updated_at ? new Date(row.updated_at).getTime() : null,
+    mode: 'thread',
+    folder: null,
+    encrypted: false,
+    bubbleCount: 0,
+    _dataType: row.data_type,
+    _gitBranch: row.worktree_branch,
+  }));
+}
+
+function getMessages(chat) {
+  const blob = queryBlob(chat.composerId);
+  if (!blob) return [];
+
+  let json;
+  const dataType = chat._dataType || 'zstd';
+  try {
+    if (dataType === 'zstd') {
+      json = decompressZstd(blob);
+    } else {
+      json = blob.toString('utf-8');
+    }
+  } catch (e) {
+    // Decompression failed - zstd CLI not available
+    return [];
+  }
+
+  let data;
+  try { data = JSON.parse(json); } catch { return []; }
+
+  const model = data.model?.model || null;
+  const messages = [];
+  for (const msg of data.messages || []) {
+    if (msg.User) {
+      const { text } = extractContent(msg.User.content);
+      if (text) messages.push({ role: 'user', content: text });
+    } else if (msg.Agent) {
+      const { text, toolCalls } = extractContent(msg.Agent.content);
+      if (text) messages.push({ role: 'assistant', content: text, _model: model, _toolCalls: toolCalls });
+    }
+  }
+  return messages;
+}
+
+function extractContent(content) {
+  if (!Array.isArray(content)) return { text: '', toolCalls: [] };
+  const parts = [];
+  const toolCalls = [];
+  for (const block of content) {
+    if (block.Text) {
+      parts.push(block.Text);
+    } else if (block.ToolUse) {
+      const tu = block.ToolUse;
+      let args = {};
+      try {
+        args = typeof tu.input === 'string' ? JSON.parse(tu.input) : (tu.input || {});
+      } catch {}
+      const argKeys = typeof args === 'object' ? Object.keys(args).join(', ') : '';
+      parts.push(`[tool-call: ${tu.name || 'tool'}(${argKeys})]`);
+      toolCalls.push({ name: tu.name || 'tool', args });
+    } else if (block.ToolResult) {
+      const tr = block.ToolResult;
+      const preview = (tr.content || tr.output || '').substring(0, 500);
+      parts.push(`[tool-result: ${tr.tool_use_id || 'tool'}] ${preview}`);
+    } else if (block.Thinking) {
+      const text = typeof block.Thinking === 'string' ? block.Thinking : (block.Thinking.text || '');
+      if (text) parts.push(`[thinking] ${text}`);
+    }
+  }
+  return { text: parts.join('\n') || '', toolCalls };
+}
+
+const labels = { 'zed': 'Zed' };
+
+function getMCPServers() {
+  const results = [];
+  // Zed stores MCP servers in ~/.config/zed/settings.json under context_servers key
+  const settingsPath = path.join(getZedDataPath(), 'settings.json');
+  if (!fs.existsSync(settingsPath)) return results;
+  try {
+    const data = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+    const servers = data.context_servers || {};
+    for (const [name, cfg] of Object.entries(servers)) {
+      if (typeof cfg !== 'object') continue;
+      const settings = cfg.settings || {};
+      results.push({
+        name,
+        editor: 'zed',
+        editorLabel: 'Zed',
+        scope: 'global',
+        configPath: settingsPath,
+        command: settings.command || cfg.command || null,
+        args: settings.args || cfg.args || [],
+        env: settings.env ? Object.keys(settings.env) : [],
+        url: settings.url || cfg.url || null,
+        transport: (settings.url || cfg.url) ? 'http' : 'stdio',
+        disabled: false,
+        disabledTools: [],
+      });
+    }
+  } catch {}
+  return results;
+}
+
+module.exports = { name, labels, getChats, getMessages, getMCPServers };

package/index.js

@@ -1,3 +1,425 @@
 #!/usr/bin/env node
-console.log('memhouse — agent conversation memory across 17 editors.');
-console.log('This name is reserved; the first public release is on its way.');
+
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+// ── Node.js version check ─────────────────────────────────
+const nodeVersion = process.versions.node;
+const [nodeMajor, nodeMinor] = nodeVersion.split('.').map(Number);
+const isNodeSupported =
+  (nodeMajor === 20 && nodeMinor >= 19) ||
+  (nodeMajor === 22 && nodeMinor >= 12) ||
+  nodeMajor === 23 || nodeMajor === 24 || nodeMajor >= 25;
+
+if (!isNodeSupported) {
+  console.error('');
+  console.error(`  \x1b[31m✗ Unsupported Node.js version: v${nodeVersion}\x1b[0m`);
+  console.error('');
+  console.error(`  \x1b[1mAgentlytics requires Node.js 20.19+ or 22.12+\x1b[0m`);
+  console.error(`  \x1b[2mYour current version: v${nodeVersion}\x1b[0m`);
+  console.error('');
+  console.error(`  \x1b[2mTo upgrade, visit: https://nodejs.org\x1b[0m`);
+  console.error(`  \x1b[2mOr use a version manager: nvm install 22\x1b[0m`);
+  console.error('');
+  process.exit(1);
+}
+
+const HOME = os.homedir();
+
+// ── Detect package manager ─────────────────────────────────
+function detectPackageManager() {
+  const ua = process.env.npm_config_user_agent || '';
+  if (ua.startsWith('pnpm/')) return 'pnpm';
+  if (ua.startsWith('yarn/')) return 'yarn';
+  if (ua.startsWith('bun/')) return 'bun';
+  return 'npm';
+}
+const PM = detectPackageManager();
+const PM_RUN = PM === 'npm' ? 'npx' : PM === 'pnpm' ? 'pnpm dlx' : PM === 'yarn' ? 'yarn dlx' : 'bunx';
+const PORT = process.env.PORT || 4637;
+const RELAY_PORT = process.env.RELAY_PORT || 4638;
+const noCache = process.argv.includes('--no-cache');
+const collectOnly = process.argv.includes('--collect');
+const isUiDev = process.argv.includes('--ui-dev');
+const isRelay = process.argv.includes('--relay');
+const joinIndex = process.argv.indexOf('--join');
+const isJoin = joinIndex !== -1;
+
+// ── Relay mode ───────────────────────────────────────────────
+if (isRelay) {
+  // Loopback by default; exposing to the network is an explicit opt-in AND
+  // fail-closed: a non-loopback bind without RELAY_PASSWORD would let any
+  // network client read all transcripts, upload/overwrite sessions, and merge
+  // users — refuse before touching anything.
+  const RELAY_HOST = process.env.RELAY_HOST || '127.0.0.1';
+  const relayLoopback = RELAY_HOST === '127.0.0.1' || RELAY_HOST === 'localhost' || RELAY_HOST === '::1';
+  if (!relayLoopback && !process.env.RELAY_PASSWORD) {
+    console.error(chalk.red(`  ✗ Refusing to bind relay to ${RELAY_HOST} without RELAY_PASSWORD.`));
+    console.error(chalk.dim('    Set RELAY_PASSWORD, or drop RELAY_HOST to stay loopback-only.'));
+    process.exit(1);
+  }
+
+  const { initRelayDb, getRelayDb, createRelayApp } = require('./relay-server');
+  const { wireMcpToExpress } = require('./mcp-server');
+
+  console.log('');
+  console.log(chalk.bold('  ⚡ Agentlytics Relay'));
+  console.log(chalk.dim('  Multi-user context sharing server'));
+  console.log('');
+
+  initRelayDb();
+  console.log(chalk.green('  ✓ Relay database initialized'));
+
+  const app = createRelayApp();
+  wireMcpToExpress(app, getRelayDb);
+  console.log(chalk.green('  ✓ MCP server registered'));
+
+  if (process.env.RELAY_PASSWORD) {
+    console.log(chalk.green('  ✓ Password protection enabled'));
+  } else {
+    console.log(chalk.yellow('  ⚠ No password set (loopback-only; set RELAY_PASSWORD before exposing with RELAY_HOST)'));
+  }
+
+  app.listen(RELAY_PORT, RELAY_HOST, () => {
+    const localIp = relayLoopback ? '127.0.0.1' : getLocalIp();
+    const relayUrl = `http://${localIp}:${RELAY_PORT}`;
+
+    console.log('');
+    console.log(chalk.green(`  ✓ Relay server running on port ${RELAY_PORT}`));
+    console.log('');
+    console.log(chalk.bold('  Team sharing:'));
+    console.log(chalk.dim('    Relay join is not supported in memhouse — members ship with their own'));
+    console.log(chalk.dim('    credentials (kernel-based): see mem-house/delivery/kernel-install.md'));
+    console.log('');
+    console.log(chalk.bold('  MCP server endpoint (add to your AI client):'));
+    console.log('');
+    console.log(chalk.cyan(`    ${relayUrl}/mcp`));
+    if (process.env.RELAY_PASSWORD) {
+      console.log(chalk.dim('    (password protection is on — clients must send the bearer token from /api/login)'));
+    }
+    console.log('');
+    console.log(chalk.dim('  REST endpoints:'));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/health`));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/users`));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/search?q=<query>`));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/activity/<username>`));
+    console.log(chalk.dim(`    GET  ${relayUrl}/relay/session/<chatId>`));
+    console.log('');
+    console.log(chalk.dim('  Press Ctrl+C to stop'));
+    console.log('');
+  });
+
+  // Skip the rest of the normal flow
+  return;
+}
+
+// ── Join mode ────────────────────────────────────────────────
+if (isJoin) {
+  // Fail fast: the relay join client still targets the removed synchronous SQLite
+  // cache (relay-client.js pickProjects → cache.getDb), which the ClickHouse
+  // cutover eliminated — it would crash after connecting. In memhouse, team
+  // sharing is the kernel path (members + owner grants + RLS), not relay.
+  console.error(chalk.red('\n  ✗ Relay join is not supported in memhouse.'));
+  console.error(chalk.dim('    Team sharing here is kernel-based: see mem-house/delivery/kernel-install.md'));
+  console.error(chalk.dim('    (register-member + owner GRANT + own-only RLS).\n'));
+  process.exit(1);
+}
+
+// ── Helper: get local IP for relay ───────────────────────────
+function getLocalIp() {
+  const interfaces = os.networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    for (const iface of interfaces[name]) {
+      if (iface.family === 'IPv4' && !iface.internal) return iface.address;
+    }
+  }
+  return 'localhost';
+}
+
+// ── ASCII banner ─────────────────────────────────────────
+const c1 = chalk.hex('#818cf8'), c2 = chalk.hex('#f472b6'), c3 = chalk.hex('#34d399'), c4 = chalk.hex('#fbbf24');
+console.log('');
+console.log(`  ${c1('(● ●)')} ${c2('[● ●]')}   ${chalk.bold('Agentlytics')}`);
+console.log(`  ${c3('{● ●}')} ${c4('<● ●>')}   ${chalk.dim('Unified analytics for your AI coding agents')}`);
+if (collectOnly) console.log(chalk.cyan('  ⟳ Collect-only mode (no server)'));
+console.log('');
+
+// ── Build UI if not already built ──────────────────────────
+const publicIndex = path.join(__dirname, 'public', 'index.html');
+const uiDir = path.join(__dirname, 'ui');
+
+if (!collectOnly && !isUiDev && !fs.existsSync(publicIndex) && fs.existsSync(uiDir)) {
+  console.log(chalk.cyan('  ⟳ Building dashboard UI (first run)...'));
+  try {
+    const uiModules = path.join(uiDir, 'node_modules');
+    if (fs.existsSync(uiModules)) fs.rmSync(uiModules, { recursive: true, force: true });
+    console.log(chalk.dim('    Installing UI dependencies...'));
+    const installCmd = PM === 'npm' ? 'npm install --no-audit --no-fund'
+      : PM === 'pnpm' ? 'pnpm install --no-frozen-lockfile'
+      : PM === 'yarn' ? 'yarn install'
+      : 'bun install';
+    const buildCmd = `${PM} run build`;
+    execSync(installCmd, { cwd: uiDir, stdio: 'pipe' });
+    console.log(chalk.dim('    Compiling frontend...'));
+    execSync(buildCmd, { cwd: uiDir, stdio: 'pipe' });
+    console.log(chalk.green('  ✓ UI built successfully'));
+  } catch (err) {
+    console.error(chalk.red('  ✗ UI build failed:'), err.message);
+    process.exit(1);
+  }
+  console.log('');
+}
+
+if (!collectOnly && !isUiDev && !fs.existsSync(publicIndex)) {
+  console.error(chalk.red('  ✗ No built UI found at public/index.html'));
+  console.error(chalk.dim(`    Run: cd ui && ${PM} install && ${PM} run build`));
+  process.exit(1);
+}
+
+// ── ClickHouse cache (no native module to build) ────────────
+const cache = require('./cache');
+// --no-cache is handled in the async flow below (ClickHouse truncate needs await).
+
+// ── Warn about installed-but-not-running Devin variants (macOS only) ─
+if (process.platform === 'darwin') {
+const DEVIN_DESKTOP_VARIANTS = [
+  {
+    name: 'Devin',
+    apps: ['/Applications/Devin Desktop.app', '/Applications/Devin.app', '/Applications/Windsurf.app'],
+    dataDirs: [path.join(HOME, '.windsurf'), path.join(HOME, '.codeium', 'windsurf')],
+    ides: ['devin-desktop', 'devin', 'windsurf'],
+  },
+  {
+    name: 'Devin Next',
+    apps: ['/Applications/Devin Desktop Next.app', '/Applications/Devin Next.app', '/Applications/Windsurf Next.app'],
+    dataDirs: [path.join(HOME, '.codeium', 'windsurf-next')],
+    ides: ['devin-desktop-next', 'devin-next', 'windsurf-next'],
+  },
+  { name: 'Antigravity', app: '/Applications/Antigravity.app', dataDir: path.join(HOME, '.codeium', 'antigravity'), ide: 'antigravity' },
+];
+
+(() => {
+  // Check which language servers are running
+  let runningIdes = [];
+  try {
+    const ps = execSync('ps aux', { encoding: 'utf-8', maxBuffer: 1024 * 1024 });
+    for (const line of ps.split('\n')) {
+      if (!line.includes('language_server_macos')) continue;
+      const ideMatch = line.match(/--ide_name\s+(\S+)/);
+      const appDirMatch = line.match(/--app_data_dir\s+(\S+)/);
+      if (ideMatch) runningIdes.push(ideMatch[1]);
+      if (appDirMatch) runningIdes.push(appDirMatch[1]);
+    }
+  } catch {}
+
+  const installedNotRunning = DEVIN_DESKTOP_VARIANTS.filter(v => {
+    const apps = v.apps || [v.app];
+    const dataDirs = v.dataDirs || [v.dataDir];
+    const ides = v.ides || [v.ide];
+    const installed = apps.some(app => fs.existsSync(app)) || dataDirs.some(dataDir => fs.existsSync(dataDir));
+    const running = runningIdes.some(r => ides.some(ide => r === ide || r.includes(ide)));
+    return installed && !running;
+  });
+
+  if (installedNotRunning.length > 0) {
+    const names = installedNotRunning.map(v => chalk.bold(v.name)).join(', ');
+    console.log(chalk.yellow(`  ⚠ ${names} installed but not running`));
+    console.log(chalk.dim('    These editors must be open for their sessions to be detected.'));
+    console.log('');
+  }
+})();
+}
+
+// Cache DB is initialized (and optionally cleared) inside the async flow below.
+
+// ── Detect editors & collect sessions ───────────────────────
+const { editors: editorModules, editorLabels } = require('./editors');
+
+console.log(chalk.dim('  Looking for AI coding agents...'));
+const allChats = [];
+for (const editor of editorModules) {
+  try {
+    const chats = editor.getChats();
+    allChats.push(...chats);
+  } catch { /* skip broken adapters */ }
+}
+allChats.sort((a, b) => (b.lastUpdatedAt || b.createdAt || 0) - (a.lastUpdatedAt || a.createdAt || 0));
+
+// Count per source
+const bySource = {};
+for (const chat of allChats) bySource[chat.source] = (bySource[chat.source] || 0) + 1;
+
+const displayByLabel = new Map();
+for (const [src, label] of Object.entries(editorLabels)) {
+  const existing = displayByLabel.get(label) || { label, count: 0 };
+  existing.count += bySource[src] || 0;
+  displayByLabel.set(label, existing);
+}
+
+const displayList = Array.from(displayByLabel.values())
+  .map(({ label, count }) => [label, count])
+  .sort((a, b) => b[1] - a[1]);
+
+for (const [label, count] of displayList) {
+  if (count > 0) {
+    console.log(`  ${chalk.green('✓')} ${chalk.bold(label.padEnd(18))} ${chalk.dim(`${count} session${count === 1 ? '' : 's'}`)}`);
+  } else {
+    console.log(`  ${chalk.dim('–')} ${chalk.dim(label.padEnd(18) + '–')}`);
+  }
+}
+console.log('');
+
+// ── Analyze sessions with robot animation (async to allow Ctrl+C) ──
+const logUpdate = require('log-update');
+const BOT_STYLES = [
+  { l: '(', r: ')', color: '#818cf8' },
+  { l: '[', r: ']', color: '#f472b6' },
+  { l: '{', r: '}', color: '#34d399' },
+  { l: '<', r: '>', color: '#fbbf24' },
+];
+
+(async () => {
+  // Initialize the ClickHouse cache (ensure DB + schema); optionally clear it.
+  await cache.initDb();
+  if (noCache) {
+    await cache.clearAll();
+    console.log(chalk.yellow('  ⟳ Cache cleared (--no-cache)'));
+  }
+
+  // ── Ask for subscription access permission (first run only) ──
+  const CONFIG_DIR = path.join(os.homedir(), '.agentlytics');
+  const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+  let agentConfig = {};
+  try { agentConfig = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8')); } catch {}
+
+  if (agentConfig.allowSubscriptionAccess === undefined) {
+    console.log(chalk.yellow('  ⚠ Subscription & usage details require access to local auth tokens.'));
+    console.log('');
+    console.log(chalk.dim('    To show your plan and usage info, Agentlytics needs to read'));
+    console.log(chalk.dim('    locally stored tokens from the following sources:'));
+    console.log('');
+    console.log(chalk.dim('      • Claude Code  – macOS Keychain / Linux secret-tool'));
+    console.log(chalk.dim('      • Cursor       – local SQLite (state.vscdb)'));
+    console.log(chalk.dim('      • Copilot      – ~/.config/github-copilot/apps.json'));
+    console.log(chalk.dim('      • VS Code      – ~/.config/github-copilot/apps.json'));
+    console.log(chalk.dim('      • Codex        – local auth.json (JWT decode only)'));
+    console.log(chalk.dim('      • Devin        – local SQLite (state.vscdb)'));
+    console.log('');
+    console.log(chalk.dim('    These tokens are used to query each editor\'s own API for'));
+    console.log(chalk.dim('    your plan name and usage limits.'));
+    console.log('');
+    console.log(chalk.bold.white('    → Tokens are kept in-memory only and never sent to any'));
+    console.log(chalk.bold.white('      third-party service. They are discarded after the request.'));
+    console.log('');
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise(r => {
+      rl.question(chalk.bold('  Allow local token inspection for subscription details? (y/N) '), (a) => {
+        rl.close();
+        r(a.trim().toLowerCase());
+      });
+    });
+    agentConfig.allowSubscriptionAccess = answer === 'y' || answer === 'yes';
+    if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(agentConfig, null, 2));
+    if (agentConfig.allowSubscriptionAccess) {
+      console.log(chalk.green('  ✓ Subscription access enabled'));
+    } else {
+      console.log(chalk.dim('  – Subscription access skipped (plan/usage details won\'t be collected)'));
+    }
+    console.log('');
+  }
+
+  let tick = 0;
+  const startTime = Date.now();
+  const result = await cache.scanAllAsync((p) => {
+    tick++;
+    if (tick % 5 !== 0) return;
+    const frame = Math.floor(tick / 40);
+    const b = BOT_STYLES[frame % 4];
+    const dots = '.'.repeat((Math.floor(tick / 10) % 3) + 1).padEnd(3);
+    logUpdate(`  ${chalk.hex(b.color)(`${b.l}● ●${b.r}`)}  ${chalk.dim(`Analyzing${dots} ${p.scanned}/${p.total}`)}`);
+  }, { chats: allChats });
+  const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
+  const allFaces = BOT_STYLES.map(b => chalk.hex(b.color)(`${b.l}● ●${b.r}`)).join(' ');
+  logUpdate(`  ${allFaces}  ${chalk.green(`✓ ${result.analyzed} analyzed, ${result.skipped} cached (${elapsed}s)`)}`);
+  logUpdate.done();
+  console.log('');
+
+  // In collect-only mode, exit after cache is built
+  if (collectOnly) {
+    const { config } = require('./clickhouse');
+    console.log(chalk.dim(`  Cache: ClickHouse ${config.database} @ ${config.url}`));
+    console.log('');
+    process.exit(0);
+  }
+
+  // Start server (kill stale agentlytics or find free port)
+  const app = require('./server');
+  const http = require('http');
+  const net = require('net');
+
+  // Pre-cache MCP server configs (runs in background, non-blocking). Live tool
+  // discovery — which EXECUTES configured servers — only happens when the user
+  // opted in via AGENTLYTICS_MCP_DISCOVERY=1 (see server.js initMcpToolsCache).
+  const mcpDiscovery = process.env.AGENTLYTICS_MCP_DISCOVERY === '1'
+    || process.env.AGENTLYTICS_MCP_DISCOVERY === 'true';
+  app.initMcpToolsCache().then(() => {
+    console.log(chalk.green(mcpDiscovery
+      ? '  ✓ MCP tools cached'
+      : '  ✓ MCP configs listed (tool discovery off — enable with AGENTLYTICS_MCP_DISCOVERY=1)'));
+  }).catch(() => {});
+
+  function isPortFree(port) {
+    return new Promise((resolve) => {
+      const tester = net.createServer()
+        .once('error', () => resolve(false))
+        .once('listening', () => tester.close(() => resolve(true)))
+        .listen(port, '0.0.0.0');
+    });
+  }
+
+  async function startServer(port) {
+    const free = await isPortFree(port);
+    if (!free) {
+      // Port in use — check if it's a previous agentlytics instance
+      try {
+        const data = await new Promise((resolve, reject) => {
+          const req = http.get(`http://127.0.0.1:${port}/api/ping`, { timeout: 2000 }, (res) => {
+            let body = '';
+            res.on('data', (d) => body += d);
+            res.on('end', () => { try { resolve(JSON.parse(body)); } catch { reject(); } });
+          });
+          req.on('error', reject);
+        });
+        if (data.app === 'agentlytics' && data.pid) {
+          console.log(chalk.yellow(`  ⟳ Killing previous Agentlytics instance (PID ${data.pid})...`));
+          try { process.kill(data.pid, 'SIGTERM'); } catch {}
+          await new Promise(r => setTimeout(r, 1000));
+          return startServer(port);
+        }
+      } catch {}
+      console.log(chalk.yellow(`  ⚠ Port ${port} is in use by another app, trying ${port + 1}...`));
+      return startServer(port + 1);
+    }
+
+    // Loopback by default — the dashboard exposes transcripts and a SQL console
+    // with no auth. LAN exposure is an explicit opt-in (AGENTLYTICS_HOST=0.0.0.0).
+    const HOST = process.env.AGENTLYTICS_HOST || '127.0.0.1';
+    app.listen(port, HOST, () => {
+      if (isUiDev) return;
+      const url = `http://localhost:${port}`;
+      console.log(chalk.green(`  ✓ Dashboard ready at ${chalk.bold.white(url)}`));
+      console.log('');
+      console.log(chalk.dim('  Press Ctrl+C to stop\n'));
+
+      const open = require('open');
+      open(url).catch(() => {});
+    });
+  }
+
+  startServer(parseInt(PORT));
+})();