venombrowser 4.1.0

package/src/tools/browser-tools.js

@@ -0,0 +1,364 @@
+/**
+ * VenomBrowser Browser Tools — Kimi-style tool definitions & execution
+ *
+ * Single source of truth for:
+ *   1. Tool schemas (Kimi-style actions)
+ *   2. Tool execution logic (routes to bridge-client)
+ *
+ * v4.0.0 — Kimi-style architecture:
+ *   - Actions match Kimi WebBridge: navigate, snapshot, click, fill, evaluate, etc.
+ *   - Screenshot returns file path, NOT base64 (fixes cost leak)
+ *   - Added: upload, save_as_pdf, network, cdp
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const SCREENSHOT_DIR = path.join(__dirname, '..', '..', 'screenshots');
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Tool Definitions — Kimi-style actions
+// ─────────────────────────────────────────────────────────────────────────────
+
+const TOOL_DEFINITIONS = [
+  {
+    type: 'function',
+    function: {
+      name: 'navigate',
+      description: 'Navigate the browser to a URL. First call opens a tab.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'URL to navigate to' },
+          newTab: { type: 'boolean', description: 'Open in a new tab. Default false.' },
+          group_title: { type: 'string', description: 'Tab group label (first navigate only)' }
+        },
+        required: ['url']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'find_tab',
+      description: 'Re-select a tab opened this session, or borrow the user\'s active tab.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'URL to find' },
+          active: { type: 'boolean', description: 'Borrow the user\'s currently viewed tab. Default false.' }
+        },
+        required: ['url']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'snapshot',
+      description: 'Get the page accessibility tree with @e refs for interactive elements. Use this to read page content and locate elements for click/fill.',
+      parameters: { type: 'object', properties: {} }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'click',
+      description: 'Click an element by @e ref (from snapshot) or CSS selector.',
+      parameters: {
+        type: 'object',
+        properties: {
+          selector: { type: 'string', description: '@e ref (e.g. "@e3") or CSS selector' }
+        },
+        required: ['selector']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'fill',
+      description: 'Fill an input/textarea/contenteditable with text. Works on React/Vue controlled inputs.',
+      parameters: {
+        type: 'object',
+        properties: {
+          selector: { type: 'string', description: '@e ref or CSS selector' },
+          value: { type: 'string', description: 'Text to fill' }
+        },
+        required: ['selector', 'value']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'type',
+      description: 'Type text into an input and optionally press Enter. Use for search boxes.',
+      parameters: {
+        type: 'object',
+        properties: {
+          selector: { type: 'string', description: '@e ref or CSS selector' },
+          text: { type: 'string', description: 'Text to type' },
+          pressEnter: { type: 'boolean', description: 'Press Enter after typing' }
+        },
+        required: ['selector', 'text']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'submit_form',
+      description: 'Submit the form containing the given element. More reliable than pressing Enter.',
+      parameters: {
+        type: 'object',
+        properties: {
+          selector: { type: 'string', description: '@e ref or CSS selector of element inside the form' }
+        },
+        required: ['selector']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'evaluate',
+      description: 'Execute JavaScript in the page context. Returns the result.',
+      parameters: {
+        type: 'object',
+        properties: {
+          code: { type: 'string', description: 'JavaScript code to execute' }
+        },
+        required: ['code']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'cdp',
+      description: 'Raw Chrome DevTools Protocol command. Low-level escape hatch for cases other tools don\'t cover.',
+      parameters: {
+        type: 'object',
+        properties: {
+          method: { type: 'string', description: 'CDP method (e.g. "Runtime.evaluate")' },
+          params: { type: 'object', description: 'CDP method parameters' }
+        },
+        required: ['method']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'screenshot',
+      description: 'Capture a screenshot. Returns file path, not base64.',
+      parameters: {
+        type: 'object',
+        properties: {
+          format: { type: 'string', enum: ['png', 'jpeg'], description: 'Image format. Default "png".' },
+          quality: { type: 'number', description: 'JPEG quality (0-100). Only for jpeg format.' },
+          selector: { type: 'string', description: '@e ref or CSS selector to screenshot a specific element.' },
+          path: { type: 'string', description: 'Custom output path.' }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'network',
+      description: 'Monitor network requests: start/stop capture, list requests, get details.',
+      parameters: {
+        type: 'object',
+        properties: {
+          cmd: { type: 'string', enum: ['start', 'stop', 'list', 'detail'], description: 'Network command' },
+          filter: { type: 'string', description: 'URL filter for list command' },
+          requestId: { type: 'string', description: 'Request ID for detail command' }
+        },
+        required: ['cmd']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'upload',
+      description: 'Upload files to a file input element.',
+      parameters: {
+        type: 'object',
+        properties: {
+          selector: { type: 'string', description: 'CSS selector of the file input' },
+          files: { type: 'array', items: { type: 'string' }, description: 'File paths to upload' }
+        },
+        required: ['selector', 'files']
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'save_as_pdf',
+      description: 'Save the current page as a PDF file.',
+      parameters: {
+        type: 'object',
+        properties: {
+          paper_format: { type: 'string', enum: ['letter', 'a4', 'legal', 'a3', 'tabloid'], description: 'Paper size. Default "letter".' },
+          landscape: { type: 'boolean', description: 'Landscape orientation. Default false.' },
+          scale: { type: 'number', description: 'Scale (0.1-2.0). Default 1.0.' },
+          print_background: { type: 'boolean', description: 'Print background colors. Default true.' },
+          path: { type: 'string', description: 'Custom output path.' }
+        }
+      }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_tabs',
+      description: 'List all open browser tabs.',
+      parameters: { type: 'object', properties: {} }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'close_tab',
+      description: 'Close the current tab in the session.',
+      parameters: { type: 'object', properties: {} }
+    }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'close_session',
+      description: 'Close all tabs in the session.',
+      parameters: { type: 'object', properties: {} }
+    }
+  }
+];
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Tool Execution — routes to bridge-client (Kimi-style)
+// ─────────────────────────────────────────────────────────────────────────────
+
+function ensureScreenshotDir() {
+  if (!fs.existsSync(SCREENSHOT_DIR)) {
+    fs.mkdirSync(SCREENSHOT_DIR, { recursive: true });
+  }
+}
+
+async function executeTool(bridge, name, args = {}) {
+  switch (name) {
+    case 'navigate': {
+      const r = await bridge.navigate(args.url, { newTab: args.newTab, group_title: args.group_title });
+      return { url: r.url || args.url, title: r.title || '', tabId: r.tabId };
+    }
+
+    case 'find_tab': {
+      const r = await bridge.findTab(args.url, { active: args.active });
+      return { url: r.url, tabId: r.tabId, borrowed: r.borrowed };
+    }
+
+    case 'snapshot': {
+      const r = await bridge.snapshot();
+      return { url: r.url, title: r.title, refCount: r.refCount, elements: r.elements };
+    }
+
+    case 'click': {
+      const r = await bridge.click(args.selector);
+      return { success: true, tag: r.tag, text: r.text };
+    }
+
+    case 'fill': {
+      const r = await bridge.fill(args.selector, args.value);
+      return { success: true, typed: r.typed, length: r.length };
+    }
+
+    case 'type': {
+      const r = await bridge.type(args.selector, args.text, { pressEnter: args.pressEnter });
+      return { success: true, typed: r.typed, length: r.length };
+    }
+
+    case 'submit_form': {
+      const r = await bridge.submitForm(args.selector);
+      return { success: true, submitted: r.submitted, action: r.action, method: r.method };
+    }
+
+    case 'evaluate': {
+      const r = await bridge.evaluate(args.code);
+      return { type: r.type, value: r.value };
+    }
+
+    case 'cdp': {
+      const r = await bridge.cdp(args.method, args.params);
+      return r;
+    }
+
+    case 'screenshot': {
+      const r = await bridge.screenshot({ format: args.format, quality: args.quality, selector: args.selector });
+      return {
+        format: r.format || args.format || 'png',
+        path: r.path,
+        sizeBytes: r.sizeBytes,
+        mimeType: r.mimeType || `image/${args.format || 'png'}`
+      };
+    }
+
+    case 'network': {
+      const r = await bridge.network(args.cmd, { filter: args.filter, requestId: args.requestId });
+      return r;
+    }
+
+    case 'upload': {
+      const r = await bridge.upload(args.selector, args.files);
+      return { success: true, fileCount: r.fileCount };
+    }
+
+    case 'save_as_pdf': {
+      const r = await bridge.saveAsPdf({
+        paper_format: args.paper_format,
+        landscape: args.landscape,
+        scale: args.scale,
+        print_background: args.print_background
+      });
+      return { path: r.path, sizeBytes: r.sizeBytes, mimeType: r.mimeType, pageTitle: r.pageTitle };
+    }
+
+    case 'list_tabs': {
+      const tabs = await bridge.listTabs();
+      return { tabs };
+    }
+
+    case 'close_tab': {
+      const r = await bridge.closeTab();
+      return { closed: true };
+    }
+
+    case 'close_session': {
+      const r = await bridge.closeSession();
+      return { closed: r.closed };
+    }
+
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+/**
+ * Get tool definitions in MCP format (inputSchema instead of parameters).
+ */
+function getMcpToolDefinitions() {
+  return TOOL_DEFINITIONS.map(t => ({
+    name: t.function.name,
+    description: t.function.description,
+    inputSchema: t.function.parameters
+  }));
+}
+
+module.exports = {
+  TOOL_DEFINITIONS,
+  executeTool,
+  getMcpToolDefinitions,
+  SCREENSHOT_DIR
+};

