brave-real-browser-mcp-server 2.28.1 → 2.29.1

package/dist/handlers/navigation-handlers.js

@@ -9,7 +9,7 @@ const eventBus = getSharedEventBus();
 function isApiEndpoint(url) {
     return /\/api\/|\.json(\?|$)|\?.*=.*&|\/v\d+\//.test(url);
 }
-// Navigation handler with real-time progress
+// Navigation handler with real-time progress and advanced features
 export async function handleNavigate(args) {
     const progressNotifier = getProgressNotifier();
     const progressToken = `navigate-${Date.now()}`;
@@ -22,25 +22,89 @@ export async function handleNavigate(args) {
                 tracker.fail('Browser not initialized');
                 throw new Error('Browser not initialized. Call browser_init first.');
             }
-            const { url, waitUntil = 'domcontentloaded' } = args;
-            tracker.setProgress(10, `📍 Navigating to: ${url}`);
-            // Navigate with retry logic
+            const { url, waitUntil = 'domcontentloaded', blockResources, customHeaders, referrer, waitForSelector, waitForContent, scrollToBottom, randomDelay, bypassCSP, timeout = 60000, retries = 3 } = args;
+            tracker.setProgress(5, `📍 Preparing to navigate to: ${url}`);
+            // ============================================================
+            // STEP 1: Setup request interception for resource blocking
+            // ============================================================
+            let interceptorEnabled = false;
+            const blockedTypes = new Set(blockResources || []);
+            if (blockedTypes.size > 0) {
+                tracker.setProgress(8, `🚫 Setting up resource blocking: ${Array.from(blockedTypes).join(', ')}`);
+                try {
+                    await pageInstance.setRequestInterception(true);
+                    interceptorEnabled = true;
+                    pageInstance.on('request', (request) => {
+                        const resourceType = request.resourceType();
+                        if (blockedTypes.has(resourceType)) {
+                            request.abort();
+                        }
+                        else {
+                            request.continue();
+                        }
+                    });
+                }
+                catch (e) {
+                    // Interception already enabled or not supported
+                }
+            }
+            // ============================================================
+            // STEP 2: Set custom headers if provided
+            // ============================================================
+            if (customHeaders && Object.keys(customHeaders).length > 0) {
+                tracker.setProgress(10, '📝 Setting custom headers...');
+                try {
+                    await pageInstance.setExtraHTTPHeaders(customHeaders);
+                }
+                catch (e) {
+                    // Ignore header setting errors
+                }
+            }
+            // ============================================================
+            // STEP 3: Bypass CSP if requested
+            // ============================================================
+            if (bypassCSP) {
+                tracker.setProgress(12, '🔓 Bypassing Content Security Policy...');
+                try {
+                    await pageInstance.setBypassCSP(true);
+                }
+                catch (e) {
+                    // CSP bypass not supported
+                }
+            }
+            // ============================================================
+            // STEP 4: Add random human-like delay
+            // ============================================================
+            if (randomDelay) {
+                const delay = 100 + Math.random() * 400; // 100-500ms
+                tracker.setProgress(14, `⏳ Human-like delay: ${Math.round(delay)}ms`);
+                await new Promise(r => setTimeout(r, delay));
+            }
+            tracker.setProgress(15, `📍 Navigating to: ${url}`);
+            // ============================================================
+            // STEP 5: Navigate with retry logic
+            // ============================================================
             let lastError = null;
             let success = false;
-            const maxRetries = 3;
+            const maxRetries = retries;
             for (let attempt = 1; attempt <= maxRetries; attempt++) {
                 try {
-                    tracker.setProgress(20 + (attempt - 1) * 20, `🔄 Attempt ${attempt}/${maxRetries}...`);
+                    tracker.setProgress(15 + (attempt - 1) * 15, `🔄 Attempt ${attempt}/${maxRetries}...`);
                     await withTimeout(async () => {
-                        await pageInstance.goto(url, {
+                        const navigationOptions = {
                             waitUntil: waitUntil,
-                            timeout: 60000
-                        });
-                        tracker.setProgress(60, '🛡️ Checking for Cloudflare...');
+                            timeout: timeout
+                        };
+                        // Add referrer if provided
+                        if (referrer) {
+                            navigationOptions.referer = referrer;
+                        }
+                        await pageInstance.goto(url, navigationOptions);
+                        tracker.setProgress(50, '🛡️ Checking for Cloudflare...');
                         // Auto-handle Cloudflare challenges if detected
                         await waitForCloudflareBypass(pageInstance, tracker);
-                    }, 90000, 'page-navigation');
-                    tracker.setProgress(80, '✅ Navigation successful');
+                    }, timeout + 30000, 'page-navigation');
+                    tracker.setProgress(60, '✅ Navigation successful');
                     success = true;
                     break;
                 }
