brave-real-browser-mcp-server 2.21.0 → 2.21.2

package/dist/handlers/advanced-tools.js

@@ -49,23 +49,29 @@ export async function handleBreadcrumbNavigator(page, args) {
     return { success: true, breadcrumbs: breadcrumbTexts };
 }
 /**
- * Trace standard URL redirects
+ * Trace standard URL redirects - Uses response events to avoid interception crashes
  */
 export async function handleUrlRedirectTracer(page, args) {
     const maxRedirects = args.maxRedirects || 10;
-    const chain = [];
-    const redirectHandler = (request) => {
+    const chain = [args.url];
+    const TIMEOUT_MS = 30000; // 30 second timeout
+    // Use response events instead of request interception to avoid crashes
+    const responseHandler = (response) => {
         try {
-            // Check if request is already handled
-            if (request.isInterceptResolutionHandled && request.isInterceptResolutionHandled()) {
-                return;
-            }
-            if (request.isNavigationRequest()) {
-                chain.push(request.url());
+            const status = response.status();
+            const url = response.url();
+            // Track redirects (3xx status codes)
+            if (status >= 300 && status < 400 && chain.length < maxRedirects) {
+                const location = response.headers()['location'];
+                if (location) {
+                    chain.push(location);
+                }
             }
-            // Only continue if not already handled
-            if (!request.isInterceptResolutionHandled || !request.isInterceptResolutionHandled()) {
-                request.continue().catch(() => { });
+            // Also track successful navigations
+            if (status >= 200 && status < 300) {
+                if (!chain.includes(url)) {
+                    chain.push(url);
+                }
             }
         }
         catch (e) {
@@ -73,29 +79,56 @@ export async function handleUrlRedirectTracer(page, args) {
         }
     };
     try {
+        page.on('response', responseHandler);
+        // Navigate with timeout protection
+        const navigationPromise = page.goto(args.url, {
+            waitUntil: 'networkidle2',
+            timeout: TIMEOUT_MS
+        }).catch((err) => {
+            // Handle navigation errors gracefully
+            return { error: err.message };
+        });
+        const result = await Promise.race([
+            navigationPromise,
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Navigation timeout')), TIMEOUT_MS))
+        ]).catch((err) => ({ error: err.message }));
+        // Get final URL safely
+        let finalUrl = args.url;
         try {
-            await page.setRequestInterception(true);
+            finalUrl = page.url() || args.url;
+            if (!chain.includes(finalUrl)) {
+                chain.push(finalUrl);
+            }
         }
         catch (e) {
-            // Interception might already be enabled
+            // Use original URL if page.url() fails
         }
-        page.on('request', redirectHandler);
-        await page.goto(args.url, { waitUntil: 'networkidle2' });
-        chain.push(page.url());
+        const uniqueChain = [...new Set(chain)];
+        return {
+            chain: uniqueChain,
+            finalUrl,
+            totalRedirects: Math.max(0, uniqueChain.length - 1),
+            error: result?.error
+        };
+    }
+    catch (error) {
+        // Return partial results on error instead of crashing
+        const uniqueChain = [...new Set(chain)];
+        return {
+            chain: uniqueChain,
+            finalUrl: chain[chain.length - 1] || args.url,
+            totalRedirects: Math.max(0, uniqueChain.length - 1),
+            error: error instanceof Error ? error.message : String(error)
+        };
     }
     finally {
-        page.off('request', redirectHandler);
         try {
-            await page.setRequestInterception(false);
+            page.off('response', responseHandler);
+        }
+        catch (e) {
+            // Ignore cleanup errors
         }
-        catch (e) { }
     }
-    const uniqueChain = [...new Set(chain)];
-    return {
-        chain: uniqueChain,
-        finalUrl: page.url(),
-        totalRedirects: uniqueChain.length - 1,
-    };
 }
 /**
  * Trace complex/hidden redirects including JavaScript redirects
@@ -462,49 +495,72 @@ export async function handleProgressTracker(_page, args) {
 }
 /**
  * Deep analysis - Logs, Network, DOM, and Screenshot
+ * Uses response events instead of request interception to avoid crashes
  */
 export async function handleDeepAnalysis(page, args) {
     const consoleLogs = [];
     const networkRequests = [];
     const duration = args.duration || 5000;
-    // Collect console logs
-    if (args.includeConsole !== false) {
-        page.on('console', (msg) => {
+    // Console log handler
+    const consoleHandler = (msg) => {
+        try {
             consoleLogs.push(`[${msg.type()}] ${msg.text()}`);
-        });
-    }
+        }
+        catch (e) {
+            // Ignore
+        }
+    };
+    // Response handler - safer than request interception
+    const responseHandler = (response) => {
+        try {
+            networkRequests.push({
+                url: response.url(),
+                status: response.status(),
+                resourceType: response.request()?.resourceType?.() || 'unknown',
+            });
+        }
+        catch (e) {
+            // Ignore
+        }
+    };
     try {
-        // Collect network
+        // Collect console logs
+        if (args.includeConsole !== false) {
+            page.on('console', consoleHandler);
+        }
+        // Collect network using response events (safer than request interception)
         if (args.includeNetwork !== false) {
-            await page.setRequestInterception(true);
-            page.on('request', (req) => {
-                networkRequests.push({
-                    url: req.url(),
-                    method: req.method(),
-                    resourceType: req.resourceType(),
-                });
-                req.continue();
-            });
+            page.on('response', responseHandler);
         }
         // Wait for specified duration
         await new Promise((r) => setTimeout(r, duration));
         // Get DOM stats
         let domStats = {};
         if (args.includeDom !== false) {
-            domStats = await page.evaluate(() => ({
-                totalElements: document.querySelectorAll('*').length,
-                images: document.querySelectorAll('img').length,
-                links: document.querySelectorAll('a').length,
-                forms: document.querySelectorAll('form').length,
-                scripts: document.querySelectorAll('script').length,
-                iframes: document.querySelectorAll('iframe').length,
-            }));
+            try {
+                domStats = await page.evaluate(() => ({
+                    totalElements: document.querySelectorAll('*').length,
+                    images: document.querySelectorAll('img').length,
+                    links: document.querySelectorAll('a').length,
+                    forms: document.querySelectorAll('form').length,
+                    scripts: document.querySelectorAll('script').length,
+                    iframes: document.querySelectorAll('iframe').length,
+                }));
+            }
+            catch (e) {
+                domStats = { error: 'Failed to get DOM stats' };
+            }
         }
         // Take screenshot
         let screenshot;
         if (args.includeScreenshot) {
-            const buffer = await page.screenshot({ encoding: 'base64' });
-            screenshot = buffer;
+            try {
+                const buffer = await page.screenshot({ encoding: 'base64' });
+                screenshot = buffer;
+            }
+            catch (e) {
+                // Screenshot failed, continue without it
+            }
         }
         return {
             console: consoleLogs,
@@ -514,87 +570,78 @@ export async function handleDeepAnalysis(page, args) {
         };
     }
     finally {
-        if (args.includeNetwork !== false) {
-            try {
-                await page.setRequestInterception(false);
+        // Clean up event listeners
+        try {
+            if (args.includeConsole !== false) {
+                page.off('console', consoleHandler);
             }
-            catch (e) {
-                // Ignore
+            if (args.includeNetwork !== false) {
+                page.off('response', responseHandler);
             }
         }
+        catch (e) {
+            // Ignore cleanup errors
+        }
     }
 }
 /**
- * Record full network traffic
+ * Record full network traffic - Uses response events to avoid crashes
  */
 export async function handleNetworkRecorder(page, args) {
     const requests = [];
     const duration = args.duration || 10000;
     let totalSize = 0;
-    const requestHandler = (request) => {
+    // Response handler - safer than request interception
+    const responseHandler = (response) => {
         try {
-            // Check if request is already handled to prevent crash
-            if (request.isInterceptResolutionHandled && request.isInterceptResolutionHandled()) {
-                return;
-            }
-            const url = request.url();
+            const url = response.url();
             if (args.filterUrl && !url.includes(args.filterUrl)) {
-                if (!request.isInterceptResolutionHandled || !request.isInterceptResolutionHandled()) {
-                    request.continue().catch(() => { });
-                }
                 return;
             }
             const entry = {
                 url,
-                method: request.method(),
-                resourceType: request.resourceType(),
+                status: response.status(),
+                resourceType: response.request()?.resourceType?.() || 'unknown',
                 timestamp: Date.now(),
             };
             if (args.includeHeaders) {
-                entry.headers = request.headers();
-            }
-            if (args.includeBody) {
-                entry.postData = request.postData();
+                try {
+                    entry.headers = response.headers();
+                }
+                catch (e) {
+                    entry.headers = {};
+                }
             }
+            // Note: Response body requires async handling, skip for stability
             requests.push(entry);
-            // Only continue if not already handled
-            if (!request.isInterceptResolutionHandled || !request.isInterceptResolutionHandled()) {
-                request.continue().catch(() => { });
-            }
-        }
-        catch {
-            // Ignore all errors in handler to prevent crash
-        }
-    };
-    try {
-        try {
-            await page.setRequestInterception(true);
-        }
-        catch (e) {
-            // Interception might already be enabled
-        }
-        page.on('request', requestHandler);
-        page.on('response', (response) => {
+            // Track size from headers
             try {
                 const headers = response.headers();
                 const size = parseInt(headers['content-length'] || '0', 10);
                 totalSize += size;
             }
             catch {
-                // Ignore errors
+                // Ignore
             }
-        });
+        }
+        catch {
+            // Ignore all errors in handler to prevent crash
+        }
+    };
+    try {
+        page.on('response', responseHandler);
         await new Promise((r) => setTimeout(r, duration));
     }
     catch (e) {
         // Capture setup errors
     }
     finally {
-        page.off('request', requestHandler);
         try {
-            await page.setRequestInterception(false);
+            page.off('response', responseHandler);
+        }
+        catch (e) {
+            // Ignore cleanup errors
         }
-        catch (e) { }
     }
     return {
         requests: requests.slice(0, 500),
@@ -603,57 +650,55 @@ export async function handleNetworkRecorder(page, args) {
     };
 }
 /**
- * Discover hidden API endpoints
+ * Discover hidden API endpoints - Uses response events to avoid crashes
  */
 export async function handleApiFinder(page, args) {
     const apis = [];
     const patterns = args.patterns || ['/api/', '/v1/', '/v2/', '/graphql', '/rest/', '.json'];
-    const requestHandler = (request) => {
+    // Response handler - safer than request interception
+    const responseHandler = (response) => {
         try {
-            // Check if request is already handled
-            if (request.isInterceptResolutionHandled && request.isInterceptResolutionHandled()) {
+            const request = response.request();
+            if (!request)
                 return;
-            }
-            const url = request.url();
+            const url = response.url();
+            const resourceType = request.resourceType?.() || 'unknown';
             const isApi = patterns.some((p) => url.includes(p));
-            const isXhr = request.resourceType() === 'xhr' || request.resourceType() === 'fetch';
+            const isXhr = resourceType === 'xhr' || resourceType === 'fetch';
             if (isApi || (args.includeInternal !== false && isXhr)) {
                 apis.push({
                     url,
-                    method: request.method(),
-                    type: request.resourceType(),
+                    method: request.method?.() || 'GET',
+                    type: resourceType,
                 });
             }
-            // Only continue if not already handled
-            if (!request.isInterceptResolutionHandled || !request.isInterceptResolutionHandled()) {
-                request.continue().catch(() => { });
-            }
         }
         catch (e) {
             // Ignore errors in handler
         }
     };
     try {
-        await page.setRequestInterception(true);
-        page.on('request', requestHandler);
+        page.on('response', responseHandler);
         // Trigger some interactions to discover more APIs
-        await page.evaluate(() => {
-            window.scrollTo(0, document.body.scrollHeight / 2);
-        });
+        try {
+            await page.evaluate(() => {
+                window.scrollTo(0, document.body.scrollHeight / 2);
+            });
+        }
+        catch (e) {
+            // Ignore scroll errors
+        }
         await new Promise((r) => setTimeout(r, 3000));
     }
     catch (error) {
-        // Log error but prioritize returning what we found
-        console.error('Error in api_finder:', error);
+        // Capture errors but continue
     }
     finally {
-        page.off('request', requestHandler);
-        // Safely disable interception
         try {
-            await page.setRequestInterception(false);
+            page.off('response', responseHandler);
         }
         catch (e) {
-            // Ignore if already disabled or browser closed
+            // Ignore cleanup errors
         }
     }
     // Remove duplicates

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.21.0",
+  "version": "2.21.2",
   "description": "🦁 MCP server for Brave Real Browser - NPM Workspaces Monorepo with anti-detection features",
   "type": "module",
   "main": "dist/index.js",
@@ -41,7 +41,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",
     "@types/turndown": "latest",
-    "brave-real-browser": "^2.3.0",
+    "brave-real-browser": "^2.3.2",
     "turndown": "latest"
   },
   "peerDependencies": {