brave-real-browser-mcp-server 2.14.2 → 2.14.4

package/dist/index.js

@@ -1,22 +1,34 @@
 #!/usr/bin/env node
+// Debug logging setup - Log process start
+console.error(`🔍 [DEBUG] Process starting - PID: ${process.pid}, Node: ${process.version}, Platform: ${process.platform}`);
+console.error(`🔍 [DEBUG] Working directory: ${process.cwd()}`);
+console.error(`🔍 [DEBUG] Command args: ${process.argv.join(" ")}`);
 // Universal AI IDE Adapter - Auto-detect and support all AI IDEs
+console.error("🔍 [DEBUG] Loading Universal IDE Adapter...");
 import { UniversalIDEAdapter, } from "./universal-ide-adapter.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+console.error("🔍 [DEBUG] MCP SDK imports completed successfully");
 // Import extracted modules
+console.error("🔍 [DEBUG] Loading tool definitions...");
 import { TOOLS, SERVER_INFO, CAPABILITIES, TOOL_NAMES, } from "./tool-definitions.js";
+console.error("🔍 [DEBUG] Universal IDE Adapter loaded successfully");
+console.error("🔍 [DEBUG] Loading system utils...");
 import { withErrorHandling } from "./system-utils.js";
 import { validateMCPResponse } from "./mcp-response-validator.js";
+console.error("🔍 [DEBUG] Loading browser manager...");
 import { closeBrowser, forceKillAllBraveProcesses } from "./browser-manager.js";
+console.error("🔍 [DEBUG] Loading core infrastructure...");
 import { setupProcessCleanup, } from "./core-infrastructure.js";
 // Initialize Universal IDE Adapter
 const universalAdapter = new UniversalIDEAdapter({
     enableAutoDetection: true,
     fallbackToHttp: true,
-    logDetectionDetails: false,
+    logDetectionDetails: true,
 });
 // Import handlers
+console.error("🔍 [DEBUG] Loading 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";
@@ -52,30 +64,54 @@ import { handleProgressTracker, handleErrorLogger, handleSuccessRateReporter, ha
 import { handleVideoLinkFinder, handleVideoDownloadPage, handleVideoDownloadButton, handleVideoPlayPushSource, handleVideoPlayButtonClick, handleUrlRedirectTraceEndpoints, handleNetworkRecordingFinder, handleNetworkRecordingExtractors, handleVideoLinksFinders, handleVideosSelectors, handleLinkProcessExtracts, handleVideoLinkFindersExtracts, handleVideoDownloadButtonFinders, } from "./handlers/advanced-video-media-handlers.js";
 // Import advanced extraction handlers (Ad-bypass & Obfuscation)
 import { handleAdvancedVideoExtraction, handleDeobfuscateJS, handleMultiLayerRedirectTrace, handleAdProtectionDetector, } from "./handlers/advanced-extraction-handlers.js";
+console.error("🔍 [DEBUG] All modules loaded successfully");
+console.error(`🔍 [DEBUG] Server info: ${JSON.stringify(SERVER_INFO)}`);
+console.error(`🔍 [DEBUG] Available tools: ${TOOLS.length} tools loaded`);
 // Initialize MCP server
+console.error("🔍 [DEBUG] Creating MCP server instance...");
 const server = new Server(SERVER_INFO, { capabilities: CAPABILITIES });
-// Register initialize handler
+console.error("🔍 [DEBUG] MCP server instance created successfully");
+// Register initialize handler (CRITICAL - missing handler can cause crash)
+console.error("🔍 [DEBUG] Registering initialize handler...");
 server.setRequestHandler(InitializeRequestSchema, async (request) => {
+    console.error(`🔍 [DEBUG] Initialize request received: ${JSON.stringify(request)}`);
+    // Use the client's protocol version to ensure compatibility
     const clientProtocolVersion = request.params.protocolVersion;
-    return {
-        protocolVersion: clientProtocolVersion,
+    console.error(`🔍 [DEBUG] Client protocol version: ${clientProtocolVersion}`);
+    const response = {
+        protocolVersion: clientProtocolVersion, // Match client version for compatibility
         capabilities: CAPABILITIES,
         serverInfo: SERVER_INFO,
     };
+    console.error(`🔍 [DEBUG] Sending initialize response: ${JSON.stringify(response)}`);
+    // Add a small delay to see if there are any immediate errors after response
+    setTimeout(() => {
+        console.error(`🔍 [DEBUG] 1 second after initialize response - server still alive`);
+    }, 1000);
+    setTimeout(() => {
+        console.error(`🔍 [DEBUG] 5 seconds after initialize response - server still alive`);
+    }, 5000);
+    return response;
 });
 // Register tool handlers
+console.error("🔍 [DEBUG] Registering tools handler...");
 server.setRequestHandler(ListToolsRequestSchema, async () => {
+    console.error("🔍 [DEBUG] Tools list requested");
     return { tools: TOOLS };
 });
-// Register resource handlers
+// Register resource handlers (placeholder)
+console.error("🔍 [DEBUG] Registering resources handler...");
 server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    console.error("🔍 [DEBUG] Resources list requested");
     return { resources: [] };
 });
-// Register prompt handlers
+// Register prompt handlers (placeholder)
+console.error("🔍 [DEBUG] Registering prompts handler...");
 server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    console.error("🔍 [DEBUG] Prompts list requested");
     return { prompts: [] };
 });
