venombrowser 4.1.0

package/src/bridge-server.js

@@ -0,0 +1,476 @@
+/**
+ * VenomBrowser Bridge Server — Kimi-style single-port daemon
+ *
+ * v4.1.0 — Stability rewrite:
+ *   - Global error handlers (no crashes)
+ *   - Protected WebSocket send (no crash on disconnect mid-command)
+ *   - Proper keepalive with timeout detection
+ *   - HTTP server error handling
+ *   - Graceful degradation
+ */
+
+require('dotenv').config();
+
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const WebSocket = require('ws');
+const { v4: uuidv4 } = require('uuid');
+
+const PORT = parseInt(process.env.BRIDGE_PORT || '10086', 10);
+const WS_PORT = parseInt(process.env.WS_PORT || String(PORT + 1), 10);
+const WS_PING_INTERVAL = 15000;
+const WS_PING_TIMEOUT = 10000;
+const CMD_TIMEOUT = 30000;
+const SCREENSHOT_DIR = path.join(__dirname, '..', '..', 'screenshots');
+
+class VenomBrowserBridgeServer {
+  constructor() {
+    this.extensionWs = null;
+    this.pending = new Map();
+    this.sessions = new Map();
+    this.startTime = Date.now();
+    this.commandCount = 0;
+    this.lastCommand = null;
+    this.lastCommandAt = null;
+    this.extensionInfo = null;
+    this.currentTab = null;
+    this.pingTimer = null;
+    this.lastPong = Date.now();
+
+    this.startHTTP();
+    this.startWS();
+    this.startPingLoop();
+  }
+
+  // ─── Safe WebSocket send ─────────────────────────────────────────────────
+  safeSend(ws, data) {
+    try {
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(typeof data === 'string' ? data : JSON.stringify(data));
+        return true;
+      }
+    } catch (e) {
+      console.error('[Bridge] safeSend error:', e.message);
+    }
+    return false;
+  }
+
+  // ─── HTTP Server ─────────────────────────────────────────────────────────
+  startHTTP() {
+    this.httpServer = http.createServer((req, res) => {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+      if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
+
+      const send = (status, data) => {
+        try {
+          res.writeHead(status, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify(data));
+        } catch (_) {}
+      };
+
+      if (req.method === 'GET' && req.url === '/health') {
+        return send(200, {
+          server: 'ok',
+          extension: this.isConnected() ? 'connected' : 'disconnected',
+          port: PORT
+        });
+      }
+
+      if (req.method === 'GET' && req.url === '/status') {
+        return send(200, {
+          success: true,
+          connected: this.isConnected(),
+          uptime_seconds: ((Date.now() - this.startTime) / 1000).toFixed(1),
+          commands_executed: this.commandCount,
+          pending_commands: this.pending.size,
+          active_sessions: this.sessions.size,
+          last_command: this.lastCommand,
+          last_command_at: this.lastCommandAt,
+          extension: this.extensionInfo
+        });
+      }
+
+      if (req.method === 'POST' && req.url === '/command') {
+        let body = '';
+        req.on('data', chunk => { body += chunk; });
+        req.on('end', async () => {
+          let request;
+          try {
+            request = JSON.parse(body);
+          } catch (e) {
+            return send(400, { success: false, error: 'Invalid JSON' });
+          }
+          try {
+            const result = await this.handleCommand(request);
+            send(200, { success: true, ...result });
+          } catch (e) {
+            const code = e.message.includes('not connected') ? 503
+              : e.message.includes('timed out') ? 408
+              : 500;
+            send(code, { success: false, error: e.message });
+          }
+        });
+        return;
+      }
+
+      send(404, { success: false, error: 'Not found. Use POST /command' });
+    });
+
+    this.httpServer.on('error', (e) => {
+      console.error('[Bridge] HTTP server error:', e.message);
+      if (e.code === 'EADDRINUSE') {
+        console.error(`[Bridge] Port ${PORT} is already in use. Kill the other process or change BRIDGE_PORT in .env`);
+        process.exit(1);
+      }
+    });
+
+    this.httpServer.listen(PORT, '127.0.0.1', () => {
+      console.log(`[Bridge] HTTP on http://127.0.0.1:${PORT}`);
+    });
+  }
+
+  // ─── Command handler ─────────────────────────────────────────────────────
+  async handleCommand(request) {
+    const { action, args = {}, session = 'default', tabId } = request;
+
+    if (!action) throw new Error('action is required');
+
+    if (!this.sessions.has(session)) {
+      this.sessions.set(session, { tabs: new Set(), startTime: Date.now(), commandCount: 0 });
+    }
+    this.sessions.get(session).commandCount++;
+
+    if (action === 'health') return { service: 'venombrowser-bridge' };
+
+    if (action === 'status') {
+      return {
+        connected: this.isConnected(),
+        uptime_seconds: ((Date.now() - this.startTime) / 1000).toFixed(1),
+        commands_executed: this.commandCount,
+        pending_commands: this.pending.size,
+        active_sessions: this.sessions.size
+      };
+    }
+
+    if (!this.isConnected()) throw new Error('Extension not connected');
+
+    return this.executeAction(action, args, session, tabId);
+  }
+
+  // ─── Action router ───────────────────────────────────────────────────────
+  async executeAction(action, args, session, tabId) {
+    const send = (cmd, params = {}, tid = null, timeout = CMD_TIMEOUT) =>
+      this.sendToExtension(cmd, params, tid, timeout);
+
+    switch (action) {
+      case 'navigate': {
+        const { url, newTab = false } = args;
+        if (!url) throw new Error('url is required');
+        if (newTab) {
+          const r = await send('NEW_TAB', { url, active: true });
+          if (r.result?.tabId) this.sessions.get(session)?.tabs.add(r.result.tabId);
+          return { url: r.result?.url ?? url, tabId: r.result?.tabId };
+        }
+        const r = await send('NAVIGATE', { url, waitForLoad: true }, tabId);
+        if (r.result?.tabId) {
+          this.currentTab = r.result.tabId;
+          this.sessions.get(session)?.tabs.add(r.result.tabId);
+        }
+        return { url: r.result?.url ?? url, tabId: r.result?.tabId, title: r.result?.title };
+      }
+
+      case 'find_tab': {
+        const { url, active = false } = args;
+        if (active) {
+          const r = await send('GET_ACTIVE_TAB');
+          return { success: true, url: r.result?.url, tabId: r.result?.tabId, borrowed: true };
+        }
+        const r = await send('LIST_TABS');
+        const match = (r.result || []).find(t => t.url?.includes(url));
+        if (match) { this.currentTab = match.id; return { success: true, url: match.url, tabId: match.id }; }
+        throw new Error(`No tab matching ${url}`);
+      }
+
+      case 'list_tabs': {
+        const r = await send('LIST_TABS');
+        return { tabs: (r.result || []).map(t => ({ tabId: t.id, url: t.url, title: t.title, active: t.active })) };
+      }
+
+      case 'close_tab': {
+        const tid = tabId || this.currentTab;
+        if (!tid) throw new Error('No tab to close');
+        await send('CLOSE_TAB', {}, tid);
+        this.sessions.get(session)?.tabs.delete(tid);
+        if (this.currentTab === tid) this.currentTab = null;
+        return { closed: true };
+      }
+
+      case 'close_session': {
+        const tabs = this.sessions.get(session)?.tabs || new Set();
+        let closed = 0;
+        for (const t of tabs) { try { await send('CLOSE_TAB', {}, t); closed++; } catch (_) {} }
+        tabs.clear();
+        this.sessions.delete(session);
+        return { closed };
+      }
+
+      case 'snapshot': {
+        const r = await send('SNAPSHOT', {}, tabId || this.currentTab);
+        const res = r.result || {};
+        return { url: res.url, title: res.title, refCount: res.refCount, elements: res.elements };
+      }
+
+      case 'click': {
+        const r = await send('CLICK', { selector: args.selector }, tabId || this.currentTab);
+        return { success: true, tag: r.result?.tag, text: r.result?.text };
+      }
+
+      case 'fill': {
+        const r = await send('TYPE', { selector: args.selector, text: args.value, clear: true }, tabId || this.currentTab);
+        return { success: true, typed: r.result?.typed, length: r.result?.length };
+      }
+
+      case 'type': {
+        const r = await send('TYPE', { selector: args.selector, text: args.text, clear: args.clear, pressEnter: args.pressEnter }, tabId || this.currentTab);
+        return { success: true, typed: r.result?.typed, length: r.result?.length };
+      }
+
+      case 'submit_form': {
+        const r = await send('SUBMIT_FORM', { selector: args.selector }, tabId || this.currentTab);
+        return { success: true, submitted: r.result?.submitted, action: r.result?.action, method: r.result?.method };
+      }
+
+      case 'evaluate': {
+        const r = await send('EVALUATE', { code: args.code }, tabId || this.currentTab, 30000);
+        return { type: r.result?.type, value: r.result?.result };
+      }
+
+      case 'cdp': {
+        const r = await send('CDP', { method: args.method, params: args.params }, tabId || this.currentTab, 30000);
+        return r.result;
+      }
+
+      case 'screenshot': {
+        const r = await send('SCREENSHOT', { format: args.format, quality: args.quality }, tabId || this.currentTab);
+        // Save base64 to disk, return file path
+        if (r.result?.base64) {
+          if (!fs.existsSync(SCREENSHOT_DIR)) fs.mkdirSync(SCREENSHOT_DIR, { recursive: true });
+          const filename = `screenshot-${Date.now()}.${r.result.format || 'png'}`;
+          const filepath = path.join(SCREENSHOT_DIR, filename);
+          fs.writeFileSync(filepath, Buffer.from(r.result.base64, 'base64'));
+          return { format: r.result.format, path: filepath, filename, sizeBytes: r.result.sizeBytes, mimeType: r.result.mimeType };
+        }
+        return { format: r.result?.format, path: r.result?.path, sizeBytes: r.result?.sizeBytes, mimeType: r.result?.mimeType };
+      }
+
+      case 'network': {
+        const r = await send('NETWORK', { cmd: args.cmd, filter: args.filter, requestId: args.requestId }, tabId || this.currentTab);
+        return r.result;
+      }
+
+      case 'upload': {
+        const r = await send('UPLOAD', { selector: args.selector, files: args.files }, tabId || this.currentTab);
+        return { success: true, fileCount: r.result?.fileCount };
+      }
+
+      case 'save_as_pdf': {
+        const r = await send('SAVE_AS_PDF', args, tabId || this.currentTab, 60000);
+        if (r.result?.base64) {
+          if (!fs.existsSync(SCREENSHOT_DIR)) fs.mkdirSync(SCREENSHOT_DIR, { recursive: true });
+          const filename = `page-${Date.now()}.pdf`;
+          const filepath = path.join(SCREENSHOT_DIR, filename);
+          fs.writeFileSync(filepath, Buffer.from(r.result.base64, 'base64'));
+          return { path: filepath, sizeBytes: r.result.sizeBytes, mimeType: r.result.mimeType, pageTitle: r.result.pageTitle };
+        }
+        return { path: r.result?.path, sizeBytes: r.result?.sizeBytes, mimeType: r.result?.mimeType, pageTitle: r.result?.pageTitle };
+      }
+
+      case 'scroll': {
+        const r = await send('SCROLL', { direction: args.direction || 'down', amount: args.amount || 500 }, tabId || this.currentTab);
+        return r.result;
+      }
+
+      default:
+        throw new Error(`Unknown action: ${action}`);
+    }
+  }
+
+  // ─── WebSocket server ────────────────────────────────────────────────────
+  startWS() {
+    this.wss = new WebSocket.Server({ port: WS_PORT }, () => {
+      console.log(`[Bridge] WebSocket on ws://localhost:${WS_PORT}`);
+    });
+
+    this.wss.on('error', (e) => {
+      console.error('[Bridge] WS server error:', e.message);
+      if (e.code === 'EADDRINUSE') {
+        console.error(`[Bridge] WS port ${WS_PORT} in use. Change WS_PORT in .env`);
+      }
+    });
+
+    this.wss.on('connection', (ws, req) => {
+      const addr = req.socket.remoteAddress || 'unknown';
+      console.log(`[Bridge] Extension connected from ${addr}`);
+
+      // Replace previous connection
+      if (this.extensionWs && this.extensionWs.readyState === WebSocket.OPEN) {
+        console.log('[Bridge] Replacing previous extension');
+        try { this.extensionWs.close(1000); } catch (_) {}
+      }
+
+      this.extensionWs = ws;
+      this.extensionInfo = { connectedAt: Date.now(), address: addr };
+      this.lastPong = Date.now();
+
+      ws.on('message', (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this.onExtMessage(ws, msg);
+        } catch (_) {}
+      });
+
+      ws.on('close', (code, reason) => {
+        console.log(`[Bridge] Extension disconnected (code=${code})`);
+        if (this.extensionWs === ws) {
+          this.extensionWs = null;
+          this.extensionInfo = null;
+          this.rejectAll('Extension disconnected');
+        }
+      });
+
+      ws.on('error', (err) => {
+        console.error('[Bridge] Extension socket error:', err.message);
+      });
+
+      // Welcome
+      this.safeSend(ws, { type: 'welcome', daemon: 'venombrowser-bridge', version: '4.1.0' });
+    });
+  }
+
+  onExtMessage(ws, msg) {
+    // Keepalive
+    if (msg.type === 'ping') {
+      this.lastPong = Date.now();
+      this.safeSend(ws, { type: 'pong', timestamp: Date.now() });
+      return;
+    }
+    if (msg.type === 'pong') {
+      this.lastPong = Date.now();
+      return;
+    }
+    if (msg.type === 'hello') {
+      console.log(`[Bridge] Extension handshake: ${msg.client} v${msg.version}`);
+      return;
+    }
+
+    // Command response
+    if (msg.id && this.pending.has(msg.id)) {
+      const entry = this.pending.get(msg.id);
+      clearTimeout(entry.timer);
+      this.pending.delete(msg.id);
+      this.commandCount++;
+      this.lastCommand = msg.id;
+      this.lastCommandAt = new Date().toISOString();
+      if (msg.status === 'success') {
+        entry.resolve(msg);
+      } else {
+        entry.reject(new Error(msg.error || 'Command failed'));
+      }
+    }
+  }
+
+  // ─── Keepalive ping loop ─────────────────────────────────────────────────
+  startPingLoop() {
+    this.pingTimer = setInterval(() => {
+      if (!this.extensionWs || this.extensionWs.readyState !== WebSocket.OPEN) return;
+
+      // Check if extension is dead (no pong in timeout period)
+      if (Date.now() - this.lastPong > WS_PING_TIMEOUT + WS_PING_INTERVAL) {
+        console.warn('[Bridge] Extension timed out — closing');
+        try { this.extensionWs.close(4001, 'Ping timeout'); } catch (_) {}
+        return;
+      }
+
+      this.safeSend(this.extensionWs, { type: 'ping', timestamp: Date.now() });
+    }, WS_PING_INTERVAL);
+  }
+
+  // ─── Send command to extension ───────────────────────────────────────────
+  sendToExtension(command, params = {}, tabId = null, timeoutMs = CMD_TIMEOUT) {
+    if (!this.isConnected()) {
+      return Promise.reject(new Error('Extension not connected'));
+    }
+
+    const id = uuidv4();
+    const normalizedTabId = tabId == null ? null : Number(tabId) || null;
+    const msg = { id, command, params, tabId: normalizedTabId, timeout: timeoutMs };
+
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new Error(`Command ${command} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      this.pending.set(id, { resolve, reject, timer });
+
+      if (!this.safeSend(this.extensionWs, msg)) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(new Error('Failed to send command to extension'));
+      }
+    });
+  }
+
+  rejectAll(reason) {
+    for (const { reject, timer } of this.pending.values()) {
+      clearTimeout(timer);
+      reject(new Error(reason));
+    }
+    this.pending.clear();
+  }
+
+  isConnected() {
+    return this.extensionWs?.readyState === WebSocket.OPEN;
+  }
+
+  shutdown() {
+    console.log('\n[Bridge] Shutting down...');
+    clearInterval(this.pingTimer);
+    this.rejectAll('Server shutting down');
+    try { this.extensionWs?.close(1000); } catch (_) {}
+    try { this.wss?.close(); } catch (_) {}
+    try {
+      this.httpServer?.close(() => {
+        console.log('[Bridge] Stopped.');
+        process.exit(0);
+      });
+    } catch (_) {}
+    setTimeout(() => process.exit(0), 2000);
+  }
+}
+
+// ─── Global error handlers (prevent crashes) ─────────────────────────────
+process.on('uncaughtException', (e) => {
+  console.error('[Bridge] UNCAUGHT EXCEPTION:', e.message);
+  // Don't exit — keep running
+});
+process.on('unhandledRejection', (reason) => {
+  console.error('[Bridge] UNHANDLED REJECTION:', reason);
+  // Don't exit — keep running
+});
+
+// ─── Start ────────────────────────────────────────────────────────────────
+console.log('🚀 Starting VenomBrowser Bridge Server v4.1.0...');
+const server = new VenomBrowserBridgeServer();
+console.log(`📡 WebSocket : ws://localhost:${WS_PORT}`);
+console.log(`🌐 HTTP API  : http://127.0.0.1:${PORT}/command`);
+console.log(`📋 Status    : http://127.0.0.1:${PORT}/status`);
+console.log('\nLoad extension from: ./extension/');
+console.log('Press Ctrl+C to stop.\n');
+
+process.on('SIGINT', () => server.shutdown());
+process.on('SIGTERM', () => server.shutdown());

package/src/connect.js

@@ -0,0 +1,220 @@
+/**
+ * VenomBrowser Connect — Auto-register MCP server with known agents
+ *
+ * Detects existing agent config files (Claude Desktop, OpenCode, Cursor)
+ * and merges a "venombrowser" MCP server entry into each without
+ * clobbering any existing entries.
+ *
+ * Uses jsonc-parser for reading/writing JSONC files, preserving comments
+ * and formatting in the user's config.
+ *
+ * Usage:
+ *   const { connect } = require('./connect');
+ *   await connect();          // auto-detect and register
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const jsonc = require('jsonc-parser');
+
+/**
+ * Build the MCP server entry object for Claude Desktop / Cursor format.
+ */
+function buildMcpEntry() {
+  const mcpPath = path.resolve(__dirname, '..', 'bin', 'venombrowser-mcp.js');
+  return {
+    command: 'node',
+    args: [mcpPath.replace(/\\/g, '/')],
+    env: { BRIDGE_PORT: '10086' }
+  };
+}
+
+/**
+ * Build the MCP server entry object for OpenCode format.
+ * OpenCode uses: { type: "local", command: [...], environment: {...} }
+ */
+function buildOpenCodeMcpEntry() {
+  const mcpPath = path.resolve(__dirname, '..', 'bin', 'venombrowser-mcp.js');
+  return {
+    type: 'local',
+    command: ['node', mcpPath.replace(/\\/g, '/')],
+    environment: { BRIDGE_PORT: '10086' }
+  };
+}
+
+/**
+ * Get the list of known agent config file paths to check.
+ * Returns an array of { name, path, format } objects.
+ * format is "mcpServers" for Claude Desktop/Cursor, "mcp" for OpenCode.
+ */
+function getAgentConfigPaths() {
+  const home = os.homedir();
+  const configs = [];
+
+  // Claude Desktop
+  if (process.platform === 'win32') {
+    const appdata = process.env.APPDATA || path.join(home, 'AppData', 'Roaming');
+    configs.push({
+      name: 'Claude Desktop',
+      path: path.join(appdata, 'Claude', 'claude_desktop_config.json'),
+      format: 'mcpServers'
+    });
+  } else {
+    configs.push({
+      name: 'Claude Desktop',
+      path: path.join(home, '.config', 'claude', 'claude_desktop_config.json'),
+      format: 'mcpServers'
+    });
+  }
+
+  // Cursor
+  configs.push({
+    name: 'Cursor',
+    path: path.join(home, '.cursor', 'mcp.json'),
+    format: 'mcpServers'
+  });
+
+  // OpenCode
+  configs.push({
+    name: 'OpenCode',
+    path: path.join(home, '.config', 'opencode', 'opencode.jsonc'),
+    format: 'mcp'
+  });
+
+  return configs;
+}
+
+/**
+ * Merge the venombrowser entry into a config file's mcpServers (Claude Desktop / Cursor).
+ * Uses jsonc-parser to preserve comments and formatting.
+ *
+ * @param {string} filePath - Absolute path to the config file
+ * @returns {{ merged: boolean, existed: boolean }} result
+ */
+function mergeIntoConfig(filePath) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return { merged: false, existed: false };
+  }
+
+  let config;
+  try {
+    config = jsonc.parse(content);
+  } catch {
+    console.warn(`  ⚠️  Skipping ${filePath} — invalid JSON`);
+    return { merged: false, existed: true };
+  }
+
+  // Ensure mcpServers key exists
+  if (!config.mcpServers || typeof config.mcpServers !== 'object') {
+    config.mcpServers = {};
+  }
+
+  // Check if already registered
+  if (config.mcpServers['venombrowser']) {
+    return { merged: false, existed: true, alreadyRegistered: true };
+  }
+
+  // Merge in the new entry — does NOT clobber existing entries
+  config.mcpServers['venombrowser'] = buildMcpEntry();
+
+  // Use jsonc-parser to write back, preserving comments and formatting
+  const edits = jsonc.modify(content, ['mcpServers', 'venombrowser'], buildMcpEntry(), { formattingOptions: { insertSpaces: true, tabSize: 2 } });
+  const updated = jsonc.applyEdits(content, edits);
+  fs.writeFileSync(filePath, updated, 'utf8');
+  return { merged: true, existed: true };
+}
+
+/**
+ * Merge the venombrowser entry into OpenCode's config file.
+ * OpenCode uses "mcp" key (not "mcpServers") and a different entry format.
+ * Preserves "$schema" and any existing "mcp" entries.
+ *
+ * @param {string} filePath - Absolute path to the config file
+ * @returns {{ merged: boolean, existed: boolean }} result
+ */
+function mergeIntoOpenCodeConfig(filePath) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return { merged: false, existed: false };
+  }
+
+  let config;
+  try {
+    config = jsonc.parse(content);
+  } catch {
+    console.warn(`  ⚠️  Skipping ${filePath} — invalid JSON`);
+    return { merged: false, existed: true };
+  }
+
+  // Ensure mcp key exists
+  if (!config.mcp || typeof config.mcp !== 'object') {
+    config.mcp = {};
+  }
+
+  // Check if already registered
+  if (config.mcp['venombrowser']) {
+    return { merged: false, existed: true, alreadyRegistered: true };
+  }
+
+  // Use jsonc-parser to write back, preserving comments and formatting
+  const entry = buildOpenCodeMcpEntry();
+  const edits = jsonc.modify(content, ['mcp', 'venombrowser'], entry, { formattingOptions: { insertSpaces: true, tabSize: 2 } });
+  const updated = jsonc.applyEdits(content, edits);
+  fs.writeFileSync(filePath, updated, 'utf8');
+  return { merged: true, existed: true };
+}
+
+/**
+ * Run the auto-registration across all known agent configs.
+ * @returns {string[]} List of agent names that were successfully registered.
+ */
+function connect() {
+  const entry = buildMcpEntry();
+  console.log('🔌 VenomBrowser Connect — Auto-registering MCP server with agents');
+  console.log('═'.repeat(55));
+  console.log(`   MCP entry: node ${entry.args[0]}`);
+  console.log();
+
+  const configs = getAgentConfigPaths();
+  const registered = [];
+
+  for (const { name, path: configPath, format } of configs) {
+    if (!fs.existsSync(configPath)) {
+      console.log(`   ⏭️  ${name}: config not found, skipping`);
+      continue;
+    }
+
+    const result = format === 'mcp'
+      ? mergeIntoOpenCodeConfig(configPath)
+      : mergeIntoConfig(configPath);
+
+    if (result.alreadyRegistered) {
+      console.log(`   ✅ ${name}: already registered`);
+      registered.push(name);
+    } else if (result.merged) {
+      console.log(`   ✅ ${name}: registered successfully`);
+      registered.push(name);
+    } else if (result.existed) {
+      console.log(`   ⚠️  ${name}: skipped (could not merge)`);
+    }
+  }
+
+  console.log();
+  if (registered.length > 0) {
+    console.log(`🎉 Registered with: ${registered.join(', ')}`);
+  } else {
+    console.log('ℹ️  No agent configs found. You can manually add VenomBrowser to your agent\'s MCP config:');
+    console.log(JSON.stringify({ 'venombrowser': entry }, null, 2));
+  }
+  console.log();
+
+  return registered;
+}
+
+module.exports = { connect, buildMcpEntry, buildOpenCodeMcpEntry, mergeIntoConfig, mergeIntoOpenCodeConfig, getAgentConfigPaths };