brave-real-browser-mcp-server 2.11.6 → 2.11.7

package/README.md

@@ -14,19 +14,28 @@ Provides AI assistants with powerful, detection-resistant browser automation cap
 3. [Features](#features)
 4. [Prerequisites](#prerequisites)
 5. [Installation](#installation)
-6. [Usage](#usage)
-   - [With Claude Desktop](#with-claude-desktop)
+6. [Multi-Protocol Support](#-multi-protocol-support)
+7. [Usage](#usage)
+   - [Quick Configuration Reference](#-quick-configuration-reference)
+   - [With Claude Desktop](#with-claude-desktop-mcp-protocol)
    - [With Claude Code CLI](#with-claude-code-cli)
    - [With Cursor IDE](#with-cursor-ide)
-   - [With Other AI Assistants](#with-other-ai-assistants)
-7. [Available Tools](#available-tools)
-8. [Advanced Features](#advanced-features)
-9. [Configuration](#configuration)
-10. [Troubleshooting](#troubleshooting)
-11. [Development](#development)
-12. [Testing](#testing)
-13. [Contributing](#contributing)
-14. [License](#license)
+   - [With Warp AI Terminal](#with-warp-ai-terminal)
+   - [With Windsurf IDE](#with-windsurf-ide-codeium)
+   - [With Continue.dev](#with-continuedev-vscode-extension)
+   - [With Cody AI](#with-cody-ai-sourcegraph)
+   - [With Zed Editor](#with-zed-editor-lsp-mode)
+   - [With VSCode](#with-vscode-via-lsp)
+   - [HTTP/WebSocket Mode](#httpwebsocket-mode-for-any-language)
+   - [Complete MCP IDE Compatibility Matrix](#-complete-mcp-ide-compatibility-matrix)
+8. [Available Tools](#available-tools)
+9. [Advanced Features](#advanced-features)
+10. [Configuration](#configuration)
+11. [Troubleshooting](#troubleshooting)
+12. [Development](#development)
+13. [Testing](#testing)
+14. [Contributing](#contributing)
+15. [License](#license)
 
 ## Quick Start for Beginners
 
@@ -193,9 +202,65 @@ npm run build
 npm run dev
 ```
 
+## 🚀 Multi-Protocol Support
+
+This server now supports **three protocols** for maximum compatibility:
+
+| Protocol | Best For | Setup Difficulty |
+|----------|----------|-----------------|
+| **MCP** | Claude Desktop, Cursor, Warp AI | Easy |
+| **HTTP/WebSocket** | Any programming language | Easy |
+| **LSP** | Zed, VSCode, Neovim | Medium |
+
+### Quick Protocol Selection
+
+```bash
+# MCP mode (default) - For Claude Desktop, Cursor, Warp
+npx brave-real-browser-mcp-server
+
+# HTTP mode - For REST API / Any language
+npx brave-real-browser-mcp-server --mode http --port 3000
+
+# LSP mode - For Zed AI IDE, VSCode, Neovim
+npx brave-real-browser-mcp-server --mode lsp
+```
+
+📖 **Complete Guide:** See [MULTI_PROTOCOL_GUIDE.md](./MULTI_PROTOCOL_GUIDE.md) for detailed setup instructions.
+
+---
+
 ## Usage
 
-### With Claude Desktop
+### 📝 Quick Configuration Reference
+
+| Your IDE/Tool | Jump To Section |
+|---------------|----------------|
+| Claude Desktop | [Configuration](#with-claude-desktop-mcp-protocol) |
+| Claude Code CLI | [Configuration](#with-claude-code-cli) |
+| Cursor IDE | [Configuration](#with-cursor-ide) |
+| Warp Terminal | [Configuration](#with-warp-ai-terminal) |
+| Windsurf IDE | [Configuration](#with-windsurf-ide-codeium) |
+| Continue.dev | [Configuration](#with-continuedev-vscode-extension) |
+| Cody AI | [Configuration](#with-cody-ai-sourcegraph) |
+| Zed Editor | [Configuration](#with-zed-editor-lsp-mode) |
+| VSCode | [Configuration](#with-vscode-via-lsp) |
+| Python/Node.js/Any Language | [Configuration](#httpwebsocket-mode-for-any-language) |
+
+**All platforms use the same simple pattern:**
+```json
+{
+  "mcpServers": {
+    "brave-real-browser": {
+      "command": "npx",
+      "args": ["brave-real-browser-mcp-server@latest"]
+    }
+  }
+}
+```
+
+---
+
+### With Claude Desktop (MCP Protocol)
 
 The configuration below uses `npx` to automatically download and run the latest version. No installation required!
 
@@ -436,22 +501,207 @@ If successful, you should see:
    - Check file is in correct directory
    - Restart Cursor IDE after changes
 
-### With Other AI Assistants
+### With Warp AI Terminal
 
-Start the server:
+Warp Terminal has native MCP support built-in.
 
-```bash
-brave-real-browser-mcp-server
+**Configuration Location:**
+- macOS: `~/.warp/mcp_config.json`
+- Linux: `~/.warp/mcp_config.json`
+- Windows: `%USERPROFILE%\.warp\mcp_config.json`
+
+**Configuration:**
+```json
+{
+  "mcpServers": {
+    "brave-real-browser": {
+      "command": "npx",
+      "args": ["brave-real-browser-mcp-server@latest"]
+    }
+  }
+}
+```
+
+**Testing:**
+1. Restart Warp Terminal
+2. Type: `/mcp` to see available servers
+3. Test: "Initialize browser and go to google.com"
+
+### With Windsurf IDE (Codeium)
+
+Windsurf IDE by Codeium supports MCP servers.
+
+**Configuration Location:**
+- Create `.windsurf/mcp.json` in your project
+- Or `~/.windsurf/mcp.json` for global configuration
+
+**Configuration:**
+```json
+{
+  "mcpServers": {
+    "brave-real-browser": {
+      "command": "npx",
+      "args": ["brave-real-browser-mcp-server@latest"],
+      "disabled": false
+    }
+  }
+}
+```
+
+### With Continue.dev (VSCode Extension)
+
+Continue.dev supports MCP through its VSCode/JetBrains extension.
+
+**Configuration Location:**
+- `~/.continue/config.json` (Global)
+- Or `.continue/config.json` in your project
+
+**Configuration:**
+```json
+{
+  "mcpServers": [
+    {
+      "name": "brave-real-browser",
+      "command": "npx",
+      "args": ["brave-real-browser-mcp-server@latest"]
+    }
+  ]
+}
 ```
 
-Or if installed from source:
+### With Cody AI (Sourcegraph)
 
+Cody AI in VS Code supports MCP servers.
+
+**Configuration Location:**
+- VS Code Settings: `settings.json`
+
+**Configuration:**
+```json
+{
+  "cody.mcp.servers": {
+    "brave-real-browser": {
+      "command": "npx",
+      "args": ["brave-real-browser-mcp-server@latest"]
+    }
+  }
+}
+```
+
+### With Zed Editor (LSP Mode)
+
+Zed uses LSP protocol instead of MCP.
+
+**Configuration Location:**
+- macOS/Linux: `~/.config/zed/settings.json`
+- Windows: `%APPDATA%\Zed\settings.json`
+
+**Configuration:**
+```json
+{
+  "lsp": {
+    "brave-browser-automation": {
+      "command": "npx",
+      "args": ["brave-real-browser-mcp-server@latest", "--mode", "lsp"],
+      "settings": {}
+    }
+  }
+}
+```
+
+### With VSCode (via LSP)
+
+VSCode can use LSP mode for browser automation.
+
+**Create:** `.vscode/settings.json` in your project
+
+**Configuration:**
+```json
+{
+  "brave-browser-automation.serverPath": "npx",
+  "brave-browser-automation.serverArgs": [
+    "brave-real-browser-mcp-server@latest",
+    "--mode",
+    "lsp"
+  ]
+}
+```
+
+### HTTP/WebSocket Mode (For Any Language)
+
+Use REST API mode for maximum compatibility with any programming language.
+
+**Start Server:**
 ```bash
-npm start
+npx brave-real-browser-mcp-server --mode http --port 3000
+```
+
+**Example - Python:**
+```python
+import requests
+
+base_url = "http://localhost:3000"
+
+# Initialize browser
+requests.post(f"{base_url}/browser/init", json={"headless": False})
+
+# Navigate
+requests.post(f"{base_url}/browser/navigate", json={"url": "https://google.com"})
+
+# Get content
+response = requests.post(f"{base_url}/browser/get-content", json={"type": "text"})
+print(response.json())
+```
+
+**Example - Node.js:**
+```javascript
+const axios = require('axios');
+
+const baseUrl = 'http://localhost:3000';
+
+// Initialize and automate
+await axios.post(`${baseUrl}/browser/init`, {headless: false});
+await axios.post(`${baseUrl}/browser/navigate`, {url: 'https://google.com'});
+const content = await axios.post(`${baseUrl}/browser/get-content`, {type: 'text'});
+console.log(content.data);
+```
+
+### With Other MCP-Compatible Tools
+
+For any other MCP-compatible IDE or tool, use the standard MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "brave-real-browser": {
+      "command": "npx",
+      "args": ["brave-real-browser-mcp-server@latest"]
+    }
+  }
+}
 ```
 
 The server communicates via stdin/stdout using the MCP protocol.
 
+---
+
+## 📊 Complete MCP IDE Compatibility Matrix
+
+| IDE/Tool | Protocol | Config File | Status |
+|----------|----------|-------------|--------|
+| **Claude Desktop** | MCP | `claude_desktop_config.json` | ✅ Fully Tested |
+| **Claude Code CLI** | MCP | `.mcp.json` | ✅ Fully Tested |
+| **Cursor IDE** | MCP | `.cursor/mcp.json` | ✅ Fully Tested |
+| **Warp Terminal** | MCP | `mcp_config.json` | ✅ Supported |
+| **Windsurf IDE** | MCP | `.windsurf/mcp.json` | ✅ Supported |
+| **Continue.dev** | MCP | `.continue/config.json` | ✅ Supported |
+| **Cody AI** | MCP | `settings.json` | ✅ Supported |
+| **Zed Editor** | LSP | `settings.json` | ✅ LSP Mode |
+| **VSCode** | LSP | `.vscode/settings.json` | ✅ LSP Mode |
+| **Any HTTP Client** | HTTP/WebSocket | REST API | ✅ Fully Supported |
+
+**Total Supported Platforms:** 10+
+
 ### Example Interactions
 
 #### Basic Web Browsing

package/dist/index.js

@@ -483,42 +483,30 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         };
     }
 });
-// Main function to start the server
+// Main function - now using multi-protocol launcher
+import { main as launcherMain } from './launcher.js';
 async function main() {
-    console.error('🔍 [DEBUG] Main function starting...');
-    // Setup process cleanup handlers
-    console.error('🔍 [DEBUG] Setting up process cleanup handlers...');
-    setupProcessCleanup(async () => {
-        console.error('🔍 [DEBUG] Process cleanup triggered');
-        await closeBrowser();
-        await forceKillAllBraveProcesses();
-    });
-    // Create and start the server transport
-    console.error('🔍 [DEBUG] Creating StdioServerTransport...');
-    const transport = new StdioServerTransport();
-    console.error('🔍 [DEBUG] StdioServerTransport created successfully');
-    await withErrorHandling(async () => {
-        console.error('🔍 [DEBUG] Attempting to connect server to transport...');
-        await server.connect(transport);
-        console.error('🔍 [DEBUG] Server connected to transport successfully');
-        console.error('🚀 Brave Real Browser MCP Server started successfully');
-        console.error('📋 Available tools:', TOOLS.map(t => t.name).join(', '));
-        console.error('🔧 Workflow validation: Active');
-        console.error('💡 Content priority mode: Enabled (use get_content for better reliability)');
-        console.error('🔍 [DEBUG] Server is now ready and waiting for requests...');
-        // Keep the process alive by maintaining the connection
-        console.error('🔍 [DEBUG] Maintaining process alive - server will wait for requests');
-        // Add a heartbeat to confirm the process is still running
-        const heartbeat = setInterval(() => {
-            console.error(`🔍 [DEBUG] Heartbeat - Server alive at ${new Date().toISOString()}`);
-        }, 30000); // Every 30 seconds
-        // Cleanup heartbeat on process exit
-        process.on('exit', () => {
-            console.error('🔍 [DEBUG] Process exiting - clearing heartbeat');
-            clearInterval(heartbeat);
+    // Check if user wants multi-protocol mode
+    const hasProtocolArg = process.argv.some(arg => arg === '--mode' || arg === '-m' || arg === '--http' || arg === '--lsp');
+    if (hasProtocolArg) {
+        // Use multi-protocol launcher
+        await launcherMain();
+    }
+    else {
+        // Default: MCP mode (backward compatibility)
+        console.error('🔍 [DEBUG] Starting in MCP mode (default)...');
+        console.error('💡 Tip: Use --mode http or --mode lsp for other protocols');
+        setupProcessCleanup(async () => {
+            await closeBrowser();
+            await forceKillAllBraveProcesses();
         });
-    }, 'Failed to start MCP server');
-    console.error('🔍 [DEBUG] Main function completed - server should be running');
+        const transport = new StdioServerTransport();
+        await withErrorHandling(async () => {
+            await server.connect(transport);
+            console.error('🚀 Brave Real Browser MCP Server started successfully');
+            console.error('📋 Available tools:', TOOLS.map(t => t.name).join(', '));
+        }, 'Failed to start MCP server');
+    }
 }
 // Enhanced error handling with debug info
 console.error('🔍 [DEBUG] Setting up error handlers...');

package/dist/launcher.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { HttpTransport } from './transports/http-transport.js';
+import { LspTransport } from './transports/lsp-transport.js';
+import { closeBrowser, forceKillAllBraveProcesses } from './browser-manager.js';
+import { setupProcessCleanup } from './core-infrastructure.js';
+export class MultiProtocolLauncher {
+    config;
+    httpTransport;
+    lspTransport;
+    mcpServer;
+    constructor(config = {}) {
+        this.config = {
+            mode: config.mode || 'mcp',
+            httpPort: config.httpPort || 3000,
+            httpHost: config.httpHost || '0.0.0.0',
+            enableWebSocket: config.enableWebSocket !== false,
+            enableCors: config.enableCors !== false,
+        };
+    }
+    async start() {
+        console.error('🚀 Multi-Protocol Brave Browser Server Starting...');
+        console.error(`📡 Mode: ${this.config.mode.toUpperCase()}`);
+        // Setup cleanup handlers
+        setupProcessCleanup(async () => {
+            await this.stop();
+        });
+        switch (this.config.mode) {
+            case 'mcp':
+                await this.startMcp();
+                break;
+            case 'http':
+                await this.startHttp();
+                break;
+            case 'lsp':
+                await this.startLsp();
+                break;
+            case 'all':
+                await this.startAll();
+                break;
+            default:
+                throw new Error(`Unknown mode: ${this.config.mode}`);
+        }
+    }
+    async startMcp() {
+        console.error('🔵 [MCP] Starting MCP server...');
+        // Import MCP server setup from index.ts
+        const { createMcpServer } = await import('./mcp-server.js');
+        this.mcpServer = await createMcpServer();
+        const transport = new StdioServerTransport();
+        await this.mcpServer.connect(transport);
+        console.error('✅ [MCP] Server started successfully');
+    }
+    async startHttp() {
+        console.error('🟢 [HTTP] Starting HTTP/WebSocket server...');
+        this.httpTransport = new HttpTransport({
+            port: this.config.httpPort,
+            host: this.config.httpHost,
+            enableWebSocket: this.config.enableWebSocket,
+        });
+        await this.httpTransport.start();
+    }
+    async startLsp() {
+        console.error('🟣 [LSP] Starting Language Server...');
+        this.lspTransport = new LspTransport();
+        await this.lspTransport.start();
+    }
+    async startAll() {
+        console.error('🌈 Starting all protocols...');
+        // Start HTTP in background
+        if (!this.httpTransport) {
+            this.httpTransport = new HttpTransport({
+                port: this.config.httpPort,
+                host: this.config.httpHost,
+                enableWebSocket: this.config.enableWebSocket,
+            });
+            await this.httpTransport.start();
+        }
+        // Note: LSP and MCP use stdio/IPC, so they can't run simultaneously
+        // In 'all' mode, we prioritize HTTP/WebSocket for universal access
+        console.error('⚠️  [Note] MCP and LSP use stdio, so only HTTP/WebSocket is active in "all" mode');
+        console.error('💡 Use separate instances for MCP or LSP: --mode=mcp or --mode=lsp');
+    }
+    async stop() {
+        console.error('🛑 Stopping servers...');
+        await closeBrowser();
+        await forceKillAllBraveProcesses();
+        if (this.httpTransport) {
+            await this.httpTransport.stop();
+        }
+        if (this.lspTransport) {
+            await this.lspTransport.stop();
+        }
+        console.error('✅ All servers stopped');
+    }
+}
+// Parse CLI arguments
+export function parseArgs() {
+    const args = process.argv.slice(2);
+    const config = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--mode' || arg === '-m') {
+            const mode = args[++i];
+            if (['mcp', 'http', 'lsp', 'all'].includes(mode)) {
+                config.mode = mode;
+            }
+            else {
+                console.error(`❌ Invalid mode: ${mode}. Use: mcp, http, lsp, or all`);
+                process.exit(1);
+            }
+        }
+        else if (arg === '--port' || arg === '-p') {
+            config.httpPort = parseInt(args[++i]);
+        }
+        else if (arg === '--host' || arg === '-h') {
+            config.httpHost = args[++i];
+        }
+        else if (arg === '--no-websocket') {
+            config.enableWebSocket = false;
+        }
+        else if (arg === '--help') {
+            console.log(`
+Brave Real Browser MCP Server - Multi-Protocol Support
+
+Usage: brave-real-browser-mcp-server [options]
+
+Options:
+  --mode, -m <mode>       Protocol mode: mcp, http, lsp, or all (default: mcp)
+  --port, -p <port>       HTTP server port (default: 3000)
+  --host, -h <host>       HTTP server host (default: 0.0.0.0)
+  --no-websocket          Disable WebSocket support in HTTP mode
+  --help                  Show this help message
+
+Examples:
+  # MCP mode (for Claude Desktop, Cursor, Warp)
+  brave-real-browser-mcp-server --mode mcp
+
+  # HTTP/WebSocket mode (for any HTTP client)
+  brave-real-browser-mcp-server --mode http --port 3000
+
+  # LSP mode (for Zed, VSCode, etc.)
+  brave-real-browser-mcp-server --mode lsp
+
+  # All protocols (HTTP only, MCP/LSP need separate instances)
+  brave-real-browser-mcp-server --mode all
+      `);
+            process.exit(0);
+        }
+    }
+    return config;
+}
+// Main entry point
+export async function main() {
+    const config = parseArgs();
+    const launcher = new MultiProtocolLauncher(config);
+    try {
+        await launcher.start();
+    }
+    catch (error) {
+        console.error('❌ Failed to start server:', error);
+        process.exit(1);
+    }
+}

package/dist/mcp-server.js

@@ -0,0 +1,141 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { TOOLS, SERVER_INFO, CAPABILITIES, TOOL_NAMES } from './tool-definitions.js';
+import { validateMCPResponse } from './mcp-response-validator.js';
+// Import handlers
+import { handleBrowserInit, handleBrowserClose } from './handlers/browser-handlers.js';
+import { handleNavigate, handleWait } from './handlers/navigation-handlers.js';
+import { handleClick, handleType, handleSolveCaptcha, handleRandomScroll } from './handlers/interaction-handlers.js';
+import { handleGetContent, handleFindSelector } from './handlers/content-handlers.js';
+import { handleSaveContentAsMarkdown } from './handlers/file-handlers.js';
+import { handleScrapeTable, handleExtractList, handleExtractJSON, handleScrapeMetaTags, handleExtractSchema } from './handlers/data-extraction-handlers.js';
+import { handleBatchElementScraper, handleNestedDataExtraction, handleAttributeHarvester, handleImageScraper, handleLinkHarvester, handleMediaExtractor, handlePDFLinkFinder } from './handlers/multi-element-handlers.js';
+export async function createMcpServer() {
+    const server = new Server(SERVER_INFO, { capabilities: CAPABILITIES });
+    // Register initialize handler
+    server.setRequestHandler(InitializeRequestSchema, async (request) => {
+        const clientProtocolVersion = request.params.protocolVersion;
+        return {
+            protocolVersion: clientProtocolVersion,
+            capabilities: CAPABILITIES,
+            serverInfo: SERVER_INFO,
+        };
+    });
+    // Register tool handlers
+    server.setRequestHandler(ListToolsRequestSchema, async () => {
+        return { tools: TOOLS };
+    });
+    // Register resource handlers (placeholder)
+    server.setRequestHandler(ListResourcesRequestSchema, async () => {
+        return { resources: [] };
+    });
+    // Register prompt handlers (placeholder)
+    server.setRequestHandler(ListPromptsRequestSchema, async () => {
+        return { prompts: [] };
+    });
+    // Main tool call handler
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            let result;
+            switch (name) {
+                case TOOL_NAMES.BROWSER_INIT:
+                    result = await handleBrowserInit(args || {});
+                    break;
+                case TOOL_NAMES.NAVIGATE:
+                    result = await handleNavigate(args);
+                    break;
+                case TOOL_NAMES.GET_CONTENT:
+                    result = await handleGetContent(args || {});
+                    break;
+                case TOOL_NAMES.CLICK:
+                    result = await handleClick(args);
+                    break;
+                case TOOL_NAMES.TYPE:
+                    result = await handleType(args);
+                    break;
+                case TOOL_NAMES.WAIT:
+                    result = await handleWait(args);
+                    break;
+                case TOOL_NAMES.BROWSER_CLOSE:
+                    result = await handleBrowserClose();
+                    break;
+                case TOOL_NAMES.SOLVE_CAPTCHA:
+                    result = await handleSolveCaptcha(args);
+                    break;
+                case TOOL_NAMES.RANDOM_SCROLL:
+                    result = await handleRandomScroll();
+                    break;
+                case TOOL_NAMES.FIND_SELECTOR:
+                    result = await handleFindSelector(args);
+                    break;
+                case TOOL_NAMES.SAVE_CONTENT_AS_MARKDOWN:
+                    result = await handleSaveContentAsMarkdown(args);
+                    break;
+                // Smart Data Extractors
+                case TOOL_NAMES.SCRAPE_TABLE:
+                    result = await handleScrapeTable(args || {});
+                    break;
+                case TOOL_NAMES.EXTRACT_LIST:
+                    result = await handleExtractList(args || {});
+                    break;
+                case TOOL_NAMES.EXTRACT_JSON:
+                    result = await handleExtractJSON(args || {});
+                    break;
+                case TOOL_NAMES.SCRAPE_META_TAGS:
+                    result = await handleScrapeMetaTags(args || {});
+                    break;
+                case TOOL_NAMES.EXTRACT_SCHEMA:
+                    result = await handleExtractSchema(args || {});
+                    break;
+                // Multi-Element Extractors
+                case TOOL_NAMES.BATCH_ELEMENT_SCRAPER:
+                    result = await handleBatchElementScraper(args);
+                    break;
+                case TOOL_NAMES.NESTED_DATA_EXTRACTION:
+                    result = await handleNestedDataExtraction(args);
+                    break;
+                case TOOL_NAMES.ATTRIBUTE_HARVESTER:
+                    result = await handleAttributeHarvester(args);
+                    break;
+                // Content Type Specific
+                case TOOL_NAMES.IMAGE_SCRAPER:
+                    result = await handleImageScraper(args || {});
+                    break;
+                case TOOL_NAMES.LINK_HARVESTER:
+                    result = await handleLinkHarvester(args || {});
+                    break;
+                case TOOL_NAMES.MEDIA_EXTRACTOR:
+                    result = await handleMediaExtractor(args || {});
+                    break;
+                case TOOL_NAMES.PDF_LINK_FINDER:
+                    result = await handlePDFLinkFinder(args || {});
+                    break;
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
+            }
+            // Validate MCP response format universally
+            return validateMCPResponse(result, name);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // For workflow validation errors, throw them so MCP SDK handles them properly
+            if (errorMessage.includes('cannot be executed in current state') ||
+                errorMessage.includes('Cannot search for selectors') ||
+                errorMessage.includes('Next Steps:')) {
+                throw error;
+            }
+            // For other errors, return formatted response
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Tool execution failed: ${errorMessage}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}

package/dist/transports/http-transport.js

@@ -0,0 +1,222 @@
+import express from 'express';
+import { createServer } from 'http';
+import { WebSocketServer } from 'ws';
+import { TOOLS, TOOL_NAMES } from '../tool-definitions.js';
+// Import all handlers
+import { handleBrowserInit, handleBrowserClose } from '../handlers/browser-handlers.js';
+import { handleNavigate, handleWait } from '../handlers/navigation-handlers.js';
+import { handleClick, handleType, handleSolveCaptcha, handleRandomScroll } from '../handlers/interaction-handlers.js';
+import { handleGetContent, handleFindSelector } from '../handlers/content-handlers.js';
+import { handleSaveContentAsMarkdown } from '../handlers/file-handlers.js';
+export class HttpTransport {
+    app;
+    server = null;
+    wss = null;
+    config;
+    constructor(config = {}) {
+        this.config = {
+            port: config.port || 3000,
+            host: config.host || '0.0.0.0',
+            enableWebSocket: config.enableWebSocket !== false,
+            corsOrigins: config.corsOrigins || ['*'],
+        };
+        this.app = express();
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    setupMiddleware() {
+        // Body parsing
+        this.app.use(express.json());
+        this.app.use(express.urlencoded({ extended: true }));
+        // CORS
+        this.app.use((req, res, next) => {
+            res.header('Access-Control-Allow-Origin', this.config.corsOrigins?.[0] || '*');
+            res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+            res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+            if (req.method === 'OPTIONS') {
+                return res.sendStatus(200);
+            }
+            next();
+        });
+        // Request logging
+        this.app.use((req, res, next) => {
+            console.error(`📡 [HTTP] ${req.method} ${req.path} - ${new Date().toISOString()}`);
+            next();
+        });
+    }
+    setupRoutes() {
+        // Health check
+        this.app.get('/health', (req, res) => {
+            res.json({ status: 'ok', timestamp: new Date().toISOString() });
+        });
+        // List all available tools
+        this.app.get('/tools', (req, res) => {
+            res.json({ tools: TOOLS });
+        });
+        // Execute tool - Generic endpoint
+        this.app.post('/tools/:toolName', async (req, res) => {
+            const { toolName } = req.params;
+            const args = req.body;
+            try {
+                const result = await this.executeTool(toolName, args);
+                res.json({ success: true, result });
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                res.status(500).json({ success: false, error: errorMessage });
+            }
+        });
+        // Browser automation endpoints
+        this.app.post('/browser/init', async (req, res) => {
+            try {
+                const result = await handleBrowserInit(req.body);
+                res.json({ success: true, result });
+            }
+            catch (error) {
+                res.status(500).json({ success: false, error: error.message });
+            }
+        });
+        this.app.post('/browser/navigate', async (req, res) => {
+            try {
+                const result = await handleNavigate(req.body);
+                res.json({ success: true, result });
+            }
+            catch (error) {
+                res.status(500).json({ success: false, error: error.message });
+            }
+        });
+        this.app.post('/browser/click', async (req, res) => {
+            try {
+                const result = await handleClick(req.body);
+                res.json({ success: true, result });
+            }
+            catch (error) {
+                res.status(500).json({ success: false, error: error.message });
+            }
+        });
+        this.app.post('/browser/type', async (req, res) => {
+            try {
+                const result = await handleType(req.body);
+                res.json({ success: true, result });
+            }
+            catch (error) {
+                res.status(500).json({ success: false, error: error.message });
+            }
+        });
+        this.app.post('/browser/get-content', async (req, res) => {
+            try {
+                const result = await handleGetContent(req.body);
+                res.json({ success: true, result });
+            }
+            catch (error) {
+                res.status(500).json({ success: false, error: error.message });
+            }
+        });
+        this.app.post('/browser/close', async (req, res) => {
+            try {
+                const result = await handleBrowserClose();
+                res.json({ success: true, result });
+            }
+            catch (error) {
+                res.status(500).json({ success: false, error: error.message });
+            }
+        });
+        // Error handling
+        this.app.use((err, req, res, next) => {
+            console.error('❌ [HTTP] Error:', err);
+            res.status(500).json({ success: false, error: err.message });
+        });
+    }
+    async executeTool(toolName, args) {
+        switch (toolName) {
+            case TOOL_NAMES.BROWSER_INIT:
+                return await handleBrowserInit(args || {});
+            case TOOL_NAMES.NAVIGATE:
+                return await handleNavigate(args);
+            case TOOL_NAMES.GET_CONTENT:
+                return await handleGetContent(args || {});
+            case TOOL_NAMES.CLICK:
+                return await handleClick(args);
+            case TOOL_NAMES.TYPE:
+                return await handleType(args);
+            case TOOL_NAMES.WAIT:
+                return await handleWait(args);
+            case TOOL_NAMES.BROWSER_CLOSE:
+                return await handleBrowserClose();
+            case TOOL_NAMES.SOLVE_CAPTCHA:
+                return await handleSolveCaptcha(args);
+            case TOOL_NAMES.RANDOM_SCROLL:
+                return await handleRandomScroll();
+            case TOOL_NAMES.FIND_SELECTOR:
+                return await handleFindSelector(args);
+            case TOOL_NAMES.SAVE_CONTENT_AS_MARKDOWN:
+                return await handleSaveContentAsMarkdown(args);
+            default:
+                throw new Error(`Unknown tool: ${toolName}`);
+        }
+    }
+    setupWebSocket() {
+        if (!this.server || !this.config.enableWebSocket)
+            return;
+        this.wss = new WebSocketServer({ server: this.server });
+        this.wss.on('connection', (ws) => {
+            console.error('🔌 [WebSocket] Client connected');
+            ws.on('message', async (message) => {
+                try {
+                    const data = JSON.parse(message.toString());
+                    const { id, tool, args } = data;
+                    const result = await this.executeTool(tool, args);
+                    ws.send(JSON.stringify({
+                        id,
+                        success: true,
+                        result,
+                    }));
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    ws.send(JSON.stringify({
+                        success: false,
+                        error: errorMessage,
+                    }));
+                }
+            });
+            ws.on('close', () => {
+                console.error('🔌 [WebSocket] Client disconnected');
+            });
+            ws.on('error', (error) => {
+                console.error('❌ [WebSocket] Error:', error);
+            });
+        });
+    }
+    async start() {
+        return new Promise((resolve) => {
+            this.server = createServer(this.app);
+            this.setupWebSocket();
+            this.server.listen(this.config.port, this.config.host, () => {
+                console.error(`✅ [HTTP] Server running on http://${this.config.host}:${this.config.port}`);
+                if (this.config.enableWebSocket) {
+                    console.error(`✅ [WebSocket] Server running on ws://${this.config.host}:${this.config.port}`);
+                }
+                resolve();
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve, reject) => {
+            if (this.wss) {
+                this.wss.close();
+            }
+            if (this.server) {
+                this.server.close((err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+}

package/dist/transports/lsp-transport.js

@@ -0,0 +1,165 @@
+import { createConnection, TextDocuments, ProposedFeatures, CompletionItemKind, TextDocumentSyncKind, } from 'vscode-languageserver/node.js';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { TOOLS, TOOL_NAMES } from '../tool-definitions.js';
+// Import all handlers
+import { handleBrowserInit, handleBrowserClose } from '../handlers/browser-handlers.js';
+import { handleNavigate, handleWait } from '../handlers/navigation-handlers.js';
+import { handleClick, handleType, handleSolveCaptcha, handleRandomScroll } from '../handlers/interaction-handlers.js';
+import { handleGetContent, handleFindSelector } from '../handlers/content-handlers.js';
+import { handleSaveContentAsMarkdown } from '../handlers/file-handlers.js';
+export class LspTransport {
+    connection;
+    documents;
+    hasWorkspaceFolderCapability = false;
+    constructor() {
+        // Create a connection for the server using Node's IPC as a transport
+        this.connection = createConnection(ProposedFeatures.all);
+        // Create a simple text document manager
+        this.documents = new TextDocuments(TextDocument);
+        this.setupHandlers();
+        // Make the text document manager listen on the connection
+        this.documents.listen(this.connection);
+    }
+    setupHandlers() {
+        // Initialize
+        this.connection.onInitialize((params) => {
+            const capabilities = params.capabilities;
+            this.hasWorkspaceFolderCapability = !!(capabilities.workspace && !!capabilities.workspace.workspaceFolders);
+            const result = {
+                capabilities: {
+                    textDocumentSync: TextDocumentSyncKind.Incremental,
+                    completionProvider: {
+                        resolveProvider: true,
+                        triggerCharacters: ['.', ':'],
+                    },
+                    executeCommandProvider: {
+                        commands: TOOLS.map(tool => `browser.${tool.name}`),
+                    },
+                    hoverProvider: true,
+                    definitionProvider: true,
+                },
+            };
+            if (this.hasWorkspaceFolderCapability) {
+                result.capabilities.workspace = {
+                    workspaceFolders: {
+                        supported: true,
+                    },
+                };
+            }
+            return result;
+        });
+        this.connection.onInitialized(() => {
+            console.error('✅ [LSP] Server initialized');
+            if (this.hasWorkspaceFolderCapability) {
+                this.connection.workspace.onDidChangeWorkspaceFolders((_event) => {
+                    console.error('[LSP] Workspace folder change event received');
+                });
+            }
+        });
+        // Completion
+        this.connection.onCompletion((_textDocumentPosition) => {
+            return TOOLS.map(tool => ({
+                label: tool.name,
+                kind: CompletionItemKind.Function,
+                data: tool.name,
+                detail: tool.description,
+                documentation: JSON.stringify(tool.inputSchema, null, 2),
+            }));
+        });
+        this.connection.onCompletionResolve((item) => {
+            return item;
+        });
+        // Execute command (actual browser automation)
+        this.connection.onExecuteCommand(async (params) => {
+            const commandName = params.command.replace('browser.', '');
+            const args = params.arguments?.[0] || {};
+            console.error(`[LSP] Executing command: ${commandName}`);
+            try {
+                const result = await this.executeTool(commandName, args);
+                this.connection.window.showInformationMessage(`✅ Command ${commandName} executed successfully`);
+                return result;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.connection.window.showErrorMessage(`❌ Command ${commandName} failed: ${errorMessage}`);
+                throw error;
+            }
+        });
+        // Hover information
+        this.connection.onHover((params) => {
+            const document = this.documents.get(params.textDocument.uri);
+            if (!document)
+                return null;
+            const position = params.position;
+            const word = this.getWordAtPosition(document, position);
+            const tool = TOOLS.find(t => t.name === word);
+            if (tool) {
+                return {
+                    contents: {
+                        kind: 'markdown',
+                        value: [
+                            `**${tool.name}**`,
+                            '',
+                            tool.description,
+                            '',
+                            '**Parameters:**',
+                            '```json',
+                            JSON.stringify(tool.inputSchema, null, 2),
+                            '```',
+                        ].join('\n'),
+                    },
+                };
+            }
+            return null;
+        });
+    }
+    getWordAtPosition(document, position) {
+        const text = document.getText();
+        const offset = document.offsetAt(position);
+        let start = offset;
+        let end = offset;
+        // Find word boundaries
+        while (start > 0 && /\w/.test(text[start - 1]))
+            start--;
+        while (end < text.length && /\w/.test(text[end]))
+            end++;
+        return text.substring(start, end);
+    }
+    async executeTool(toolName, args) {
+        switch (toolName) {
+            case TOOL_NAMES.BROWSER_INIT:
+                return await handleBrowserInit(args || {});
+            case TOOL_NAMES.NAVIGATE:
+                return await handleNavigate(args);
+            case TOOL_NAMES.GET_CONTENT:
+                return await handleGetContent(args || {});
+            case TOOL_NAMES.CLICK:
+                return await handleClick(args);
+            case TOOL_NAMES.TYPE:
+                return await handleType(args);
+            case TOOL_NAMES.WAIT:
+                return await handleWait(args);
+            case TOOL_NAMES.BROWSER_CLOSE:
+                return await handleBrowserClose();
+            case TOOL_NAMES.SOLVE_CAPTCHA:
+                return await handleSolveCaptcha(args);
+            case TOOL_NAMES.RANDOM_SCROLL:
+                return await handleRandomScroll();
+            case TOOL_NAMES.FIND_SELECTOR:
+                return await handleFindSelector(args);
+            case TOOL_NAMES.SAVE_CONTENT_AS_MARKDOWN:
+                return await handleSaveContentAsMarkdown(args);
+            default:
+                throw new Error(`Unknown tool: ${toolName}`);
+        }
+    }
+    async start() {
+        console.error('🔍 [LSP] Starting Language Server...');
+        this.connection.listen();
+        console.error('✅ [LSP] Language Server started and listening');
+    }
+    async stop() {
+        console.error('[LSP] Stopping server...');
+        this.connection.dispose();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.11.6",
+  "version": "2.11.7",
   "description": "MCP server for brave-real-browser",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,12 @@
     "build": "tsc",
     "rebuild": "npm run clean && npm run build",
     "start": "node dist/index.js",
+    "start:http": "node dist/index.js --mode http",
+    "start:lsp": "node dist/index.js --mode lsp",
+    "start:all": "node dist/index.js --mode all",
     "dev": "tsx src/index.ts",
+    "dev:http": "tsx src/index.ts --mode http",
+    "dev:lsp": "tsx src/index.ts --mode lsp",
     "test": "vitest",
     "test:watch": "vitest --watch",
     "test:ui": "vitest --ui",
@@ -37,11 +42,12 @@
     "axios": "^1.6.5",
     "brave-real-browser": "^1.5.102",
     "brave-real-launcher": "^1.2.17",
-    "brave-real-puppeteer-core": "^24.24.0",
+    "brave-real-puppeteer-core": "^24.25.0",
     "cheerio": "^1.0.0-rc.12",
     "chrono-node": "^2.7.0",
     "compromise": "^14.13.0",
     "dotenv": "^17.2.3",
+    "express": "^4.21.2",
     "franc": "^6.2.0",
     "libphonenumber-js": "^1.10.51",
     "natural": "^6.12.0",
@@ -51,11 +57,16 @@
     "sentiment": "^5.0.2",
     "tesseract.js": "^5.0.5",
     "turndown": "^7.2.1",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "ws": "^8.18.3",
     "xml2js": "^0.6.2"
   },
   "devDependencies": {
     "@types/cheerio": "^0.22.35",
+    "@types/express": "^4.17.23",
     "@types/node": "latest",
+    "@types/ws": "^8.18.1",
     "@types/xml2js": "^0.4.14",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
@@ -100,6 +111,6 @@
     "puppeteer": "npm:brave-real-puppeteer-core@latest",
     "puppeteer-core": "npm:brave-real-puppeteer-core@latest",
     "tar-fs": "^3.0.0",
-    "ws": "^8.18.0"
+    "ws": "^8.18.3"
   }
 }