@@ -62,6 +126,13 @@ export async function handleNavigate(args) {
                                     data: text
                                 };
                             }, url);
+                            // Cleanup interception
+                            if (interceptorEnabled) {
+                                try {
+                                    await pageInstance.setRequestInterception(false);
+                                }
+                                catch { }
+                            }
                             tracker.complete('📡 API endpoint fetched successfully');
                             return {
                                 content: [
@@ -77,19 +148,89 @@ export async function handleNavigate(args) {
                             tracker.setProgress(55, '❌ Fetch fallback failed, retrying navigation...');
                         }
                     }
-                    tracker.setProgress(20 + attempt * 20, `❌ Attempt ${attempt} failed: ${lastError.message}`);
+                    tracker.setProgress(15 + attempt * 15, `❌ Attempt ${attempt} failed: ${lastError.message}`);
                     if (attempt < maxRetries) {
                         const delay = 1000 * Math.pow(2, attempt - 1);
-                        tracker.setProgress(25 + attempt * 20, `⏳ Retrying in ${delay}ms...`);
+                        tracker.setProgress(20 + attempt * 15, `⏳ Retrying in ${delay}ms...`);
                         await new Promise(resolve => setTimeout(resolve, delay));
                     }
                 }
             }
             if (!success && lastError) {
+                // Cleanup interception
+                if (interceptorEnabled) {
+                    try {
+                        await pageInstance.setRequestInterception(false);
+                    }
+                    catch { }
+                }
                 tracker.fail(lastError.message);
                 throw lastError;
             }
