brave-real-browser-mcp-server 2.17.11 → 2.17.13

package/dist/tool-definitions.js

@@ -237,17 +237,33 @@ export const TOOLS = [
     },
     {
         name: 'solve_captcha',
-        description: 'Attempt to solve CAPTCHAs (if supported)',
+        description: 'Solve various types of CAPTCHAs (Auto-detect, OCR, Audio, Puzzle). Routes to appropriate solver based on arguments.',
         inputSchema: {
             type: 'object',
             properties: {
-                type: {
+                strategy: {
                     type: 'string',
-                    enum: ['recaptcha', 'hCaptcha', 'turnstile'],
-                    description: 'Type of captcha to solve',
+                    enum: ['auto', 'ocr', 'audio', 'puzzle', 'recaptcha', 'hCaptcha', 'turnstile'],
+                    description: 'Strategy to use. "auto" attempts to infer based on provided arguments.',
+                    default: 'auto'
                 },
+                // Shared
+                url: { type: 'string' },
+                // OCR
+                selector: { type: 'string' },
+                imageUrl: { type: 'string' },
+                imageBuffer: { type: 'string' },
+                language: { type: 'string' },
+                // Audio
+                audioSelector: { type: 'string' },
+                audioUrl: { type: 'string' },
+                downloadPath: { type: 'string' },
+                // Puzzle
+                puzzleSelector: { type: 'string' },
+                sliderSelector: { type: 'string' },
+                method: { type: 'string' },
             },
-            required: ['type'],
+            required: [],
         },
     },
     {
@@ -451,115 +467,60 @@ export const TOOLS = [
         },
     },
     // Search & Filter Tools (5 tools)
+    // Search & Filter Tools (Consolidated)
     {
-        name: 'keyword_search',
-        description: 'Advanced keyword search in page content',
+        name: 'search_content',
+        description: 'Search content using keywords or regex patterns.',
         inputSchema: {
             type: 'object',
             properties: {
+                query: { type: 'string', description: 'Keyword or Regex pattern' },
+                type: { type: 'string', enum: ['text', 'regex'], default: 'text' },
                 url: { type: 'string' },
-                keywords: { type: 'array', items: { type: 'string' } },
+                // Text options
                 caseSensitive: { type: 'boolean', default: false },
                 wholeWord: { type: 'boolean', default: false },
                 context: { type: 'number', default: 50 },
-            },
-            required: ['keywords'],
-        },
-    },
-    {
-        name: 'regex_pattern_matcher',
-        description: 'Search using regular expressions',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' },
-                pattern: { type: 'string', description: 'Regular expression pattern' },
+                // Regex options
                 flags: { type: 'string', default: 'g' },
-                selector: { type: 'string' },
+                selector: { type: 'string', description: 'Limit search to specific element' },
             },
-            required: ['pattern'],
+            required: ['query'],
         },
     },
     {
-        name: 'xpath_support',
-        description: 'Query elements using XPath',
+        name: 'find_element_advanced',
+        description: 'Find elements using XPath or Advanced CSS selectors.',
         inputSchema: {
             type: 'object',
             properties: {
+                query: { type: 'string', description: 'Selector or XPath expression' },
+                type: { type: 'string', enum: ['css', 'xpath'], default: 'css' },
                 url: { type: 'string' },
-                xpath: { type: 'string', description: 'XPath expression' },
-                returnType: { type: 'string', default: 'elements' },
-            },
-            required: ['xpath'],
-        },
-    },
-    {
-        name: 'advanced_css_selectors',
-        description: 'Support for complex CSS selectors',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' },
-                selector: { type: 'string' },
+                // CSS options
                 operation: { type: 'string', enum: ['query', 'closest', 'matches'], default: 'query' },
-                returnType: { type: 'string', default: 'elements' },
+                // Shared
+                returnType: { type: 'string', enum: ['elements', 'styles', 'html'], default: 'elements' },
             },
