brave-real-browser-mcp-server 2.9.21 → 2.11.0

package/dist/handlers/advanced-video-media-handlers.js

@@ -3,7 +3,7 @@
 // @ts-nocheck
 import { getCurrentPage } from '../browser-manager.js';
 import { validateWorkflow } from '../workflow-validation.js';
-import { withErrorHandling } from '../system-utils.js';
+import { withErrorHandling, sleep } from '../system-utils.js';
 /**
  * Video Link Finder - Find all video links on page
  */
@@ -184,7 +184,7 @@ export async function handleVideoDownloadButton(args) {
             const selector = customSelector || 'a[download], button[download]';
             try {
                 await page.click(selector);
-                await page.waitForTimeout(2000);
+                await sleep(2000);
                 return {
                     content: [{
                             type: 'text',
@@ -252,7 +252,7 @@ export async function handleVideoPlayPushSource(args) {
             }
         }
         // Wait for sources to load
-        await page.waitForTimeout(3000);
+        await sleep(3000);
         page.off('response', responseHandler);
         return {
             content: [{
@@ -370,84 +370,154 @@ export async function handleUrlRedirectTraceEndpoints(args) {
  * Network Recording Finder - Find and analyze network recordings
  */
 export async function handleNetworkRecordingFinder(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('network_recording_finder', {
+    try {
+        const validation = validateWorkflow('network_recording_finder', {
             requireBrowser: true,
             requirePage: true,
         });
+        if (!validation.isValid) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `⚠️ ${validation.errorMessage || 'Workflow validation failed'}`,
+                    }],
+                isError: true,
+            };
+        }
         const page = getCurrentPage();
         const duration = args.duration || 10000;
         const filterType = args.filterType || 'video'; // video, audio, media
+        const navigateTo = args.navigateTo; // Optional URL to navigate to
+        const verbose = args.verbose !== false; // Default true for detailed logging
         const recordings = [];
+        let totalResponses = 0;
+        let matchedResponses = 0;
         const responseHandler = async (response) => {
-            const url = response.url();
-            const contentType = response.headers()['content-type'] || '';
-            const resourceType = response.request().resourceType();
-            let shouldRecord = false;
-            if (filterType === 'video' && (contentType.includes('video') || resourceType === 'media')) {
-                shouldRecord = true;
-            }
-            else if (filterType === 'audio' && contentType.includes('audio')) {
-                shouldRecord = true;
-            }
-            else if (filterType === 'media' && (contentType.includes('video') || contentType.includes('audio'))) {
-                shouldRecord = true;
-            }
-            if (shouldRecord) {
-                try {
-                    const buffer = await response.buffer();
-                    recordings.push({
-                        url,
-                        contentType,
-                        size: buffer.length,
-                        status: response.status(),
-                        timestamp: new Date().toISOString(),
-                    });
+            try {
+                totalResponses++;
+                const url = response.url();
+                const contentType = response.headers()['content-type'] || '';
+                const resourceType = response.request().resourceType();
+                if (verbose && totalResponses % 10 === 0) {
+                    console.log(`[Network Recording] Processed ${totalResponses} responses, ${matchedResponses} matched`);
                 }
-                catch (e) {
-                    recordings.push({
-                        url,
-                        contentType,
-                        status: response.status(),
-                        error: 'Could not capture buffer',
-                    });
+                let shouldRecord = false;
+                if (filterType === 'video' && (contentType.includes('video') || resourceType === 'media')) {
+                    shouldRecord = true;
+                }
+                else if (filterType === 'audio' && contentType.includes('audio')) {
+                    shouldRecord = true;
+                }
+                else if (filterType === 'media' && (contentType.includes('video') || contentType.includes('audio'))) {
+                    shouldRecord = true;
+                }
+                if (shouldRecord) {
+                    matchedResponses++;
+                    if (verbose) {
+                        console.log(`[Network Recording] ✅ Matched ${filterType}: ${url.substring(0, 100)}`);
+                    }
+                    try {
+                        const buffer = await response.buffer();
+                        recordings.push({
+                            url,
+                            contentType,
+                            size: buffer.length,
+                            status: response.status(),
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                    catch (e) {
+                        recordings.push({
+                            url,
+                            contentType,
+                            status: response.status(),
+                            error: 'Could not capture buffer',
+                        });
+                    }
                 }
             }
+            catch (e) {
+                // Ignore individual response errors
+            }
         };
+        console.log(`[Network Recording] 🎬 Starting monitoring for ${filterType} (${duration}ms)${navigateTo ? ` + navigating to ${navigateTo}` : ''}`);
         page.on('response', responseHandler);
-        await page.waitForTimeout(duration);
+        // If navigateTo is provided, navigate first, then wait
+        if (navigateTo) {
+            try {
+                await page.goto(navigateTo, { waitUntil: 'networkidle2', timeout: 30000 });
+                console.log(`[Network Recording] ✅ Navigation complete, continuing monitoring...`);
+            }
+            catch (e) {
+                console.log(`[Network Recording] ⚠️ Navigation error (continuing anyway): ${e}`);
+            }
+        }
+        await sleep(duration);
         page.off('response', responseHandler);
+        console.log(`[Network Recording] 🛑 Monitoring stopped. Total: ${totalResponses}, Matched: ${matchedResponses}, Recorded: ${recordings.length}`);
+        if (recordings.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `ℹ️ No ${filterType} recordings found\n\n📊 Statistics:\n  • Total responses checked: ${totalResponses}\n  • Matched ${filterType} responses: ${matchedResponses}\n  • Duration: ${duration}ms\n  • Navigation: ${navigateTo || 'None'}\n\n💡 Suggestions:\n  ${navigateTo ? '• Try longer duration if page loads slowly\n  • Check if page actually has video/media content' : '• Use navigateTo parameter to capture requests during page load\n  • Example: {"navigateTo": "https://example.com", "duration": 15000}'}\n  • Consider 'advanced_video_extraction' for analyzing loaded content`,
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ Network Recordings Found: ${recordings.length}\n\n📊 Statistics:\n  • Total responses: ${totalResponses}\n  • Matched: ${matchedResponses}\n  • Recorded: ${recordings.length}\n\n${JSON.stringify(recordings, null, 2)}`,
+                }],
+        };
+    }
+    catch (error) {
         return {
             content: [{
                     type: 'text',
-                    text: `✅ Network Recordings Found: ${recordings.length}\n\n${JSON.stringify(recordings, null, 2)}`,
+                    text: `❌ Network recording finder failed: ${error instanceof Error ? error.message : String(error)}`,
                 }],
+            isError: true,
         };
-    }, 'Failed to find network recordings');
+    }
 }
 /**
  * Network Recording Extractors - Extract data from network recordings
  */
 export async function handleNetworkRecordingExtractors(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('network_recording_extractors', {
+    try {
+        const validation = validateWorkflow('network_recording_extractors', {
             requireBrowser: true,
             requirePage: true,
         });
+        if (!validation.isValid) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `⚠️ ${validation.errorMessage || 'Workflow validation failed'}`,
+                    }],
+                isError: true,
+            };
+        }
         const page = getCurrentPage();
         const duration = args.duration || 10000;
+        const navigateTo = args.navigateTo; // Optional URL to navigate to
+        const verbose = args.verbose !== false; // Default true
         const extractedData = {
             videos: [],
             audio: [],
             manifests: [],
             apis: [],
         };
+        let totalResponses = 0;
         const responseHandler = async (response) => {
+            totalResponses++;
             const url = response.url();
             const contentType = response.headers()['content-type'] || '';
             try {
                 // Video files
                 if (contentType.includes('video') || url.includes('.mp4') || url.includes('.webm')) {
+                    if (verbose)
+                        console.log(`[Extractor] 🎥 Video found: ${url.substring(0, 80)}`);
                     extractedData.videos.push({
                         url,
                         contentType,
@@ -456,6 +526,8 @@ export async function handleNetworkRecordingExtractors(args) {
                 }
                 // Audio files
                 if (contentType.includes('audio') || url.includes('.mp3') || url.includes('.m4a')) {
+                    if (verbose)
+                        console.log(`[Extractor] 🎵 Audio found: ${url.substring(0, 80)}`);
                     extractedData.audio.push({
                         url,
                         contentType,
@@ -463,6 +535,8 @@ export async function handleNetworkRecordingExtractors(args) {
                 }
                 // Manifest files (HLS, DASH)
                 if (url.includes('.m3u8') || url.includes('.mpd')) {
+                    if (verbose)
+                        console.log(`[Extractor] 📜 Manifest found: ${url.substring(0, 80)}`);
                     const text = await response.text();
                     extractedData.manifests.push({
                         url,
@@ -472,6 +546,8 @@ export async function handleNetworkRecordingExtractors(args) {
                 }
                 // API responses with video data
                 if (contentType.includes('json') && (url.includes('video') || url.includes('media'))) {
+                    if (verbose)
+                        console.log(`[Extractor] 📡 API found: ${url.substring(0, 80)}`);
                     const json = await response.json();
                     extractedData.apis.push({
                         url,
@@ -483,16 +559,47 @@ export async function handleNetworkRecordingExtractors(args) {
                 // Response not available
             }
         };
+        console.log(`[Extractor] 🎬 Starting extraction (${duration}ms)${navigateTo ? ` + navigating to ${navigateTo}` : ''}`);
         page.on('response', responseHandler);
-        await page.waitForTimeout(duration);
+        // If navigateTo is provided, navigate first, then wait
+        if (navigateTo) {
+            try {
+                await page.goto(navigateTo, { waitUntil: 'networkidle2', timeout: 30000 });
+                console.log(`[Extractor] ✅ Navigation complete, continuing extraction...`);
+            }
+            catch (e) {
+                console.log(`[Extractor] ⚠️ Navigation error (continuing): ${e}`);
+            }
+        }
+        await sleep(duration);
         page.off('response', responseHandler);
+        const totalFound = extractedData.videos.length + extractedData.audio.length +
+            extractedData.manifests.length + extractedData.apis.length;
+        console.log(`[Extractor] 🛑 Extraction complete. Total responses: ${totalResponses}, Extracted: ${totalFound}`);
+        if (totalFound === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `ℹ️ No media content extracted\n\n📊 Statistics:\n  • Total responses checked: ${totalResponses}\n  • Duration: ${duration}ms\n  • Navigation: ${navigateTo || 'None'}\n\n💡 Suggestions:\n  ${navigateTo ? '• Try longer duration (15000-20000ms)\n  • Verify page actually contains video/media' : '• Add navigateTo parameter: {"navigateTo": "https://example.com", "duration": 15000}'}\n  • Use 'advanced_video_extraction' for analyzing loaded content\n  • Check browser console logs for detailed monitoring`,
+                    }],
+            };
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: `✅ Network Recording Extraction Complete\n\n📊 Results:\n  • Videos: ${extractedData.videos.length}\n  • Audio: ${extractedData.audio.length}\n  • Manifests: ${extractedData.manifests.length}\n  • APIs: ${extractedData.apis.length}\n  • Total responses: ${totalResponses}\n\n${JSON.stringify(extractedData, null, 2)}`,
+                }],
+        };
+    }
+    catch (error) {
         return {
             content: [{
                     type: 'text',
-                    text: `✅ Network Recording Extraction Complete\n\nVideos: ${extractedData.videos.length}\nAudio: ${extractedData.audio.length}\nManifests: ${extractedData.manifests.length}\nAPIs: ${extractedData.apis.length}\n\n${JSON.stringify(extractedData, null, 2)}`,
+                    text: `❌ Network recording extraction failed: ${error instanceof Error ? error.message : String(error)}`,
                 }],
+            isError: true,
         };
-    }, 'Failed to extract network recordings');
+    }
 }
 /**
  * Video Links Finders - Advanced video link detection

package/dist/handlers/api-integration-handlers.js

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import { getPageInstance } from '../browser-manager.js';
 import axios from 'axios';
+import { sleep } from '../system-utils.js';
 /**
  * REST API Endpoint Finder - Discover REST API endpoints
  */
@@ -46,7 +47,7 @@ export async function handleRESTAPIEndpointFinder(args) {
                 await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
             }
             // Wait for additional requests
-            await page.waitForTimeout(scanDuration);
+            await sleep(scanDuration);
             page.off('request', requestHandler);
         }
         // Also scan page content for API endpoints

package/dist/handlers/captcha-handlers.js

@@ -1,6 +1,7 @@
 // @ts-nocheck
 import { getPageInstance } from '../browser-manager.js';
 import Tesseract from 'tesseract.js';
+import { sleep } from '../system-utils.js';
 /**
  * OCR Engine - Extract text from captcha images using OCR
  */
@@ -207,7 +208,7 @@ export async function handlePuzzleCaptchaHandler(args) {
                         const stepSize = targetDistance / steps;
                         for (let i = 0; i < steps; i++) {
                             await page.mouse.move(box.x + box.width / 2 + (stepSize * i), box.y + box.height / 2, { steps: 5 });
-                            await page.waitForTimeout(50 + Math.random() * 50); // Random delay for human-like behavior
+                            await sleep(50 + Math.random() * 50); // Random delay for human-like behavior
                         }
                         await page.mouse.up();
                         result.attemptedSolve = true;

package/dist/handlers/dynamic-session-handlers.js

@@ -3,7 +3,7 @@
 // @ts-nocheck
 import { getCurrentPage } from '../browser-manager.js';
 import { validateWorkflow } from '../workflow-validation.js';
-import { withErrorHandling } from '../system-utils.js';
+import { withErrorHandling, sleep } from '../system-utils.js';
 /**
  * Shadow DOM Extractor - Extract content from Shadow DOM
  */
@@ -291,11 +291,20 @@ export async function handleFormAutoFill(args) {
  * AJAX Content Waiter - Wait for dynamic content to load
  */
 export async function handleAjaxContentWaiter(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('ajax_content_waiter', {
+    try {
+        const validation = validateWorkflow('ajax_content_waiter', {
             requireBrowser: true,
             requirePage: true,
         });
+        if (!validation.isValid) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `⚠️ ${validation.errorMessage || 'Workflow validation failed'}`,
+                    }],
+                isError: true,
+            };
+        }
         const page = getCurrentPage();
         const waitFor = args.waitFor || 'selector'; // selector, xhr, timeout
         const value = args.value;
@@ -320,7 +329,7 @@ export async function handleAjaxContentWaiter(args) {
             }
         }
         if (waitFor === 'xhr') {
-            const duration = value || 5000;
+            const duration = parseInt(value) || 5000;
             let xhrCount = 0;
             const requestHandler = (request) => {
                 if (request.resourceType() === 'xhr' || request.resourceType() === 'fetch') {
@@ -328,8 +337,16 @@ export async function handleAjaxContentWaiter(args) {
                 }
             };
             page.on('request', requestHandler);
-            await page.waitForTimeout(duration);
+            await sleep(duration);
             page.off('request', requestHandler);
+            if (xhrCount === 0) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `ℹ️ Waited ${duration}ms - No XHR/Fetch requests detected.\n\n💡 Note: Monitoring captures NEW requests made during wait period. Page already loaded before monitoring started.`,
+                        }],
+                };
+            }
             return {
                 content: [{
                         type: 'text',
@@ -338,8 +355,8 @@ export async function handleAjaxContentWaiter(args) {
             };
         }
         if (waitFor === 'timeout') {
-            const duration = value || 3000;
-            await page.waitForTimeout(duration);
+            const duration = parseInt(value) || 3000;
+            await sleep(duration);
             return {
                 content: [{
                         type: 'text',
@@ -347,8 +364,23 @@ export async function handleAjaxContentWaiter(args) {
                     }],
             };
         }
-        throw new Error(`Unknown waitFor type: ${waitFor}`);
-    }, 'Failed AJAX content waiter');
+        return {
+            content: [{
+                    type: 'text',
+                    text: `❌ Unknown waitFor type: ${waitFor}. Valid types: 'selector', 'xhr', 'timeout'`,
+                }],
+            isError: true,
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `❌ AJAX content waiter failed: ${error instanceof Error ? error.message : String(error)}`,
+                }],
+            isError: true,
+        };
+    }
 }
 /**
  * Modal Popup Handler - Handle modal popups

package/dist/handlers/pagination-handlers.js

@@ -3,7 +3,7 @@
 // @ts-nocheck
 import { getCurrentPage } from '../browser-manager.js';
 import { validateWorkflow } from '../workflow-validation.js';
-import { withErrorHandling } from '../system-utils.js';
+import { withErrorHandling, sleep } from '../system-utils.js';
 import * as xml2js from 'xml2js';
 /**
  * "Next" button automatically detect और click करके सभी pages से data collect करता है
@@ -51,14 +51,14 @@ export async function handleAutoPagination(args) {
             }
             // Click next button
             await nextButton.click();
-            await page.waitForTimeout(waitBetweenPages);
+            await sleep(waitBetweenPages);
             // Wait for navigation or content load
             try {
                 await page.waitForNavigation({ timeout: 5000, waitUntil: 'domcontentloaded' });
             }
             catch (e) {
                 // No navigation occurred, content loaded dynamically
-                await page.waitForTimeout(1000);
+                await sleep(1000);
             }
             currentPage++;
         }
@@ -114,7 +114,7 @@ export async function handleInfiniteScroll(args) {
                 window.scrollTo(0, document.body.scrollHeight);
             });
             // Wait for new content to load
-            await page.waitForTimeout(scrollDelay);
+            await sleep(scrollDelay);
             scrollCount++;
         }
         return {
@@ -145,7 +145,7 @@ export async function handleMultiPageScraper(args) {
             const url = urls[i];
             try {
                 await page.goto(url, { waitUntil: 'domcontentloaded' });
-                await page.waitForTimeout(waitBetweenPages);
+                await sleep(waitBetweenPages);
                 const pageData = await page.evaluate((selector) => {
                     const elements = document.querySelectorAll(selector);
                     return Array.from(elements).map((el) => ({

package/dist/handlers/smart-data-extractors.js

@@ -3,7 +3,7 @@
 // @ts-nocheck
 import { getCurrentPage } from '../browser-manager.js';
 import { validateWorkflow } from '../workflow-validation.js';
-import { withErrorHandling } from '../system-utils.js';
+import { withErrorHandling, sleep } from '../system-utils.js';
 /**
  * HTML Elements Extractor - Extract all HTML elements with complete details
  */
@@ -203,7 +203,7 @@ export async function handleAjaxExtractor(args) {
         if (url && page.url() !== url) {
             await page.goto(url, { waitUntil: 'networkidle2' });
         }
-        await page.waitForTimeout(duration);
+        await sleep(duration);
         page.off('request', requestHandler);
         return {
             content: [{
@@ -247,7 +247,7 @@ export async function handleFetchXHR(args) {
             }
         };
         page.on('response', responseHandler);
-        await page.waitForTimeout(duration);
+        await sleep(duration);
         page.off('response', responseHandler);
         return {
             content: [{
@@ -296,7 +296,7 @@ export async function handleNetworkRecorder(args) {
         };
         page.on('request', requestHandler);
         page.on('response', responseHandler);
-        await page.waitForTimeout(duration);
+        await sleep(duration);
         page.off('request', requestHandler);
         page.off('response', responseHandler);
         return {

package/dist/handlers/visual-tools-handlers.js

@@ -4,6 +4,7 @@ import * as fs from 'fs/promises';
 import * as path from 'path';
 import pixelmatch from 'pixelmatch';
 import { PNG } from 'pngjs';
+import { sleep } from '../system-utils.js';
 /**
  * Full Page Screenshot - Capture entire page
  */
@@ -236,7 +237,7 @@ export async function handleVideoRecording(args) {
                 const framePath = path.join(framesDir, `frame_${i.toString().padStart(4, '0')}.png`);
                 await page.screenshot({ path: framePath });
                 frames.push(framePath);
-                await page.waitForTimeout(frameDelay);
+                await sleep(frameDelay);
             }
         }
         return {