-            tracker.setProgress(90, '📄 Page loaded, preparing response...');
+            // ============================================================
+            // STEP 6: Wait for specific selector if requested
+            // ============================================================
+            if (waitForSelector) {
+                tracker.setProgress(65, `🔍 Waiting for selector: ${waitForSelector}`);
+                try {
+                    await pageInstance.waitForSelector(waitForSelector, { timeout: 10000, visible: true });
+                    tracker.setProgress(70, '✅ Selector found');
+                }
+                catch (e) {
+                    tracker.setProgress(70, `⚠️ Selector not found: ${waitForSelector}`);
+                }
+            }
+            // ============================================================
+            // STEP 7: Wait for specific content if requested
+            // ============================================================
+            if (waitForContent) {
+                tracker.setProgress(72, `📝 Waiting for content: "${waitForContent.substring(0, 30)}..."`);
+                try {
+                    await pageInstance.waitForFunction((text) => document.body?.innerText?.includes(text), { timeout: 10000 }, waitForContent);
+                    tracker.setProgress(75, '✅ Content found');
+                }
+                catch (e) {
+                    tracker.setProgress(75, `⚠️ Content not found: "${waitForContent.substring(0, 30)}..."`);
+                }
+            }
+            // ============================================================
+            // STEP 8: Auto-scroll to trigger lazy loading
+            // ============================================================
+            if (scrollToBottom) {
+                tracker.setProgress(77, '📜 Auto-scrolling to trigger lazy loading...');
+                try {
+                    await pageInstance.evaluate(async () => {
+                        const scrollStep = window.innerHeight;
+                        const scrollDelay = 200;
+                        let totalScrolled = 0;
+                        const maxScroll = Math.min(document.body.scrollHeight, 10000);
+                        while (totalScrolled < maxScroll) {
+                            window.scrollBy(0, scrollStep);
+                            totalScrolled += scrollStep;
+                            await new Promise(r => setTimeout(r, scrollDelay));
+                        }
+                        // Scroll back to top
+                        window.scrollTo(0, 0);
+                    });
+                    // Wait for lazy content to load
+                    await new Promise(r => setTimeout(r, 1000));
+                    tracker.setProgress(82, '✅ Auto-scroll completed');
+                }
+                catch (e) {
+                    tracker.setProgress(82, '⚠️ Auto-scroll failed');
+                }
+            }
+            // ============================================================
+            // STEP 9: Cleanup and prepare response
+            // ============================================================
+            // Disable request interception if it was enabled
+            if (interceptorEnabled) {
+                try {
+                    await pageInstance.setRequestInterception(false);
+                }
+                catch { }
+            }
+            tracker.setProgress(85, '📄 Page loaded, preparing response...');
             // Publish browser state update to event bus
             try {
                 eventBus.publish({
@@ -106,6 +247,34 @@ export async function handleNavigate(args) {
             catch (error) {
                 // Ignore event bus errors
             }
+            // Get page info for response
+            let pageInfo = '';
+            try {
+                const title = await pageInstance.title();
+                const finalUrl = pageInstance.url();
+                pageInfo = `\n📄 Title: ${title}\n🔗 Final URL: ${finalUrl}`;
+            }
+            catch { }
+            const advancedOptionsUsed = [];
+            if (blockResources?.length)
+                advancedOptionsUsed.push(`Blocked: ${blockResources.join(', ')}`);
+            if (customHeaders)
+                advancedOptionsUsed.push('Custom headers set');
+            if (referrer)
+                advancedOptionsUsed.push(`Referrer: ${referrer}`);
+            if (waitForSelector)
+                advancedOptionsUsed.push(`Waited for: ${waitForSelector}`);
+            if (waitForContent)
+                advancedOptionsUsed.push(`Waited for content`);
+            if (scrollToBottom)
+                advancedOptionsUsed.push('Auto-scrolled');
+            if (randomDelay)
+                advancedOptionsUsed.push('Human delay added');
+            if (bypassCSP)
+                advancedOptionsUsed.push('CSP bypassed');
+            const advancedInfo = advancedOptionsUsed.length > 0
+                ? `\n\n⚡ Advanced options: ${advancedOptionsUsed.join(' | ')}`
+                : '';
             const workflowMessage = '\n\n🔄 Workflow Status: Page loaded\n' +
                 '  • Next step: Use get_content to analyze page content\n' +
                 '  • Then: Use find_selector to locate elements\n' +
@@ -116,7 +285,7 @@ export async function handleNavigate(args) {
                 content: [
                     {
                         type: 'text',
-                        text: `Successfully navigated to ${url}${workflowMessage}`,
+                        text: `Successfully navigated to ${url}${pageInfo}${advancedInfo}${workflowMessage}`,
                     },
                 ],
             };

package/dist/handlers/tool-executor.js

@@ -247,3 +247,204 @@ export async function executeBatchWithProgress(toolName, items, operation) {
         return results;
     }, { totalSteps: items.length + 2 });
 }
+// Default recovery strategies for common browser automation errors
+const defaultRecoveryStrategies = [
+    // Network errors - retry with delay
+    { errorPattern: /net::ERR_|ECONNREFUSED|ETIMEDOUT|socket hang up/i, action: 'retry', maxRetries: 3, delay: 2000 },
+    // Navigation errors - refresh and retry
+    { errorPattern: /Navigation timeout|navigation.*timed out/i, action: 'refresh', maxRetries: 2, delay: 1000 },
+    // Frame/Context errors - restart browser
+    { errorPattern: /frame was detached|Execution context was destroyed|Target closed/i, action: 'restart_browser', maxRetries: 1 },
+    // Session errors - restart browser
+    { errorPattern: /Session closed|Protocol error|Session timed out/i, action: 'restart_browser', maxRetries: 1 },
+    // Element not found - retry with delay
+    { errorPattern: /Element.*not found|waiting for selector|failed to find/i, action: 'retry', maxRetries: 3, delay: 1000 },
+    // Rate limiting - wait and retry
+    { errorPattern: /rate limit|too many requests|429/i, action: 'retry', maxRetries: 3, delay: 5000 },
+    // Cloudflare/Bot detection - skip (handled separately)
+    { errorPattern: /cloudflare|captcha|bot detected|access denied/i, action: 'skip', maxRetries: 0 },
+];
+// Global error recovery configuration
+let errorRecoveryConfig = {
+    enabled: true,
+    maxGlobalRetries: 5,
+    defaultDelay: 1000,
+    strategies: defaultRecoveryStrategies
+};
+/**
+ * Configure error recovery
+ */
+export function configureErrorRecovery(config) {
+    errorRecoveryConfig = { ...errorRecoveryConfig, ...config };
+    if (config.strategies) {
+        errorRecoveryConfig.strategies = [...config.strategies, ...defaultRecoveryStrategies];
+    }
+}
+/**
+ * Add a custom recovery strategy
+ */
+export function addRecoveryStrategy(strategy) {
+    errorRecoveryConfig.strategies.unshift(strategy); // Add at beginning for priority
+}
+/**
+ * Get matching recovery strategy for an error
+ */
+function getRecoveryStrategy(error) {
+    const errorMessage = error.message || String(error);
+    for (const strategy of errorRecoveryConfig.strategies) {
+        const pattern = typeof strategy.errorPattern === 'string'
+            ? new RegExp(strategy.errorPattern, 'i')
+            : strategy.errorPattern;
+        if (pattern.test(errorMessage)) {
+            return strategy;
+        }
+    }
+    return null;
+}
+const recoveryState = {
+    globalRetries: 0,
+    errorCounts: new Map(),
+    lastRecoveryTime: 0
+};
+/**
+ * Reset recovery state (call after successful operation)
+ */
+export function resetRecoveryState() {
+    recoveryState.globalRetries = 0;
+    recoveryState.errorCounts.clear();
+}
+/**
+ * Execute with auto-recovery
+ */
+export async function executeWithRecovery(operation, options) {
+    if (!errorRecoveryConfig.enabled) {
+        try {
+            const result = await operation();
+            return { success: true, result, recoveryAttempts: 0 };
+        }
+        catch (error) {
+            return { success: false, error: error, recoveryAttempts: 0 };
+        }
+    }
+    let lastError = null;
+    let attempts = 0;
+    while (recoveryState.globalRetries < errorRecoveryConfig.maxGlobalRetries) {
+        try {
+            const result = await operation();
+            // Success - reset relevant counters
+            if (attempts > 0) {
+                options.onProgress?.(`✅ Recovery successful after ${attempts} attempts`);
+            }
+            return { success: true, result, recoveryAttempts: attempts };
+        }
+        catch (error) {
+            lastError = error;
+            const strategy = getRecoveryStrategy(lastError);
+            if (!strategy) {
+                // No recovery strategy for this error
+                options.onProgress?.(`❌ No recovery strategy for: ${lastError.message}`);
+                return { success: false, error: lastError, recoveryAttempts: attempts };
+            }
+            // Check error-specific retry count
+            const errorKey = strategy.errorPattern.toString();
+            const errorCount = recoveryState.errorCounts.get(errorKey) || 0;
+            if (errorCount >= (strategy.maxRetries || 3)) {
+                options.onProgress?.(`❌ Max retries (${strategy.maxRetries}) reached for: ${errorKey}`);
+                return { success: false, error: lastError, recoveryAttempts: attempts };
+            }
+            // Increment counters
+            recoveryState.globalRetries++;
+            recoveryState.errorCounts.set(errorKey, errorCount + 1);
+            attempts++;
+            // Execute recovery action
+            const delay = strategy.delay || errorRecoveryConfig.defaultDelay;
+            options.onProgress?.(`🔄 Recovery attempt ${attempts}: ${strategy.action} (${lastError.message.substring(0, 50)}...)`);
+            // Notify callback
+            errorRecoveryConfig.onRecovery?.(lastError, strategy.action, attempts);
+            switch (strategy.action) {
+                case 'retry':
+                    // Simple retry after delay
+                    await new Promise(r => setTimeout(r, delay));
+                    break;
+                case 'refresh':
+                    // Refresh the page and retry
+                    if (options.page) {
+                        try {
+                            await options.page.reload({ waitUntil: 'domcontentloaded', timeout: 15000 });
+                            await new Promise(r => setTimeout(r, delay));
+                        }
+                        catch (e) {
+                            // Refresh failed, continue anyway
+                        }
+                    }
+                    break;
+                case 'restart_browser':
+                    // Restart the browser
+                    if (options.restartBrowser) {
+                        try {
+                            options.onProgress?.('🔄 Restarting browser...');
+                            await options.restartBrowser();
+                            await new Promise(r => setTimeout(r, delay));
+                        }
+                        catch (e) {
+                            options.onProgress?.(`⚠️ Browser restart failed: ${e.message}`);
+                        }
+                    }
+                    break;
+                case 'fallback':
+                    // Try fallback function
+                    if (strategy.fallbackFn) {
+                        try {
+                            const fallbackResult = await strategy.fallbackFn();
+                            return { success: true, result: fallbackResult, recoveryAttempts: attempts };
+                        }
+                        catch (e) {
+                            // Fallback failed, continue with retry
+                        }
+                    }
+                    break;
+                case 'skip':
+                    // Skip this operation entirely
+                    options.onProgress?.(`⏭️ Skipping operation due to: ${lastError.message}`);
+                    return { success: false, error: lastError, recoveryAttempts: attempts };
+            }
+            recoveryState.lastRecoveryTime = Date.now();
+        }
+    }
+    // Max global retries reached
+    options.onProgress?.(`❌ Max global retries (${errorRecoveryConfig.maxGlobalRetries}) reached`);
+    return { success: false, error: lastError || new Error('Max retries reached'), recoveryAttempts: attempts };
+}
+/**
+ * Decorator to add auto-recovery to any async function
+ */
+export function withAutoRecovery(toolName, options = {}) {
+    return function (handler) {
+        return async function (...args) {
+            // Check if first arg is a page object
+            const page = args[0]?.goto ? args[0] : undefined;
+            const result = await executeWithRecovery(() => handler(...args), {
+                toolName,
+                page,
+                onProgress: (msg) => console.log(`[${toolName}] ${msg}`)
+            });
+            if (!result.success) {
+                throw result.error;
+            }
+            return result.result;
+        };
+    };
+}
+/**
+ * Get current recovery statistics
+ */
+export function getRecoveryStats() {
+    return {
+        enabled: errorRecoveryConfig.enabled,
+        globalRetries: recoveryState.globalRetries,
+        maxGlobalRetries: errorRecoveryConfig.maxGlobalRetries,
+        errorCounts: Object.fromEntries(recoveryState.errorCounts),
+        lastRecoveryTime: recoveryState.lastRecoveryTime,
+        strategiesCount: errorRecoveryConfig.strategies.length
+    };
+}

package/dist/tool-definitions.js

@@ -195,7 +195,7 @@ export const TOOLS = [
     },
     {
         name: 'navigate',
-        description: 'Navigate to a URL',
+        description: 'Navigate to a URL with advanced options: resource blocking, custom headers, auto-scroll, wait for content, and anti-detection features.',
         inputSchema: {
             type: 'object',
             additionalProperties: false,
@@ -210,6 +210,53 @@ export const TOOLS = [
                     enum: ['load', 'domcontentloaded', 'networkidle0', 'networkidle2'],
                     default: 'domcontentloaded',
                 },
+                // Advanced options
+                blockResources: {
+                    type: 'array',
+                    items: { type: 'string', enum: ['image', 'stylesheet', 'font', 'media', 'script'] },
+                    description: 'Block resource types for faster loading (e.g., ["image", "font"])',
+                },
+                customHeaders: {
+                    type: 'object',
+                    description: 'Custom headers to send with request (e.g., {"Authorization": "Bearer xxx"})',
+                },
+                referrer: {
+                    type: 'string',
+                    description: 'Custom referrer URL',
+                },
+                waitForSelector: {
+                    type: 'string',
+                    description: 'Wait for specific CSS selector after navigation',
+                },
+                waitForContent: {
+                    type: 'string',
+                    description: 'Wait for specific text content to appear',
+                },
+                scrollToBottom: {
+                    type: 'boolean',
+                    description: 'Auto-scroll to bottom to trigger lazy loading',
+                    default: false,
+                },
+                randomDelay: {
+                    type: 'boolean',
+                    description: 'Add random human-like delay (100-500ms) before navigation',
+                    default: false,
+                },
+                bypassCSP: {
+                    type: 'boolean',
+                    description: 'Bypass Content Security Policy',
+                    default: false,
+                },
+                timeout: {
+                    type: 'number',
+                    description: 'Navigation timeout in ms',
+                    default: 60000,
+                },
+                retries: {
+                    type: 'number',
+                    description: 'Number of retry attempts on failure',
+                    default: 3,
+                },
             },
             required: ['url'],
         },
@@ -648,7 +695,7 @@ export const TOOLS = [
     },
     {
         name: 'network_recorder',
-        description: 'Record full network traffic including headers and body. Also discovers hidden API endpoints.',
+        description: 'Record full network traffic including headers and body. Also discovers hidden API endpoints. NEW: API interception with request blocking, mocking, and header modification.',
         inputSchema: {
             type: 'object',
             additionalProperties: false,
@@ -660,6 +707,33 @@ export const TOOLS = [
                 // Merged from api_finder
                 findApis: { type: 'boolean', description: 'Discover hidden API endpoints (XHR/fetch)', default: false },
                 apiPatterns: { type: 'array', items: { type: 'string' }, description: 'URL patterns to match for API discovery' },
+                // API Interceptor options
+                interceptMode: { type: 'string', enum: ['record', 'intercept', 'mock'], description: 'Mode: record (passive), intercept (active with blocking/modifying), mock (respond with fake data)', default: 'record' },
+                blockPatterns: { type: 'array', items: { type: 'string' }, description: 'URL patterns to block (e.g., ["ads", "/tracking/"])' },
+                mockResponses: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            urlPattern: { type: 'string' },
+                            response: { type: 'object' },
+                            statusCode: { type: 'number' }
+                        }
+                    },
+                    description: 'Mock responses for matching URLs'
+                },
+                modifyHeaders: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            urlPattern: { type: 'string' },
+                            headers: { type: 'object' }
+                        }
+                    },
+                    description: 'Modify headers for matching URLs'
+                },
+                capturePayloads: { type: 'boolean', description: 'Capture POST/PUT request bodies', default: false },
             },
         },
     },
