brave-real-browser-mcp-server 2.15.1 → 2.15.3

package/dist/index.js

@@ -44,7 +44,7 @@ import { handleOCREngine, handleAudioCaptchaSolver, handlePuzzleCaptchaHandler,
 // Import visual tools handlers
 import { handleFullPageScreenshot, handleElementScreenshot, handleVideoRecording, handleVisualComparison, } from "./handlers/visual-tools-handlers.js";
 // Import smart data extractors
-import { handleHtmlElementsExtractor, handleTagsFinder, handleLinksFinder, handleXpathLinks, handleAjaxExtractor, handleFetchXHR, handleNetworkRecorder, handleRegexPatternFinder, handleIframeExtractor, handleEmbedPageExtractor, handleImageExtractorAdvanced, handleVideoSourceExtractor, handleVideoPlayerExtractor, handleVideoPlayerHosterFinder, handleOriginalVideoHosterFinder, handleUrlRedirectTracer, handleUserAgentExtractor, } from "./handlers/smart-data-extractors.js";
+import { handleHtmlElementsExtractor, handleTagsFinder, handleLinksFinder, handleXpathLinks, handleAjaxExtractor, handleFetchXHR, handleNetworkRecorder, handleRegexPatternFinder, handleIframeExtractor, handleEmbedPageExtractor, handleImageExtractorAdvanced, handleVideoSourceExtractor, handleUrlRedirectTracer, handleUserAgentExtractor, } from "./handlers/smart-data-extractors.js";
 // Import dynamic session handlers
 import { handleShadowDOMExtractor, handleCookieManager, handleFormAutoFill, handleAjaxContentWaiter, } from "./handlers/dynamic-session-handlers.js";
 // Import monitoring & reporting handlers
@@ -276,15 +276,6 @@ export async function executeToolByName(name, args) {
             case "video_source_extractor":
                 result = await handleVideoSourceExtractor(args || {});
                 break;
-            case "video_player_extractor":
-                result = await handleVideoPlayerExtractor(args || {});
-                break;
-            case "video_player_hoster_finder":
-                result = await handleVideoPlayerHosterFinder(args || {});
-                break;
-            case "original_video_hoster_finder":
-                result = await handleOriginalVideoHosterFinder(args || {});
-                break;
             case "url_redirect_tracer":
                 result = await handleUrlRedirectTracer(args);
                 break;

package/dist/tool-definitions.js

@@ -868,38 +868,6 @@ export const TOOLS = [
             },
         },
     },
-    {
-        name: 'video_source_extractor',
-        description: 'Extract video sources from video elements',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'video_player_extractor',
-        description: 'Extract video player information',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'video_player_hoster_finder',
-        description: 'Detect video hosting platform (YouTube, Vimeo, etc.)',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'original_video_hoster_finder',
-        description: 'Find original video source',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
     {
         name: 'url_redirect_tracer',
         description: 'Trace URL redirects',
@@ -1155,16 +1123,6 @@ export const TOOLS = [
             }
         }
     },