package/src/uninstall.js

@@ -0,0 +1,246 @@
+/**
+ * VenomBrowser Uninstall — Fully reverse everything install/setup/connect did
+ *
+ * 1. Stop daemon (by port, not by matching all node.exe)
+ * 2. Remove "venombrowser" entries from agent configs (jsonc-parser, safe)
+ * 3. Leave everything else untouched
+ * 4. Optionally purge user data (screenshots/)
+ * 5. Print npm uninstall instructions
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const jsonc = require('jsonc-parser');
+
+const PURGE_DATA_FLAG = '--purge-data';
+
+/**
+ * Stop the daemon process listening on the given port.
+ * Uses netstat to find the PID, then kills only that process.
+ */
+function stopDaemon(port) {
+  try {
+    if (process.platform === 'win32') {
+      const output = execSync(
+        `netstat -ano | findstr :${port} | findstr LISTENING`,
+        { encoding: 'utf8', timeout: 5000 }
+      );
+      const lines = output.trim().split('\n').filter(Boolean);
+      const pids = new Set();
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        const pid = parts[parts.length - 1];
+        if (pid && pid !== '0') pids.add(pid);
+      }
+      for (const pid of pids) {
+        try {
+          execSync(`taskkill /F /PID ${pid}`, { encoding: 'utf8', timeout: 5000 });
+          console.log(`   ✅ Stopped daemon (PID ${pid}) on port ${port}`);
+        } catch {
+          console.log(`   ⚠️  Could not stop PID ${pid} (may have already exited)`);
+        }
+      }
+      if (pids.size === 0) {
+        console.log(`   ℹ️  No daemon found on port ${port}`);
+      }
+    } else {
+      // Unix: lsof or fuser
+      try {
+        const output = execSync(`lsof -ti :${port}`, { encoding: 'utf8', timeout: 5000 });
+        const pids = output.trim().split('\n').filter(Boolean);
+        for (const pid of pids) {
+          try {
+            execSync(`kill -9 ${pid}`, { encoding: 'utf8', timeout: 5000 });
+            console.log(`   ✅ Stopped daemon (PID ${pid}) on port ${port}`);
+          } catch {
+            console.log(`   ⚠️  Could not stop PID ${pid}`);
+          }
+        }
+        if (pids.length === 0) {
+          console.log(`   ℹ️  No daemon found on port ${port}`);
+        }
+      } catch {
+        console.log(`   ℹ️  No daemon found on port ${port}`);
+      }
+    }
+  } catch {
+    console.log(`   ℹ️  No daemon found on port ${port}`);
+  }
+}
+
+/**
+ * Remove "venombrowser" key from the "mcpServers" object in a Claude Desktop / Cursor config.
+ * Uses jsonc.modify to preserve comments and formatting.
+ * Returns { removed: boolean, path: string }
+ */
+function removeFromMcpServersConfig(filePath) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return { removed: false, path: filePath, reason: 'not found' };
+  }
+
+  let config;
+  try {
+    config = jsonc.parse(content);
+  } catch {
+    return { removed: false, path: filePath, reason: 'invalid JSON' };
+  }
+
+  if (!config.mcpServers || !config.mcpServers['venombrowser']) {
+    return { removed: false, path: filePath, reason: 'entry not present' };
+  }
+
+  const edits = jsonc.modify(content, ['mcpServers', 'venombrowser'], undefined, {
+    formattingOptions: { insertSpaces: true, tabSize: 2 }
+  });
+  const updated = jsonc.applyEdits(content, edits);
+  fs.writeFileSync(filePath, updated, 'utf8');
+  return { removed: true, path: filePath };
+}
+
+/**
+ * Remove "venombrowser" key from the "mcp" object in an OpenCode config.
+ * Uses jsonc.modify to preserve comments and formatting.
+ * Returns { removed: boolean, path: string }
+ */
+function removeFromOpenCodeConfig(filePath) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return { removed: false, path: filePath, reason: 'not found' };
+  }
+
+  let config;
+  try {
+    config = jsonc.parse(content);
+  } catch {
+    return { removed: false, path: filePath, reason: 'invalid JSON' };
+  }
+
+  if (!config.mcp || !config.mcp['venombrowser']) {
+    return { removed: false, path: filePath, reason: 'entry not present' };
+  }
+
+  const edits = jsonc.modify(content, ['mcp', 'venombrowser'], undefined, {
+    formattingOptions: { insertSpaces: true, tabSize: 2 }
+  });
+  const updated = jsonc.applyEdits(content, edits);
+  fs.writeFileSync(filePath, updated, 'utf8');
+  return { removed: true, path: filePath };
+}
+
+/**
+ * Main uninstall routine.
+ * @param {string[]} args - CLI arguments (may include --purge-data)
+ */
+function uninstall(args = []) {
+  const purgeData = args.includes(PURGE_DATA_FLAG);
+  const home = os.homedir();
+  const port = parseInt(process.env.BRIDGE_PORT || '10086', 10);
+
+  console.log('🧹 VenomBrowser Uninstall');
+  console.log('═'.repeat(55));
+  console.log();
+
+  // ── Step 1: Stop daemon ──────────────────────────────────────────────
+  console.log('Step 1: Stopping daemon...');
+  stopDaemon(port);
+  console.log();
+
+  // ── Step 2: Remove agent config entries ──────────────────────────────
+  console.log('Step 2: Removing MCP entries from agent configs...');
+  const homeDir = os.homedir();
+  const agentConfigs = [];
+
+  // Claude Desktop
+  if (process.platform === 'win32') {
+    const appdata = process.env.APPDATA || path.join(homeDir, 'AppData', 'Roaming');
+    agentConfigs.push({
+      name: 'Claude Desktop',
+      path: path.join(appdata, 'Claude', 'claude_desktop_config.json'),
+      type: 'mcpServers'
+    });
+  } else {
+    agentConfigs.push({
+      name: 'Claude Desktop',
+      path: path.join(homeDir, '.config', 'claude', 'claude_desktop_config.json'),
+      type: 'mcpServers'
+    });
+  }
+
+  // Cursor
+  agentConfigs.push({
+    name: 'Cursor',
+    path: path.join(homeDir, '.cursor', 'mcp.json'),
+    type: 'mcpServers'
+  });
+
+  // OpenCode
+  agentConfigs.push({
+    name: 'OpenCode',
+    path: path.join(homeDir, '.config', 'opencode', 'opencode.jsonc'),
+    type: 'mcp'
+  });
+
+  let anyRemoved = false;
+  for (const { name, path: configPath, type } of agentConfigs) {
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+
+    const result = type === 'mcp'
+      ? removeFromOpenCodeConfig(configPath)
+      : removeFromMcpServersConfig(configPath);
+
+    if (result.removed) {
+      console.log(`   ✅ Removed venombrowser from ${name} config (${configPath})`);
+      anyRemoved = true;
+    } else if (result.reason === 'entry not present') {
+      // silently skip — we didn't touch this file
+    } else {
+      console.log(`   ⚠️  ${name}: ${result.reason}`);
+    }
+  }
+
+  if (!anyRemoved) {
+    console.log('   ℹ️  No venombrowser entries found in any agent config');
+  }
+  console.log();
+
+  // ── Step 3: Purge user data (optional) ──────────────────────────────
+  const screenshotsDir = path.join(__dirname, '..', '..', 'screenshots');
+  if (purgeData) {
+    console.log('Step 3: Purging user data...');
+    if (fs.existsSync(screenshotsDir)) {
+      const count = fs.readdirSync(screenshotsDir).length;
+      fs.rmSync(screenshotsDir, { recursive: true, force: true });
+      console.log(`   ✅ Deleted screenshots/ (${count} files)`);
+    } else {
+      console.log('   ℹ️  No screenshots/ folder found');
+    }
+  } else {
+    console.log('Step 3: User data preserved (screenshots/ kept)');
+    if (fs.existsSync(screenshotsDir)) {
+      console.log(`   📁 ${screenshotsDir}`);
+    }
+    console.log('   To delete screenshots too, re-run: venombrowser uninstall --purge-data');
+  }
+  console.log();
+
+  // ── Step 4: npm uninstall instructions ──────────────────────────────
+  console.log('Step 4: Remove the global npm package:');
+  console.log('═'.repeat(55));
+  console.log('   Run this command to complete the uninstall:');
+  console.log();
+  console.log('     npm uninstall -g venombrowser');
+  console.log();
+  console.log('   After that, "venombrowser" will no longer be on your PATH.');
+  console.log('═'.repeat(55));
+}
+
+module.exports = { uninstall };