-// Tool execution function
+// Tool execution function - exported for use in transports
 export async function executeToolByName(name, args) {
     try {
         let result;
@@ -430,15 +466,19 @@ export async function executeToolByName(name, args) {
             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);
+        console.error(`Tool ${name} failed:`, errorMessage);
+        // 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: [
                 {
@@ -451,18 +491,25 @@ export async function executeToolByName(name, args) {
     }
 }
 // Main tool call handler
+console.error("🔍 [DEBUG] Registering tool call handler...");
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    console.error(`🔍 [DEBUG] Tool call received: ${name} with args: ${JSON.stringify(args)}`);
     return await executeToolByName(name, args);
 });
-// Main function
+// Main function - now using multi-protocol launcher
 import { main as launcherMain } from "./launcher.js";
 async function main() {
+    // 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();
@@ -470,32 +517,66 @@ async function main() {
         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");
     }
 }
-// Error handling
+// Enhanced error handling with debug info
+console.error("🔍 [DEBUG] Setting up error handlers...");
 process.on("uncaughtException", (error) => {
+    console.error(`🔍 [DEBUG] Uncaught exception at ${new Date().toISOString()}`);
     console.error("❌ Uncaught exception:", error);
+    console.error(`🔍 [DEBUG] Stack trace:`, error.stack);
     process.exit(1);
 });
-process.on("unhandledRejection", (reason) => {
+process.on("unhandledRejection", (reason, promise) => {
+    console.error(`🔍 [DEBUG] Unhandled rejection at ${new Date().toISOString()}`);
     console.error("❌ Unhandled rejection:", reason);
+    console.error(`🔍 [DEBUG] Promise:`, promise);
     process.exit(1);
 });
+// Process lifecycle debugging
+process.on("exit", (code) => {
+    console.error(`🔍 [DEBUG] Process exiting with code: ${code} at ${new Date().toISOString()}`);
+});
+process.on("beforeExit", (code) => {
+    console.error(`🔍 [DEBUG] Before exit event with code: ${code} at ${new Date().toISOString()}`);
+});
+process.on("SIGTERM", () => {
+    console.error(`🔍 [DEBUG] SIGTERM received at ${new Date().toISOString()}`);
+});
+process.on("SIGINT", () => {
+    console.error(`🔍 [DEBUG] SIGINT received at ${new Date().toISOString()}`);
+});
+console.error("🔍 [DEBUG] All error handlers registered");
 // Start the server
+console.error("🔍 [DEBUG] Checking if module is main...");
+console.error(`🔍 [DEBUG] import.meta.url: ${import.meta.url}`);
+console.error(`🔍 [DEBUG] process.argv[1]: ${process.argv[1]}`);
+console.error(`🔍 [DEBUG] process.argv[0]: ${process.argv[0]}`);
+// Enhanced main module detection for npx compatibility
 const isMain = import.meta.url === `file://${process.argv[1]}` ||
     process.argv[1].includes("brave-real-browser-mcp-server") ||
     process.argv[1].endsWith(".bin/brave-real-browser-mcp-server") ||
     process.argv.some((arg) => arg.includes("brave-real-browser-mcp-server"));
+console.error(`🔍 [DEBUG] Enhanced main detection result: ${isMain}`);
 if (isMain) {
+    console.error("🔍 [DEBUG] Module is main - starting server...");
     main().catch((error) => {
+        console.error(`🔍 [DEBUG] Main function failed at ${new Date().toISOString()}`);
         console.error("❌ Failed to start server:", error);
+        console.error(`🔍 [DEBUG] Error stack:`, error.stack);
         process.exit(1);
     });
 }
 else {
+    console.error("🔍 [DEBUG] Module is not main - not starting server");
+    console.error("🔍 [DEBUG] FORCE STARTING - This is likely an npx execution");
     main().catch((error) => {
+        console.error(`🔍 [DEBUG] Forced main function failed at ${new Date().toISOString()}`);
         console.error("❌ Failed to start server:", error);
+        console.error(`🔍 [DEBUG] Error stack:`, error.stack);
         process.exit(1);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.14.2",
+  "version": "2.14.4",
   "description": "Universal AI IDE MCP Server - Auto-detects and supports all AI IDEs (Claude Desktop, Cursor, Windsurf, Cline, Zed, VSCode, Qoder AI, etc.) with Brave browser automation",
   "type": "module",
   "main": "dist/index.js",
@@ -44,8 +44,8 @@
     "ajv": "^8.12.0",
     "axios": "^1.6.5",
     "brave-real-browser": "^1.5.105",
-    "brave-real-launcher": "^1.2.28",
-    "brave-real-puppeteer-core": "^24.33.0-patch.1",
+    "brave-real-launcher": "^1.2.19",
+    "brave-real-puppeteer-core": "^24.26.1",
     "cheerio": "^1.0.0-rc.12",
     "chrono-node": "^2.7.0",
     "compromise": "^14.13.0",
@@ -73,7 +73,7 @@
     "@types/xml2js": "^0.4.14",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
-    "rimraf": "^6.1.2",
+    "rimraf": "^6.0.1",
     "tsx": "latest",
     "typescript": "^5.5.3",
     "vitest": "^3.2.4"