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

package/dist/browser-manager.js

@@ -298,13 +298,33 @@ export async function initializeBrowser(options) {
             // console.('   Mode: GUI (visible browser)');
         }
         // Brave-real-browser handles everything automatically
-        // Simply pass-through user options without any manual args/flags
+        // Enable uBlock Origin for ad/popup blocking
+        // Add adblocker plugin for additional protection
+        // Dynamically import adblocker plugin
+        let adblockerPlugin = null;
+        try {
+            const adblockerModule = await import('puppeteer-extra-plugin-adblocker');
+            const AdblockerPlugin = (adblockerModule.default || adblockerModule);
+            if (typeof AdblockerPlugin === 'function') {
+                adblockerPlugin = AdblockerPlugin({
+                    blockTrackers: true,
+                    blockTrackersAndAnnoyances: true,
+                });
+            }
+        }
+        catch (e) {
+            // Adblocker plugin not available, continue without it
+        }
         const connectOptions = {
             headless: headlessMode,
             turnstile: true,
             connectOption: {
                 defaultViewport: null // Full window content, no viewport restriction
             },
+            plugins: adblockerPlugin ? [adblockerPlugin] : [], // Add adblocker plugin
+            customConfig: {
+                autoLoadUBlock: true, // Enable uBlock Origin in brave-real-launcher
+            },
             ...options, // Pass-through all user options
         };
         // Ensure headless is set correctly (overriding any conflicting option)

package/dist/handlers/advanced-tools.js