-            required: ['selector'],
+            required: ['query'],
         },
     },
     // Data Quality & Validation (5 tools)
+    // Deep Analysis Tool -- Trace Recording
     {
-        name: 'data_type_validator',
-        description: 'Validate data types against JSON schema',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                data: { description: 'Data to validate' },
-                schema: { type: 'object', description: 'JSON Schema' },
-            },
-            required: ['data', 'schema'],
-        },
-    },
-    // Advanced Captcha Handling (3 tools)
-    {
-        name: 'ocr_engine',
-        description: 'Extract text from captcha images using OCR',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' },
-                selector: { type: 'string' },
-                imageUrl: { type: 'string' },
-                imageBuffer: { type: 'string', description: 'Base64 encoded image' },
-                language: { type: 'string', default: 'eng' },
-            },
-        },
-    },
-    {
-        name: 'audio_captcha_solver',
-        description: 'Handle audio captchas',
+        name: 'deep_analysis',
+        description: 'Perform a deep analysis of the page including network traces, console logs, DOM snapshot, and screenshot. Equivalent to a trace recording.',
         inputSchema: {
             type: 'object',
             properties: {
                 url: { type: 'string' },
-                audioSelector: { type: 'string' },
-                audioUrl: { type: 'string' },
-                downloadPath: { type: 'string' },
-            },
-        },
-    },
-    {
-        name: 'puzzle_captcha_handler',
-        description: 'Handle slider and puzzle captchas',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' },
-                puzzleSelector: { type: 'string' },
-                sliderSelector: { type: 'string' },
-                method: { type: 'string', enum: ['auto', 'manual'], default: 'auto' },
-            },
-        },
+                duration: { type: 'number', default: 5000, description: 'Duration to record (ms)' },
+                screenshots: { type: 'boolean', default: true },
+                network: { type: 'boolean', default: true },
+                logs: { type: 'boolean', default: true },
+                dom: { type: 'boolean', default: true }
+            }
+        }
     },
     // Screenshot & Visual Tools (5 tools)
     {
@@ -745,17 +706,17 @@ export const TOOL_NAMES = {
     SMART_SELECTOR_GENERATOR: 'smart_selector_generator',
     CONTENT_CLASSIFICATION: 'content_classification',
     // Phase 3: Media & Video
-    // Search & Filter Tools
-    KEYWORD_SEARCH: 'keyword_search',
-    REGEX_PATTERN_MATCHER: 'regex_pattern_matcher',
-    XPATH_SUPPORT: 'xpath_support',
-    ADVANCED_CSS_SELECTORS: 'advanced_css_selectors',
+    // Search & Filter (Consolidated)
+    SEARCH_CONTENT: 'search_content',
+    FIND_ELEMENT_ADVANCED: 'find_element_advanced',
+    // Deep Analysis
+    DEEP_ANALYSIS: 'deep_analysis',
     // Data Quality & Validation
-    DATA_TYPE_VALIDATOR: 'data_type_validator',
-    // Advanced Captcha Handling
-    OCR_ENGINE: 'ocr_engine',
-    AUDIO_CAPTCHA_SOLVER: 'audio_captcha_solver',
-    PUZZLE_CAPTCHA_HANDLER: 'puzzle_captcha_handler',
+    // (Removed DATA_TYPE_VALIDATOR)
+    // Advanced Captcha Handling (Consolidated)
+    // OCR_ENGINE: 'ocr_engine', // Merged into solve_captcha
+    // AUDIO_CAPTCHA_SOLVER: 'audio_captcha_solver', // Merged
+    // PUZZLE_CAPTCHA_HANDLER: 'puzzle_captcha_handler', // Merged
     // Screenshot & Visual Tools
     ELEMENT_SCREENSHOT: 'element_screenshot',
     VIDEO_RECORDING: 'video_recording',

package/dist/workflows/forensic-media-extractor.js

@@ -3,7 +3,7 @@ import { handleNavigate } from '../handlers/navigation-handlers.js';
 import { handleAdProtectionDetector, handleAdvancedVideoExtraction } from '../handlers/advanced-extraction-handlers.js';
 import { handleSmartSelectorGenerator } from '../handlers/ai-powered-handlers.js';
 import { handleNetworkRecorder, handleApiFinder } from '../handlers/smart-data-extractors.js';
-import { handleRegexPatternMatcher } from '../handlers/search-filter-handlers.js';
+import { handleSearchContent } from '../handlers/unified-search-handler.js';
 import { handleRandomScroll } from '../handlers/interaction-handlers.js';
 async function main() {
     const targetUrl = "https://multimovies.golf/movies/120-bahadur/";
@@ -70,7 +70,7 @@ async function main() {
         ];
         report.infrastructure.patterns = [];
         for (const check of regexChecks) {
-            const match = await handleRegexPatternMatcher({ pattern: check.pattern });
+            const match = await handleSearchContent({ query: check.pattern, type: 'regex' });
             if (match && match.content) {
                 report.infrastructure.patterns.push({ type: check.name, result: match.content });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.17.11",
+  "version": "2.17.13",
   "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",

package/dist/handlers/captcha-handlers.js

@@ -1,257 +0,0 @@
-// @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
- */
-export async function handleOCREngine(args) {
-    const { url, selector, imageUrl, imageBuffer, language = 'eng' } = args;
-    try {
-        let imageSource;
-        if (imageBuffer) {
-            imageSource = Buffer.from(imageBuffer, 'base64');
-        }
-        else if (imageUrl) {
-            imageSource = imageUrl;
-        }
-        else if (selector) {
-            const page = getPageInstance();
-            if (!page) {
-                throw new Error('Browser not initialized. Call browser_init first.');
-            }
-            if (url && page.url() !== url) {
-                await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-            }
-            // Get image element and take screenshot
-            const element = await page.$(selector);
-            if (!element) {
-                throw new Error(`Element not found: ${selector}`);
-            }
-            const screenshot = await element.screenshot({ encoding: 'base64' });
-            imageSource = Buffer.from(screenshot, 'base64');
-        }
-        else {
-            throw new Error('No image source provided');
-        }
-        // Perform OCR
-        const result = await Tesseract.recognize(imageSource, language, {
-            logger: () => { } // Suppress logs
-        });
-        // Clean and process text
-        const text = result.data.text.trim();
-        const confidence = result.data.confidence;
-        // Extract words with their confidence
-        const words = result.data.words.map(word => ({
-            text: word.text,
-            confidence: word.confidence,
-            bbox: word.bbox
-        }));
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `OCR Results:\n- Extracted Text: ${text}\n- Confidence: ${confidence.toFixed(2)}%\n- Words Found: ${words.length}\n- Lines: ${result.data.lines.length}\n- Language: ${language}\n\nWords Detail:\n${words.map((w) => `  "${w.text}" (confidence: ${w.confidence.toFixed(2)}%)`).join('\n')}`
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `OCR Engine Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}
-/**
- * Audio Captcha Solver - Handle audio captchas
- */
-export async function handleAudioCaptchaSolver(args) {
-    const { url, audioSelector, audioUrl, downloadPath } = args;
-    try {
-        const page = getPageInstance();
-        if (!page) {
-            throw new Error('Browser not initialized. Call browser_init first.');
-        }
-        if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        }
-        let audioSource = audioUrl;
-        // If selector provided, extract audio URL
-        if (audioSelector && !audioUrl) {
-            audioSource = await page.evaluate((sel) => {
-                const element = document.querySelector(sel);
-                if (!element)
-                    return null;
-                if (element.tagName === 'AUDIO') {
-                    return element.src || element.currentSrc;
-                }
-                else if (element.tagName === 'SOURCE') {
-                    return element.src;
-                }
-                return element.getAttribute('src') || element.getAttribute('data-src');
-            }, audioSelector);
-        }
-        if (!audioSource) {
-            throw new Error('No audio source found');
-        }
-        // Download audio if path provided
-        let downloaded = false;
-        if (downloadPath) {
-            const response = await page.goto(audioSource);
-            if (response) {
-                const fs = await import('fs/promises');
-                const buffer = await response.buffer();
-                await fs.writeFile(downloadPath, buffer);
-                downloaded = true;
-            }
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Audio Captcha Analysis:\n- Audio URL: ${audioSource}\n- Downloaded: ${downloaded ? 'Yes' : 'No'}${downloaded ? `\n- Download Path: ${downloadPath}` : ''}\n\nNote: Audio captcha solving requires external speech-to-text API (Google Speech, AWS Transcribe, etc.)`
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Audio Captcha Solver Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}
-/**
- * Puzzle Captcha Handler - Handle slider and puzzle captchas
- */
-export async function handlePuzzleCaptchaHandler(args) {
-    const { url, puzzleSelector, sliderSelector, method = 'auto' } = args;
-    try {
-        const page = getPageInstance();
-        if (!page) {
-            throw new Error('Browser not initialized. Call browser_init first.');
-        }
-        if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        }
-        const result = await page.evaluate(async (puzzleSel, sliderSel, meth) => {
-            const puzzleElement = puzzleSel ? document.querySelector(puzzleSel) : null;
-            const sliderElement = sliderSel ? document.querySelector(sliderSel) : null;
-            if (!puzzleElement && !sliderElement) {
-                throw new Error('No puzzle or slider element found');
-            }
-            const info = {
-                puzzleFound: !!puzzleElement,
-                sliderFound: !!sliderElement
-            };
-            // Get puzzle dimensions if exists
-            if (puzzleElement) {
-                const rect = puzzleElement.getBoundingClientRect();
-                info.puzzle = {
-                    width: rect.width,
-                    height: rect.height,
-                    top: rect.top,
-                    left: rect.left,
-                    visible: rect.width > 0 && rect.height > 0
-                };
-                // Check for puzzle piece
-                const puzzlePiece = puzzleElement.querySelector('.puzzle-piece, [class*="piece"], [class*="puzzle"]');
-                if (puzzlePiece) {
-                    const pieceRect = puzzlePiece.getBoundingClientRect();
-                    info.puzzlePiece = {
-                        width: pieceRect.width,
-                        height: pieceRect.height,
-                        top: pieceRect.top,
-                        left: pieceRect.left
-                    };
-                }
-            }
-            // Get slider info if exists
-            if (sliderElement) {
-                const rect = sliderElement.getBoundingClientRect();
-                info.slider = {
-                    width: rect.width,
-                    height: rect.height,
-                    top: rect.top,
-                    left: rect.left,
-                    visible: rect.width > 0 && rect.height > 0,
-                    tagName: sliderElement.tagName.toLowerCase()
-                };
-            }
-            return info;
-        }, puzzleSelector || '', sliderSelector || '', method);
-        // If auto method, attempt to solve
-        if (method === 'auto' && sliderSelector) {
-            try {
-                const sliderElement = await page.$(sliderSelector);
-                if (sliderElement) {
-                    const box = await sliderElement.boundingBox();
-                    if (box) {
-                        // Simulate drag - this is a basic implementation
-                        // Real puzzle solving would need image analysis
-                        await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
-                        await page.mouse.down();
-                        // Move in small increments
-                        const targetDistance = result.puzzle?.width || 300;
-                        const steps = 20;
-                        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 sleep(50 + Math.random() * 50); // Random delay for human-like behavior
-                        }
-                        await page.mouse.up();
-                        result.attemptedSolve = true;
-                        result.method = 'automated_drag';
-                    }
-                }
-            }
-            catch (solveError) {
-                result.solveError = solveError.message;
-            }
-        }
-        let summary = `Puzzle Captcha Analysis:\n- Puzzle Found: ${result.puzzleFound ? 'Yes' : 'No'}\n- Slider Found: ${result.sliderFound ? 'Yes' : 'No'}`;
-        if (result.puzzle) {
-            summary += `\n\nPuzzle Details:\n- Dimensions: ${result.puzzle.width}x${result.puzzle.height}\n- Position: (${result.puzzle.left}, ${result.puzzle.top})\n- Visible: ${result.puzzle.visible ? 'Yes' : 'No'}`;
-        }
-        if (result.puzzlePiece) {
-            summary += `\n\nPuzzle Piece:\n- Dimensions: ${result.puzzlePiece.width}x${result.puzzlePiece.height}\n- Position: (${result.puzzlePiece.left}, ${result.puzzlePiece.top})`;
-        }
-        if (result.slider) {
-            summary += `\n\nSlider Details:\n- Dimensions: ${result.slider.width}x${result.slider.height}\n- Position: (${result.slider.left}, ${result.slider.top})\n- Visible: ${result.slider.visible ? 'Yes' : 'No'}\n- Tag: ${result.slider.tagName}`;
-        }
-        if (result.attemptedSolve) {
-            summary += `\n\nSolve Attempt:\n- Method: ${result.method}\n- Status: ${result.solveError ? 'Failed' : 'Completed'}${result.solveError ? `\n- Error: ${result.solveError}` : ''}`;
-        }
-        summary += `\n\nNote: Advanced puzzle solving requires computer vision libraries (OpenCV, TensorFlow)`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Puzzle Captcha Handler Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}

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

@@ -1,82 +0,0 @@
-// @ts-nocheck
-import Ajv from 'ajv/dist/2020.js';
-const ajv = new Ajv();
-/**
- * Data Deduplication - Remove duplicate entries from scraped data
- */
-/**
- * Missing Data Handler - Detect and handle missing data
- */
-/**
- * Data Type Validator - Validate data types against schema
- */
-export async function handleDataTypeValidator(args) {
-    const { data, schema } = args;
-    try {
-        if (!schema) {
-            throw new Error('Schema is required');
-        }
-        const validate = ajv.compile(schema);
-        const validItems = [];
-        const invalidItems = [];
-        if (Array.isArray(data)) {
-            data.forEach((item, index) => {
-                const valid = validate(item);
-                if (valid) {
-                    validItems.push(item);
-                }
-                else {
-                    invalidItems.push({
-                        item,
-                        index,
-                        errors: validate.errors
-                    });
-                }
-            });
-        }
-        else {
-            const valid = validate(data);
-            if (valid) {
-                validItems.push(data);
-            }
-            else {
-                invalidItems.push({
-                    item: data,
-                    errors: validate.errors
-                });
-            }
-        }
-        const total = Array.isArray(data) ? data.length : 1;
-        const validationRate = ((validItems.length / total) * 100).toFixed(2);
-        let summary = `Data Type Validation Results:\n\nStatistics:\n- Total Items: ${total}\n- Valid Items: ${validItems.length}\n- Invalid Items: ${invalidItems.length}\n- Validation Rate: ${validationRate}%`;
-        if (invalidItems.length > 0) {
-            summary += `\n\nInvalid Items (Top 5):\n${invalidItems.slice(0, 5).map((inv, i) => {
-                const errorMsgs = inv.errors?.map((e) => `${e.instancePath || 'root'}: ${e.message}`).join(', ') || 'Unknown error';
-                return `${i + 1}. Index ${inv.index || 'N/A'}:\n   Errors: ${errorMsgs}`;
-            }).join('\n')}`;
-        }
-        summary += `\n\nSchema: ${JSON.stringify(schema, null, 2).substring(0, 200)}${JSON.stringify(schema).length > 200 ? '...' : ''}`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Data Type Validator Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}
-/**
- * Consistency Checker - Check data consistency across fields
- */