-    {
-        name: 'redirect_tracer',
-        description: 'Trace URL redirects to find final destination',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' }
-            }
-        }
-    },
     {
         name: 'video_download_link_finder',
         description: 'Find direct download links for video files',
@@ -1231,7 +1189,6 @@ export const TOOL_NAMES = {
     VIDEO_SOURCE_EXTRACTOR: 'video_source_extractor',
     VIDEO_PLAYER_FINDER: 'video_player_finder',
     STREAM_DETECTOR: 'stream_detector',
-    REDIRECT_TRACER: 'redirect_tracer',
     // Search & Filter Tools
     KEYWORD_SEARCH: 'keyword_search',
     REGEX_PATTERN_MATCHER: 'regex_pattern_matcher',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.15.1",
+  "version": "2.15.3",
   "description": "Universal AI IDE MCP Server - Auto-detects and supports all AI IDEs (Claude Desktop, Cursor, Windsurf, Cline, Zed, VSCode, Qoder AI, etc.) with Brave browser automation",
   "type": "module",
   "main": "dist/index.js",
@@ -10,7 +10,7 @@
     "clean": "rimraf dist",
     "clean:cache": "npm cache clean --force",
     "fix-cache-permissions": "echo 'Run: sudo chown -R $(whoami):$(id -gn) ~/.npm' && echo 'This fixes npm cache permission issues'",
-    "clean:modules": "rm -rf node_modules",
+    "clean:modules": "rimraf node_modules",
     "clean:all": "npm run clean:modules && npm run clean:cache && npm run clean",
     "fresh-install": "npm run clean:all && npm install",
     "fresh-start": "npm run fresh-install && npm run build && npm start",

package/dist/handlers/APPLY_OPTIMIZATION_PATTERN.js

@@ -1,326 +0,0 @@
-// 🚀 APPLY THIS PATTERN TO ALL 113 TOOLS
-// This file shows the EXACT pattern to apply to every tool handler
-// Copy-paste and customize for each tool
-import { getCurrentPage } from '../browser-manager.js';
-import { validateWorkflow } from '../workflow-validation.js';
-import { TOOL_OPTIMIZATION_CONFIG, globalCache, deduplicateResults, executeToolWithOptimizations, VIDEO_HOSTERS_DB, SELECTOR_UTILS, globalMetrics, globalToolStatus, createErrorHandler, } from '../optimization-utils.js';
-import { sleep } from '../system-utils.js';
-/**
- * ✅ TEMPLATE: Universal Pattern for ALL 113 Tools
- *
- * Replace:
- * - TOOL_NAME: Actual tool name (e.g., 'ajax_extractor')
- * - CATEGORY: Category from TOOL_OPTIMIZATION_CONFIG
- * - TIMEOUT: Duration value from TOOL_OPTIMIZATION_CONFIG.xxx.defaultTimeout
- * - CACHE_KEY: Unique key for caching (usually based on URL + params)
- */
-export async function handleUNIVERSAL_TOOL_TEMPLATE(args) {
-    const toolName = 'TOOL_NAME'; // ← REPLACE with actual tool name
-    const errorHandler = createErrorHandler(toolName);
-    globalMetrics.start(toolName);
-    try {
-        // Validate workflow
-        validateWorkflow(toolName, {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        // Get timeout from configuration (example)
-        const timeout = args.timeout || TOOL_OPTIMIZATION_CONFIG.dataExtraction.defaultTimeout;
-        const shouldCache = args.cache !== false;
-        const cacheKey = `${toolName}_${args.url || 'default'}`;
-        // Check cache first
-        if (shouldCache) {
-            const cached = globalCache.get(cacheKey);
-            if (cached) {
-                console.error(`[${toolName}] Cache hit for key: ${cacheKey}`);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `✅ ${toolName} (from cache)\n\n${JSON.stringify(cached, null, 2)}`,
-                        },
-                    ],
-                };
-            }
-        }
-        // ======================================================
-        // YOUR ORIGINAL TOOL LOGIC GOES HERE
-        // ======================================================
-        const page = getCurrentPage();
-        let results = [];
-        // Example: Basic extraction logic
-        // Replace this with your actual tool implementation
-        results = await page.evaluate(() => {
-            // Your extraction logic here
-            return [];
-        });
-        // ======================================================
-        // OPTIMIZATION LAYER (Apply to all results)
-        // ======================================================
-        // 1. Deduplicate results
-        if (Array.isArray(results)) {
-            results = deduplicateResults(results, 'url'); // Use 'url' or your unique key
-        }
-        // 2. Filter empty/invalid results
-        results = results.filter((r) => r && Object.keys(r).length > 0);
-        // 3. Cache results if enabled
-        if (shouldCache && results.length > 0) {
-            globalCache.set(cacheKey, results);
-        }
-        // ======================================================
-        // RETURN OPTIMIZED RESULT
-        // ======================================================
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ ${toolName}\nFound ${results.length} results\n\n${JSON.stringify(results, null, 2)}`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        // Enhanced error handling
-        return errorHandler.handle(error, 'tool execution');
-    }
-    finally {
-        // Cleanup and metrics
-        const duration = globalMetrics.end(toolName);
-        globalToolStatus.recordExecution(toolName, duration);
-        console.error(`[${toolName}] Execution time: ${duration}ms`);
-    }
-}
-// ============================================================================
-// SPECIFIC OPTIMIZATION PATTERNS FOR EACH TOOL CATEGORY
-// ============================================================================
-/**
- * 🎥 VIDEO EXTRACTION TOOLS (20+ tools)
- *
- * Pattern: Use VIDEO_HOSTERS_DB, extended timeout, deep iframe scanning
- */
-export async function handleVideoExtractionTemplate(args) {
-    const toolName = 'video_extraction_tool';
-    const errorHandler = createErrorHandler(toolName);
-    globalMetrics.start(toolName);
-    try {
-        const page = getCurrentPage();
-        const timeout = args.timeout || TOOL_OPTIMIZATION_CONFIG.videoExtraction.defaultTimeout;
-        const videoData = await executeToolWithOptimizations(toolName, async () => {
-            let videos = [];
-            // Use optimized selectors
-            videos = await page.evaluate((videoSelectors) => {
-                return Array.from(document.querySelectorAll(videoSelectors.join(','))).map((el) => ({
-                    type: el.tagName.toLowerCase(),
-                    src: el.src || el.getAttribute('data-src') || el.getAttribute('href'),
-                    hoster: null,
-                    platform: null,
-                }));
-            }, SELECTOR_UTILS.videoSelectors);
-            // Detect video hosters
-            videos = videos.map((video) => ({
-                ...video,
-                hoster: VIDEO_HOSTERS_DB.getHosterName(video.src),
-            }));
-            // Deduplicate
-            videos = deduplicateResults(videos, 'src');
-            // Filter by hoster if needed
-            if (args.filterByHoster) {
-                videos = videos.filter((v) => v.hoster !== null);
-            }
-            return videos;
-        }, {
-            timeout,
-            retryAttempts: 2,
-            cacheKey: `videos_${page.url()}`,
-            shouldCache: true,
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `🎥 Found ${videoData.length} video sources\n\n${JSON.stringify(videoData, null, 2)}`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return errorHandler.handle(error, 'video extraction');
-    }
-    finally {
-        const duration = globalMetrics.end(toolName);
-        globalToolStatus.recordExecution(toolName, duration);
-    }
-}
-/**
- * ⏱️ NETWORK MONITORING TOOLS (ajax_extractor, fetch_xhr, network_recorder)
- *
- * Pattern: Extended duration, retry logic, comprehensive request capture
- */
-export async function handleNetworkMonitoringTemplate(args) {
-    const toolName = 'network_monitoring_tool';
-    const errorHandler = createErrorHandler(toolName);
-    globalMetrics.start(toolName);
-    try {
-        const page = getCurrentPage();
-        const duration = args.duration || TOOL_OPTIMIZATION_CONFIG.networkMonitoring.defaultDuration;
-        const networkData = await executeToolWithOptimizations(toolName, async () => {
-            const requests = [];
-            const requestHandler = (request) => {
-                const resourceType = request.resourceType();
-                if (resourceType === 'xhr' || resourceType === 'fetch') {
-                    requests.push({
-                        url: request.url(),
-                        method: request.method(),
-                        type: resourceType,
-                        timestamp: new Date().toISOString(),
-                    });
-                }
-            };
-            page.on('request', requestHandler);
-            // Monitor for configured duration
-            await sleep(duration);
-            page.off('request', requestHandler);
-            // Deduplicate requests
-            return deduplicateResults(requests, 'url');
-        }, {
-            timeout: TOOL_OPTIMIZATION_CONFIG.networkMonitoring.monitoringTimeout,
-            retryAttempts: 3,
-            cacheKey: `network_${Date.now() / 60000}`, // Cache per minute
-            shouldCache: false, // Don't cache network data
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `📡 Captured ${networkData.length} network requests\n\n${JSON.stringify(networkData, null, 2)}`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return errorHandler.handle(error, 'network monitoring');
-    }
-    finally {
-        const duration = globalMetrics.end(toolName);
-        globalToolStatus.recordExecution(toolName, duration);
-    }
-}
-/**
- * 📊 DATA EXTRACTION TOOLS (scrape_table, extract_links, extract_images, etc.)
- *
- * Pattern: Deep scanning, result deduplication, background-image extraction
- */
-export async function handleDataExtractionTemplate(args) {
-    const toolName = 'data_extraction_tool';
-    const errorHandler = createErrorHandler(toolName);
-    globalMetrics.start(toolName);
-    try {
-        const page = getCurrentPage();
-        const selector = args.selector || '*';
-        const deepScan = args.deepScan ?? TOOL_OPTIMIZATION_CONFIG.dataExtraction.deepScanEnabled;
-        const extractedData = await executeToolWithOptimizations(toolName, async () => {
-            let results = [];
-            // Primary extraction
-            results = await page.evaluate((sel, deep) => {
-                const data = [];
-                // Standard extraction
-                document.querySelectorAll(sel).forEach((el, idx) => {
-                    data.push({
-                        index: idx,
-                        tag: el.tagName.toLowerCase(),
-                        text: el.textContent?.trim().substring(0, 100),
-                        attributes: Array.from(el.attributes || []).reduce((acc, attr) => {
-                            acc[attr.name] = attr.value;
-                            return acc;
-                        }, {}),
-                    });
-                });
-                // Deep scan if enabled
-                if (deep && data.length < 1000) {
-                    // Scan hidden elements, data attributes, etc.
-                    document.querySelectorAll('[data-*]').forEach((el) => {
-                        Object.keys(el.dataset || {}).forEach((key) => {
-                            data.push({
-                                type: 'data-attribute',
-                                key,
-                                value: el.dataset[key],
-                            });
-                        });
-                    });
-                }
-                return data;
-            }, selector, deepScan);
-            // Deduplicate
-            results = deduplicateResults(results);
-            // Filter empty
-            results = results.filter((r) => r && Object.keys(r).length > 0);
-            return results;
-        }, {
-            timeout: TOOL_OPTIMIZATION_CONFIG.dataExtraction.defaultTimeout,
-            retryAttempts: 2,
-            cacheKey: `data_${page.url()}_${selector}`,
-            shouldCache: true,
-        });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `📋 Extracted ${extractedData.length} items\n\n${JSON.stringify(extractedData.slice(0, 20), null, 2)}`,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return errorHandler.handle(error, 'data extraction');
-    }
-    finally {
-        const duration = globalMetrics.end(toolName);
-        globalToolStatus.recordExecution(toolName, duration);
-    }
-}
-// ============================================================================
-// IMPLEMENTATION INSTRUCTIONS
-// ============================================================================
-/**
- * TO APPLY THIS OPTIMIZATION PATTERN TO ALL 113 TOOLS:
- *
- * 1. For EACH tool handler function:
- *    - Add imports from optimization-utils at top of file
- *    - Wrap main logic with try-catch-finally
- *    - Add globalMetrics.start() and end() calls
- *    - Apply deduplicateResults() to list outputs
- *    - Use appropriate TOOL_OPTIMIZATION_CONFIG value
- *
- * 2. For VIDEO tools specifically:
- *    - Use handleVideoExtractionTemplate pattern
- *    - Replace hardcoded selectors with SELECTOR_UTILS.videoSelectors
- *    - Use VIDEO_HOSTERS_DB for hoster detection
- *
- * 3. For NETWORK tools specifically:
- *    - Use handleNetworkMonitoringTemplate pattern
- *    - Extend duration to TOOL_OPTIMIZATION_CONFIG.networkMonitoring.defaultDuration
- *    - Add retry logic for failed captures
- *
- * 4. For DATA tools specifically:
- *    - Use handleDataExtractionTemplate pattern
- *    - Enable deep scanning with TOOL_OPTIMIZATION_CONFIG.dataExtraction.deepScanEnabled
- *    - Always deduplicate before returning results
- *
- * 5. Test each optimized tool:
- *    - Verify it still works with original functionality
- *    - Check success rate > 95%
- *    - Verify deduplication works (no duplicate results)
- *    - Check caching is effective
- *
- * 6. After completing ALL 113 tools:
- *    - Run: npm run build
- *    - Run: npm run test
- *    - Run: npm run lint:fix
- *    - Commit with: git commit -m "✅ Optimize ALL 113 MCP tools for production"
- */
-export default {
-    handleUNIVERSAL_TOOL_TEMPLATE,
-    handleVideoExtractionTemplate,
-    handleNetworkMonitoringTemplate,
-    handleDataExtractionTemplate,
-};

package/dist/handlers/advanced-scraping-handlers.js

@@ -1,58 +0,0 @@
-import { getPageInstance } from '../browser-manager.js';
-export async function handleMultiPageScraper(args) {
-    const page = getPageInstance();
-    if (!page)
-        throw new Error('Browser not initialized. Use browser_init first.');
-    const results = [];
-    const errors = [];
-    for (const url of args.urls) {
-        try {
-            await page.goto(url, { waitUntil: 'domcontentloaded' });
-            if (args.waitBetweenPages) {
-                await new Promise(resolve => setTimeout(resolve, args.waitBetweenPages));
-            }
-            const data = await page.evaluate((selector) => {
-                const elements = document.querySelectorAll(selector);
-                return Array.from(elements).map(el => el.textContent?.trim()).filter(Boolean);
-            }, args.dataSelector);
-            results.push({ url, data, success: true });
-        }
-        catch (error) {
-            errors.push({ url, error: String(error) });
-            results.push({ url, success: false, error: String(error) });
-        }
-    }
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify({ summary: `Scraped ${results.length} pages`, results, errors }, null, 2)
-            }]
-    };
-}
-export async function handleBreadcrumbNavigator(args) {
-    const page = getPageInstance();
-    if (!page)
-        throw new Error('Browser not initialized. Use browser_init first.');
-    const breadcrumbs = await page.evaluate((selector) => {
-        const elements = document.querySelectorAll(selector);
-        return Array.from(elements).map(el => ({
-            text: el.textContent?.trim() || '',
-            href: el.href || null
-        }));
-    }, args.breadcrumbSelector);
-    let navigationResult = null;
-    if (args.followLinks && breadcrumbs.length > 0) {
-        // Navigate to parent (second to last)
-        const parent = breadcrumbs.length > 1 ? breadcrumbs[breadcrumbs.length - 2] : null;
-        if (parent && parent.href) {
-            await page.goto(parent.href);
-            navigationResult = `Navigated to parent: ${parent.text} (${parent.href})`;
-        }
-    }
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify({ breadcrumbs, navigationResult }, null, 2)
-            }]
-    };
-}

package/dist/handlers/data-transform-handlers.js

@@ -1,66 +0,0 @@
-import TurndownService from 'turndown';
-export async function handleHtmlToText(args) {
-    try {
-        const turndownService = new TurndownService({
-            headingStyle: 'atx',
-            codeBlockStyle: 'fenced'
-        });
-        // Config based on args
-        if (!args.preserveLinks) {
-            turndownService.addRule('no-links', {
-                filter: 'a',
-                replacement: function (content) { return content; }
-            });
-        }
-        const text = turndownService.turndown(args.html);
-        return {
-            content: [{
-                    type: 'text',
-                    text: text
-                }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{
-                    type: 'text',
-                    text: `Error converting HTML to text: ${error}`
-                }],
-            isError: true
-        };
-    }
-}
-export async function handleDuplicateRemover(args) {
-    if (!Array.isArray(args.data)) {
-        throw new Error("Input 'data' must be an array.");
-    }
-    let uniqueData;
-    if (args.uniqueKey) {
-        const seen = new Set();
-        uniqueData = args.data.filter(item => {
-            const val = item[args.uniqueKey];
-            if (seen.has(val))
-                return false;
-            seen.add(val);
-            return true;
-        });
-    }
-    else {
-        // Deep equality check or simple JSON stringify check?
-        // Use JSON stringify for simplicity and speed on complex objects
-        const seen = new Set();
-        uniqueData = args.data.filter(item => {
-            const val = JSON.stringify(item);
-            if (seen.has(val))
-                return false;
-            seen.add(val);
-            return true;
-        });
-    }
-    return {
-        content: [{
-                type: 'text',
-                text: JSON.stringify(uniqueData, null, 2)
-            }]
-    };
-}