@@ -54,15 +54,31 @@ export async function handleBreadcrumbNavigator(page, args) {
 export async function handleUrlRedirectTracer(page, args) {
     const maxRedirects = args.maxRedirects || 10;
     const chain = [];
-    await page.setRequestInterception(true);
     const redirectHandler = (request) => {
-        if (request.isNavigationRequest()) {
-            chain.push(request.url());
+        try {
+            // Check if request is already handled
+            if (request.isInterceptResolutionHandled && request.isInterceptResolutionHandled()) {
+                return;
+            }
+            if (request.isNavigationRequest()) {
+                chain.push(request.url());
+            }
+            // Only continue if not already handled
+            if (!request.isInterceptResolutionHandled || !request.isInterceptResolutionHandled()) {
+                request.continue().catch(() => { });
+            }
+        }
+        catch (e) {
+            // Ignore errors in handler
         }
-        request.continue();
     };
     try {
-        await page.setRequestInterception(true);
+        try {
+            await page.setRequestInterception(true);
+        }
+        catch (e) {
+            // Interception might already be enabled
+        }
         page.on('request', redirectHandler);
         await page.goto(args.url, { waitUntil: 'networkidle2' });
         chain.push(page.url());
@@ -515,31 +531,50 @@ export async function handleNetworkRecorder(page, args) {
     const requests = [];
     const duration = args.duration || 10000;
     let totalSize = 0;
-    const requestHandler = async (request) => {
-        const url = request.url();
-        if (args.filterUrl && !url.includes(args.filterUrl)) {
-            request.continue();
-            return;
-        }
-        const entry = {
-            url,
-            method: request.method(),
-            resourceType: request.resourceType(),
-            timestamp: Date.now(),
-        };
-        if (args.includeHeaders) {
-            entry.headers = request.headers();
+    const requestHandler = (request) => {
+        try {
+            // Check if request is already handled to prevent crash
+            if (request.isInterceptResolutionHandled && request.isInterceptResolutionHandled()) {
+                return;
+            }
+            const url = request.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(),
+                timestamp: Date.now(),
+            };
+            if (args.includeHeaders) {
+                entry.headers = request.headers();
+            }
+            if (args.includeBody) {
+                entry.postData = request.postData();
+            }
+            requests.push(entry);
+            // Only continue if not already handled
+            if (!request.isInterceptResolutionHandled || !request.isInterceptResolutionHandled()) {
+                request.continue().catch(() => { });
+            }
         }
-        if (args.includeBody) {
-            entry.postData = request.postData();
+        catch {
+            // Ignore all errors in handler to prevent crash
         }
-        requests.push(entry);
-        request.continue();
     };
     try {
-        await page.setRequestInterception(true);
+        try {
+            await page.setRequestInterception(true);
+        }
+        catch (e) {
+            // Interception might already be enabled
+        }
         page.on('request', requestHandler);
-        page.on('response', async (response) => {
+        page.on('response', (response) => {
             try {
                 const headers = response.headers();
                 const size = parseInt(headers['content-length'] || '0', 10);
@@ -551,6 +586,9 @@ export async function handleNetworkRecorder(page, args) {
         });
         await new Promise((r) => setTimeout(r, duration));
     }
+    catch (e) {
+        // Capture setup errors
+    }
     finally {
         page.off('request', requestHandler);
         try {
@@ -571,17 +609,29 @@ export async function handleApiFinder(page, args) {
     const apis = [];
     const patterns = args.patterns || ['/api/', '/v1/', '/v2/', '/graphql', '/rest/', '.json'];
     const requestHandler = (request) => {
-        const url = request.url();
-        const isApi = patterns.some((p) => url.includes(p));
-        const isXhr = request.resourceType() === 'xhr' || request.resourceType() === 'fetch';
-        if (isApi || (args.includeInternal !== false && isXhr)) {
-            apis.push({
-                url,
-                method: request.method(),
-                type: request.resourceType(),
-            });
+        try {
+            // Check if request is already handled
+            if (request.isInterceptResolutionHandled && request.isInterceptResolutionHandled()) {
+                return;
+            }
+            const url = request.url();
+            const isApi = patterns.some((p) => url.includes(p));
+            const isXhr = request.resourceType() === 'xhr' || request.resourceType() === 'fetch';
+            if (isApi || (args.includeInternal !== false && isXhr)) {
+                apis.push({
+                    url,
+                    method: request.method(),
+                    type: request.resourceType(),
+                });
+            }
+            // Only continue if not already handled
+            if (!request.isInterceptResolutionHandled || !request.isInterceptResolutionHandled()) {
+                request.continue().catch(() => { });
+            }
+        }
+        catch (e) {
+            // Ignore errors in handler
         }
-        request.continue();
     };
     try {
         await page.setRequestInterception(true);
@@ -1325,11 +1375,23 @@ export async function handleM3u8Parser(page, args) {
     // Intercept network requests to find m3u8 files
     const m3u8Urls = [];
     const requestHandler = (request) => {
-        const url = request.url();
-        if (url.includes('.m3u8') || url.includes('manifest') || url.includes('playlist')) {
-            m3u8Urls.push(url);
+        try {
+            // Check if request is already handled
+            if (request.isInterceptResolutionHandled && request.isInterceptResolutionHandled()) {
+                return;
+            }
+            const url = request.url();
+            if (url.includes('.m3u8') || url.includes('manifest') || url.includes('playlist')) {
+                m3u8Urls.push(url);
+            }
+            // Only continue if not already handled
+            if (!request.isInterceptResolutionHandled || !request.isInterceptResolutionHandled()) {
+                request.continue().catch(() => { });
+            }
+        }
+        catch (e) {
+            // Ignore errors in handler
         }
-        request.continue();
     };
     try {
         await page.setRequestInterception(true);

package/dist/handlers/content-handlers.js

@@ -85,145 +85,48 @@ export async function handleFindSelector(args) {
             // Enhanced selector finding with authentication detection
             const results = await pageInstance.evaluate((searchText, selectors, isExact) => {
                 const elements = [];
-                // Authentication patterns for special handling
-                const authPatterns = [
-                    /^(log\s*in|sign\s*in|log\s*on|sign\s*on)$/i,
-                    /^(login|signin|authenticate|enter)$/i,
-                    /continue with (google|github|facebook|twitter|microsoft)/i,
-                    /sign in with/i
-                ];
-                const isAuthSearch = authPatterns.some(pattern => pattern.test(searchText));
-                // Utility class patterns to ignore (but not remove completely)
-                const utilityPatterns = [
-                    /^(m|p|mt|mb|ml|mr|pt|pb|pl|pr|mx|my|px|py)-?\d+$/,
-                    /^(text|bg|border)-(primary|secondary|danger|warning|info|success|light|dark|white|black)$/,
-                    /^(d|display)-(none|block|inline|flex|grid)$/,
-                    /^(w|h)-\d+$/,
-                    /^(btn|button)-(sm|md|lg|xl)$/
-                ];
-                function isUtilityClass(className) {
-                    return utilityPatterns.some(pattern => pattern.test(className));
-                }
-                function isMeaningfulClass(className) {
-                    // Keep classes that seem semantic/meaningful
-                    const meaningfulPatterns = [
-                        /^(nav|menu|header|footer|sidebar|content|main|article)/,
-                        /^(form|input|button|link|modal|dialog)/,
-                        /^(auth|login|signin|signup|register)/,
-                        /^(search|filter|sort|toggle)/,
-                        /(container|wrapper|section|panel|card)$/
-                    ];
-                    return meaningfulPatterns.some(pattern => pattern.test(className.toLowerCase()));
-                }
-                function generateSimpleSelector(element) {
-                    // Prioritize ID
-                    if (element.id && /^[a-zA-Z][\w-]*$/.test(element.id)) {
-                        return `#${CSS.escape(element.id)}`;
-                    }
-                    // Try data attributes
-                    const dataAttrs = Array.from(element.attributes)
-                        .filter(attr => attr.name.startsWith('data-') && attr.value)
-                        .map(attr => `[${attr.name}="${CSS.escape(attr.value)}"]`);
-                    if (dataAttrs.length > 0) {
-                        return element.tagName.toLowerCase() + dataAttrs[0];
-                    }
-                    // Use meaningful classes
-                    if (element.className && typeof element.className === 'string') {
-                        const classes = element.className.trim().split(/\s+/)
-                            .filter(cls => cls && (isMeaningfulClass(cls) || !isUtilityClass(cls)))
-                            .slice(0, 2); // Limit to 2 classes for simplicity
-                        if (classes.length > 0) {
-                            return element.tagName.toLowerCase() + '.' + classes.map(c => CSS.escape(c)).join('.');
-                        }
-                    }
-                    // Fallback to tag + text content for small text
-                    const textContent = element.textContent?.trim() || '';
-                    if (textContent.length > 0 && textContent.length <= 30) {
-                        return `${element.tagName.toLowerCase()}:contains("${textContent}")`;
-                    }
-                    return element.tagName.toLowerCase();
-                }
-                function calculateElementScore(element, searchText) {
-                    let score = 0;
-                    const elementText = element.textContent?.trim() || '';
-                    const lowerSearchText = searchText.toLowerCase();
-                    const lowerElementText = elementText.toLowerCase();
-                    // Exact match bonus
-                    if (lowerElementText === lowerSearchText)
-                        score += 100;
-                    // Contains match
-                    else if (lowerElementText.includes(lowerSearchText))
-                        score += 50;
-                    // Word boundary match bonus
-                    const wordRegex = new RegExp(`\\b${lowerSearchText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`);
-                    if (wordRegex.test(lowerElementText))
-                        score += 25;
-                    // Interactive elements bonus
-                    if (['button', 'a', 'input'].includes(element.tagName.toLowerCase()))
-                        score += 20;
-                    // Role attribute bonus
-                    if (element.getAttribute('role'))
-                        score += 10;
-                    // ID bonus
-                    if (element.id)
-                        score += 15;
-                    // Clickable bonus
-                    if (element.getAttribute('onclick') || element.getAttribute('href'))
-                        score += 10;
-                    // Penalize utility classes
-                    if (element.className && typeof element.className === 'string') {
-                        const utilityCount = element.className.split(/\s+/).filter(isUtilityClass).length;
-                        score -= utilityCount * 5;
-                    }
-                    return score;
-                }
+                const lowerSearchText = searchText.toLowerCase();
                 // Search through specified selectors
                 for (const baseSelector of selectors) {
                     const candidates = document.querySelectorAll(baseSelector);
                     candidates.forEach(element => {
                         const elementText = element.textContent?.trim() || '';
-                        const ariaLabel = element.getAttribute('aria-label') || '';
-                        const title = element.getAttribute('title') || '';
-                        const placeholder = element.getAttribute('placeholder') || '';
-                        const searchableText = [elementText, ariaLabel, title, placeholder].join(' ').toLowerCase();
-                        const lowerSearchText = searchText.toLowerCase();
+                        const lowerElementText = elementText.toLowerCase();
                         let matches = false;
                         if (isExact) {
-                            matches = elementText.toLowerCase() === lowerSearchText ||
-                                ariaLabel.toLowerCase() === lowerSearchText;
+                            matches = lowerElementText === lowerSearchText;
                         }
                         else {
-                            matches = searchableText.includes(lowerSearchText);
-                        }
-                        // Special handling for authentication searches
-                        if (isAuthSearch && !matches) {
-                            const href = element.href || '';
-                            const hasAuthRoute = href.includes('login') || href.includes('signin') ||
-                                href.includes('auth') || href.includes('oauth');
-                            if (hasAuthRoute)
-                                matches = true;
+                            matches = lowerElementText.includes(lowerSearchText);
                         }
                         if (matches) {
-                            const rect = element.getBoundingClientRect();
-                            const selector = generateSimpleSelector(element);
-                            const confidence = calculateElementScore(element, searchText);
+                            // Generate simple selector
+                            let selector = element.tagName.toLowerCase();
+                            if (element.id) {
+                                selector += '#' + element.id;
+                            }
+                            else if (element.className && typeof element.className === 'string') {
+                                const cls = element.className.trim().split(/\s+/)[0];
+                                if (cls)
+                                    selector += '.' + cls;
+                            }
+                            // Calculate dummy confidence / score based on match
+                            let confidence = 100;
+                            if (lowerElementText === lowerSearchText)
+                                confidence = 100;
+                            else
+                                confidence = 80;
                             elements.push({
                                 selector,
-                                text: elementText,
+                                text: elementText.substring(0, 100),
                                 tagName: element.tagName.toLowerCase(),
-                                confidence,
-                                rect: {
-                                    x: rect.x,
-                                    y: rect.y,
-                                    width: rect.width,
-                                    height: rect.height
-                                }
+                                confidence
                             });
                         }
                     });
                 }
-                // Sort by confidence score
-                return elements.sort((a, b) => b.confidence - a.confidence);
+                // Return top 10 unique
+                return elements.slice(0, 10);
             }, text, // Use the text argument from args
             searchSelectors, exact);
             if (results.length === 0) {

package/dist/handlers/file-handlers.js

@@ -117,17 +117,8 @@ export async function handleSaveContentAsMarkdown(args) {
             catch (error) {
                 throw new Error(`Failed to create directory: ${dirPath}. ${error instanceof Error ? error.message : String(error)}`);
             }
-            // Check if file already exists
-            try {
-                await fs.access(filePath);
-                throw new Error(`File already exists: ${filePath}. Please choose a different path or delete the existing file.`);
-            }
-            catch (error) {
-                // File doesn't exist, which is what we want
-                if (error.code !== 'ENOENT') {
-                    throw error;
-                }
-            }
+            // File existence check removed to allow overwriting
+            // ensure directory is there (already checked above)
             // Extract content from page
             let content;
             let currentUrl;

package/dist/handlers/navigation-handlers.js

@@ -152,20 +152,40 @@ async function waitForCloudflareBypass(pageInstance) {
     try {
         // Initial stable wait
         await new Promise(resolve => setTimeout(resolve, 2000));
-        const maxWait = 40000;
+        const maxWait = 60000;
         const startTime = Date.now();
         while (Date.now() - startTime < maxWait) {
             const isChallenge = await pageInstance.evaluate(() => {
                 const bodyText = (document.body?.innerText || '').toLowerCase();
                 // Strict checks to avoid false positives on normal sites
-                return bodyText.includes('verifying you are human') ||
-                    bodyText.includes('checking your browser before accessing');
+                const hasChallengeText = bodyText.includes('verifying you are human') ||
+                    bodyText.includes('checking your browser before accessing') ||
+                    bodyText.includes('just a moment');
+                // Also check for challenge iframes
+                const hasChallengeFrames = !!document.querySelector('iframe[src*="cloudflare"]') ||
+                    !!document.querySelector('iframe[src*="turnstile"]');
+                return hasChallengeText && hasChallengeFrames;
             });
             if (!isChallenge) {
-                return; // Not a challenge page, or passed
+                // Double check state remains stable
+                await new Promise(resolve => setTimeout(resolve, 1500));
+                const stillChallenge = await pageInstance.evaluate(() => {
+                    const bodyText = (document.body?.innerText || '').toLowerCase();
+                    return bodyText.includes('verifying you are human');
+                });
+                if (!stillChallenge)
+                    return; // Not a challenge page, or passed
+            }
+            // Simulate human behavior: Random small mouse movements
+            try {
+                // Move mouse slightly to simulate presence
+                await pageInstance.mouse.move(100 + Math.random() * 200, 100 + Math.random() * 200, { steps: 5 });
+            }
+            catch (e) {
+                // Ignore mouse errors (e.g. if target closed)
             }
             // Still blocked, wait
-            await new Promise(resolve => setTimeout(resolve, 1000));
+            await new Promise(resolve => setTimeout(resolve, 2000));
         }
     }
     catch (error) {

package/dist/workflow-validation.js

@@ -66,7 +66,14 @@ export class WorkflowValidator {
             'type': [WorkflowState.CONTENT_ANALYZED, WorkflowState.SELECTOR_AVAILABLE],
             'wait': [WorkflowState.PAGE_LOADED, WorkflowState.CONTENT_ANALYZED, WorkflowState.SELECTOR_AVAILABLE],
             'solve_captcha': [WorkflowState.PAGE_LOADED, WorkflowState.CONTENT_ANALYZED, WorkflowState.SELECTOR_AVAILABLE],
-            'random_scroll': [WorkflowState.PAGE_LOADED, WorkflowState.CONTENT_ANALYZED, WorkflowState.SELECTOR_AVAILABLE]
+            'random_scroll': [WorkflowState.PAGE_LOADED, WorkflowState.CONTENT_ANALYZED, WorkflowState.SELECTOR_AVAILABLE],
+            'save_content_as_markdown': [WorkflowState.CONTENT_ANALYZED, WorkflowState.SELECTOR_AVAILABLE],
+            // Allow advanced tools in analyzed state
+            'search_content': [WorkflowState.CONTENT_ANALYZED, WorkflowState.SELECTOR_AVAILABLE],
+            'extract_json': [WorkflowState.CONTENT_ANALYZED, WorkflowState.SELECTOR_AVAILABLE],
+            'scrape_meta_tags': [WorkflowState.PAGE_LOADED, WorkflowState.CONTENT_ANALYZED],
+            'link_harvester': [WorkflowState.PAGE_LOADED, WorkflowState.CONTENT_ANALYZED],
+            'deep_analysis': [WorkflowState.PAGE_LOADED, WorkflowState.CONTENT_ANALYZED]
         };
         const allowedStates = toolPrerequisites[toolName];
         if (!allowedStates) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.20.0",
+  "version": "2.21.0",
   "description": "🦁 MCP server for Brave Real Browser - NPM Workspaces Monorepo with anti-detection features",
   "type": "module",
   "main": "dist/index.js",
@@ -26,6 +26,8 @@
     "test:ui": "vitest --ui",
     "test:coverage": "vitest --coverage",
     "test:ci": "vitest run --coverage",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:integration": "npx tsx test/integration/test-all-tools.ts",
     "publish-all": "node scripts/publish-all.js",
     "publish-all:dry": "node scripts/publish-all.js --dry-run",
     "prepare-publish": "node scripts/prepare-publish.js",
@@ -39,7 +41,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",
     "@types/turndown": "latest",
-    "brave-real-browser": "^2.2.0",
+    "brave-real-browser": "^2.3.0",
     "turndown": "latest"
   },
   "peerDependencies": {