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

package/dist/launcher.js

@@ -1,41 +1,72 @@
 #!/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';
+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";
+import { UniversalIDEAdapter, ProtocolType, } from "./universal-ide-adapter.js";
 export class MultiProtocolLauncher {
     config;
     httpTransport;
     lspTransport;
     mcpServer;
+    universalAdapter;
     constructor(config = {}) {
         this.config = {
-            mode: config.mode || 'mcp',
+            mode: config.mode || "auto",
             httpPort: config.httpPort || 3000,
-            httpHost: config.httpHost || '0.0.0.0',
+            httpHost: config.httpHost || "0.0.0.0",
             enableWebSocket: config.enableWebSocket !== false,
             enableCors: config.enableCors !== false,
+            enableAutoDetection: config.enableAutoDetection !== false,
         };
     }
     async start() {
-        console.error('🚀 Multi-Protocol Brave Browser Server Starting...');
+        console.error("🚀 Multi-Protocol Brave Browser Server Starting...");
         console.error(`📡 Mode: ${this.config.mode.toUpperCase()}`);
+        // Initialize Universal IDE Adapter if auto-detection is enabled
+        if (this.config.enableAutoDetection && this.config.mode === "auto") {
+            console.error("🔍 Initializing Universal IDE Adapter...");
+            this.universalAdapter = new UniversalIDEAdapter({
+                enableAutoDetection: true,
+                fallbackToHttp: true,
+                httpPort: this.config.httpPort,
+                logDetectionDetails: true,
+            });
+            const detectionResult = await this.universalAdapter.initialize();
+            // Override mode based on detection
+            if (detectionResult.protocol === ProtocolType.MCP ||
+                detectionResult.protocol === ProtocolType.STDIO) {
+                this.config.mode = "mcp";
+            }
+            else if (detectionResult.protocol === ProtocolType.LSP) {
+                this.config.mode = "lsp";
+            }
+            else if (detectionResult.protocol === ProtocolType.HTTP ||
+                detectionResult.protocol === ProtocolType.WEBSOCKET) {
+                this.config.mode = "http";
+            }
+            console.error(`✅ Auto-detected mode: ${this.config.mode.toUpperCase()}`);
+        }
         // Setup cleanup handlers
         setupProcessCleanup(async () => {
             await this.stop();
         });
         switch (this.config.mode) {
-            case 'mcp':
+            case "auto":
+                // Fallback to MCP if auto-detection didn't override
                 await this.startMcp();
                 break;
-            case 'http':
+            case "mcp":
+                await this.startMcp();
+                break;
+            case "http":
                 await this.startHttp();
                 break;
-            case 'lsp':
+            case "lsp":
                 await this.startLsp();
                 break;
-            case 'all':
+            case "all":
                 await this.startAll();
                 break;
             default:
@@ -43,30 +74,45 @@ export class MultiProtocolLauncher {
         }
     }
     async startMcp() {
-        console.error('🔵 [MCP] Starting MCP server...');
+        console.error("🔵 [MCP] Starting MCP server with STDIO transport...");
+        if (this.universalAdapter?.getDetectionResult()) {
+            const result = this.universalAdapter.getDetectionResult();
+            console.error(`🎯 [MCP] Optimized for: ${result.capabilities.name}`);
+        }
         // Import MCP server setup from index.ts
-        const { createMcpServer } = await import('./mcp-server.js');
+        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');
+        console.error("✅ [MCP] Server started successfully");
+        console.error("💡 [MCP] Compatible with: Claude Desktop, Cursor, Windsurf, Cline, Warp, Roo Coder");
     }
     async startHttp() {
-        console.error('🟢 [HTTP] Starting HTTP/WebSocket server...');
+        console.error("🟢 [HTTP] Starting HTTP/WebSocket server...");
+        if (this.universalAdapter?.getDetectionResult()) {
+            const result = this.universalAdapter.getDetectionResult();
+            console.error(`🎯 [HTTP] Optimized for: ${result.capabilities.name}`);
+        }
         this.httpTransport = new HttpTransport({
             port: this.config.httpPort,
             host: this.config.httpHost,
             enableWebSocket: this.config.enableWebSocket,
         });
         await this.httpTransport.start();
+        console.error("💡 [HTTP] Universal mode - works with ALL AI IDEs");
     }
     async startLsp() {
-        console.error('🟣 [LSP] Starting Language Server...');
+        console.error("🟣 [LSP] Starting Language Server Protocol...");
+        if (this.universalAdapter?.getDetectionResult()) {
+            const result = this.universalAdapter.getDetectionResult();
+            console.error(`🎯 [LSP] Optimized for: ${result.capabilities.name}`);
+        }
         this.lspTransport = new LspTransport();
         await this.lspTransport.start();
+        console.error("💡 [LSP] Compatible with: Zed Editor, VSCode, Neovim, Emacs, Sublime Text");
     }
     async startAll() {
-        console.error('🌈 Starting all protocols...');
+        console.error("🌈 Starting all protocols...");
         // Start HTTP in background
         if (!this.httpTransport) {
             this.httpTransport = new HttpTransport({
@@ -79,10 +125,10 @@ export class MultiProtocolLauncher {
         // 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');
+        console.error("💡 Use separate instances for MCP or LSP: --mode=mcp or --mode=lsp");
     }
     async stop() {
-        console.error('🛑 Stopping servers...');
+        console.error("🛑 Stopping servers...");
         await closeBrowser();
         await forceKillAllBraveProcesses();
         if (this.httpTransport) {
@@ -91,7 +137,7 @@ export class MultiProtocolLauncher {
         if (this.lspTransport) {
             await this.lspTransport.stop();
         }
-        console.error('✅ All servers stopped');
+        console.error("✅ All servers stopped");
     }
 }
 // Parse CLI arguments
@@ -100,50 +146,76 @@ export function parseArgs() {
     const config = {};
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
-        if (arg === '--mode' || arg === '-m') {
+        if (arg === "--mode" || arg === "-m") {
             const mode = args[++i];
-            if (['mcp', 'http', 'lsp', 'all'].includes(mode)) {
+            if (["auto", "mcp", "http", "lsp", "all"].includes(mode)) {
                 config.mode = mode;
             }
             else {
-                console.error(`❌ Invalid mode: ${mode}. Use: mcp, http, lsp, or all`);
+                console.error(`❌ Invalid mode: ${mode}. Use: auto, mcp, http, lsp, or all`);
                 process.exit(1);
             }
         }
-        else if (arg === '--port' || arg === '-p') {
+        else if (arg === "--port" || arg === "-p") {
             config.httpPort = parseInt(args[++i]);
         }
-        else if (arg === '--host' || arg === '-h') {
+        else if (arg === "--host" || arg === "-h") {
             config.httpHost = args[++i];
         }
-        else if (arg === '--no-websocket') {
+        else if (arg === "--no-websocket") {
             config.enableWebSocket = false;
         }
-        else if (arg === '--help') {
+        else if (arg === "--no-auto-detect") {
+            config.enableAutoDetection = false;
+        }
+        else if (arg === "--list-ides") {
+            UniversalIDEAdapter.printSupportedIDEs();
+            process.exit(0);
+        }
+        else if (arg === "--help") {
             console.log(`
-Brave Real Browser MCP Server - Multi-Protocol Support
+Brave Real Browser MCP Server - Universal AI IDE Support
 
 Usage: brave-real-browser-mcp-server [options]
 
 Options:
-  --mode, -m <mode>       Protocol mode: mcp, http, lsp, or all (default: mcp)
+  --mode, -m <mode>       Protocol mode: auto, mcp, http, lsp, or all (default: auto)
   --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
+  --no-auto-detect        Disable automatic IDE detection
+  --list-ides             Show list of all supported AI IDEs
   --help                  Show this help message
 
+Supported AI IDEs (with auto-detection):
+  ✓ Claude Desktop         ✓ Cursor AI              ✓ Windsurf
+  ✓ Cline (VSCode)         ✓ Roo Coder             ✓ Zed Editor
+  ✓ Continue.dev           ✓ Qoder AI              ✓ Warp Terminal
+  ✓ GitHub Copilot         ✓ Amazon CodeWhisperer  ✓ Tabnine
+  ✓ Cody (Sourcegraph)     ✓ Aider                 ✓ Pieces for Developers
+  ✓ VSCode (Generic)       ✓ Any LSP-compatible editor
+
 Examples:
-  # MCP mode (for Claude Desktop, Cursor, Warp)
+  # Auto mode (automatically detects your IDE and uses optimal protocol)
+  brave-real-browser-mcp-server --mode auto
+
+  # Or simply run without arguments (auto is default)
+  brave-real-browser-mcp-server
+
+  # MCP mode (for Claude Desktop, Cursor, Windsurf, Cline, Warp, Roo Coder)
   brave-real-browser-mcp-server --mode mcp
 
-  # HTTP/WebSocket mode (for any HTTP client)
+  # HTTP/WebSocket mode (universal - works with ALL IDEs)
   brave-real-browser-mcp-server --mode http --port 3000
 
-  # LSP mode (for Zed, VSCode, etc.)
+  # LSP mode (for Zed, VSCode, Neovim, Emacs, Sublime Text)
   brave-real-browser-mcp-server --mode lsp
 
   # All protocols (HTTP only, MCP/LSP need separate instances)
   brave-real-browser-mcp-server --mode all
+
+  # Show all supported IDEs
+  brave-real-browser-mcp-server --list-ides
       `);
             process.exit(0);
         }
@@ -158,7 +230,7 @@ export async function main() {
         await launcher.start();
     }
     catch (error) {
-        console.error('❌ Failed to start server:', error);
+        console.error("❌ Failed to start server:", error);
         process.exit(1);
     }
 }