@@ -670,7 +744,7 @@ export const TOOLS = [
     // batch_element_scraper REMOVED - merged into find_element (use batchMode: true)
     {
         name: 'link_harvester',
-        description: 'Harvest all links from page with filtering options',
+        description: 'Harvest all links from page with filtering options. NEW: Auto-follow pagination to scrape multiple pages automatically.',
         inputSchema: {
             type: 'object',
             additionalProperties: false,
@@ -679,6 +753,11 @@ export const TOOLS = [
                 includeExternal: { type: 'boolean', description: 'Include external links', default: true },
                 includeInternal: { type: 'boolean', description: 'Include internal links', default: true },
                 maxLinks: { type: 'number', description: 'Maximum links to return' },
+                // Pagination options
+                followPagination: { type: 'boolean', description: 'Auto-follow pagination links to scrape multiple pages', default: false },
+                maxPages: { type: 'number', description: 'Maximum pages to scrape when following pagination (1-20)', default: 5 },
+                paginationSelector: { type: 'string', description: 'Custom CSS selector for the next page link (e.g., "a.next-page")' },
+                delayBetweenPages: { type: 'number', description: 'Delay between page navigations in ms', default: 1000 },
             },
         },
     },
@@ -746,7 +825,7 @@ export const TOOLS = [
     },
     {
         name: 'stream_extractor',
-        description: 'Master tool: Extract direct download/stream URLs from any page with automatic redirect following, countdown waiting, and format detection',
+        description: 'Master tool: Extract direct download/stream URLs from any page with automatic redirect following, countdown waiting, format detection, multi-quality selection, and VidSrc/Filemoon/StreamWish support',
         inputSchema: {
             type: 'object',
             additionalProperties: false,
@@ -762,17 +841,32 @@ export const TOOLS = [
                     default: ['mp4', 'mkv', 'm3u8', 'mp3'],
                 },
                 quality: { type: 'string', description: 'Preferred quality (highest, lowest, 1080p, 720p)', default: 'highest' },
+                autoSelectBest: { type: 'boolean', description: 'Auto-select highest quality stream', default: true },
+                preferredQuality: {
+                    type: 'string',
+                    enum: ['1080p', '720p', '480p', '360p', 'highest', 'lowest'],
+                    description: 'Preferred quality to select',
+                    default: 'highest'
+                },
+                extractSubtitles: { type: 'boolean', description: 'Also extract VTT/SRT subtitles', default: false },
+                siteType: {
+                    type: 'string',
+                    enum: ['auto', 'vidsrc', 'filemoon', 'streamwish', 'doodstream', 'mixdrop', 'streamtape', 'vidcloud', 'mp4upload'],
+                    description: 'Site-specific extraction mode (auto-detects if not specified)',
+                    default: 'auto'
+                },
             },
         },
     },
     {
         name: 'js_scrape',
-        description: 'Single-call JavaScript-rendered content extraction. Combines navigation, auto-wait, scrolling, and content extraction. Perfect for AJAX/dynamic pages that Jsoup cannot parse.',
+        description: 'Single-call JavaScript-rendered content extraction. Combines navigation, auto-wait, scrolling, and content extraction. Perfect for AJAX/dynamic pages that Jsoup cannot parse. NEW: Supports parallel scraping of multiple URLs with concurrency control.',
         inputSchema: {
             type: 'object',
             additionalProperties: false,
             properties: {
                 url: { type: 'string', description: 'URL to scrape (required)' },
+                urls: { type: 'array', items: { type: 'string' }, description: 'Multiple URLs for parallel scraping (alternative to url)' },
                 waitForSelector: { type: 'string', description: 'CSS selector to wait for before extracting content' },
                 waitForTimeout: { type: 'number', description: 'Maximum wait time in ms', default: 10000 },
                 extractSelector: { type: 'string', description: 'CSS selector for specific elements to extract (optional, extracts full page if not specified)' },
@@ -780,8 +874,12 @@ export const TOOLS = [
                 returnType: { type: 'string', enum: ['html', 'text', 'elements'], description: 'Return format', default: 'html' },
                 scrollToLoad: { type: 'boolean', description: 'Scroll page to trigger lazy loading', default: true },
                 closeBrowserAfter: { type: 'boolean', description: 'Close browser after scraping', default: false },
+                // Parallel scraping options
+                concurrency: { type: 'number', description: 'Max concurrent scrapes for parallel mode (1-10)', default: 3 },
+                continueOnError: { type: 'boolean', description: 'Continue scraping even if some URLs fail', default: true },
+                delayBetween: { type: 'number', description: 'Delay between starting each scrape in ms', default: 500 },
             },
-            required: ['url'],
+            required: [],
         },
     },
     // ============================================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.28.1",
+  "version": "2.29.1",
   "description": "🦁 MCP server for Brave Real Browser - NPM Workspaces Monorepo with anti-detection features, SSE streaming, and LSP compatibility",
   "type": "module",
   "main": "dist/index.js",
@@ -50,7 +50,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",
     "@types/turndown": "latest",
-    "brave-real-browser": "^2.8.33",
+    "brave-real-browser": "^2.9.1",
     "puppeteer-core": "^24.35.0",
     "turndown": "latest",
     "vscode-languageserver": "^9.0.1",