brave-real-browser-mcp-server 2.17.10 → 2.17.12

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: [],
         },
     },
     {
@@ -336,18 +352,6 @@ export const TOOLS = [
     },
     // Smart Data Extractors
     // DOM & HTML Extraction (Phase 1)
-    {
-        name: 'html_elements_extractor',
-        description: 'Extract detailed information about HTML elements matching a selector',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string', default: '*' },
-                maxElements: { type: 'number', default: 100 },
-                includeStyles: { type: 'boolean', default: false },
-            },
-        },
-    },
     {
         name: 'extract_json',
         description: 'Extract embedded JSON/API data from the page',
@@ -398,19 +402,6 @@ export const TOOLS = [
             required: ['selector'],
         },
     },
-    {
-        name: 'attribute_harvester',
-        description: 'Collect attributes (href, src, data-*) from elements',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string' },
-                attributes: { type: 'array', items: { type: 'string' } },
-                maxElements: { type: 'number', default: 100 },
-            },
-            required: ['selector'],
-        },
-    },
     // Content Type Specific Extractors
     {
         name: 'link_harvester',
@@ -476,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',
+        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' },
-                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',
-        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)
     {
@@ -616,16 +552,6 @@ export const TOOLS = [
         },
     },
     // Smart Data Extractors (Advanced)
-    {
-        name: 'fetch_xhr',
-        description: 'Capture fetch and XHR requests with responses',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                duration: { type: 'number', default: 15000 },
-            },
-        },
-    },
     {
         name: 'network_recorder',
         description: 'Record all network activity',
@@ -713,14 +639,6 @@ export const TOOLS = [
             },
         },
     },
-    {
-        name: 'deobfuscate_js',
-        description: 'Deobfuscate JavaScript code and extract hidden URLs, domains, and base64-encoded content. Detects eval, atob, hex encoding, and identifier obfuscation.',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
     {
         name: 'multi_layer_redirect_trace',
         description: 'Follow multiple layers of redirects (URL redirects and iframe chains) to find final video source. Traces up to specified depth.',
@@ -754,46 +672,6 @@ export const TOOLS = [
         },
     },
     // Phase 3: Media & Video Tools
-    {
-        name: 'video_source_extractor',
-        description: 'Extract raw video sources from video tags and sources',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' }
-            }
-        }
-    },
-    {
-        name: 'video_player_finder',
-        description: 'Identify video players (JWPlayer, VideoJS, etc) and extract config',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                url: { type: 'string' }
-            }
-        }
-    },
-    {
-        name: 'stream_detector',
-        description: 'Detects HLS (m3u8) and DASH (mpd) streams from network traffic',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                duration: { type: 'number', description: 'Monitoring duration in ms' }
-            }
-        }
-    },
-    {
-        name: 'video_download_link_finder',
-        description: 'Find direct download links for video files',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                extensions: { type: 'array', items: { type: 'string' } }
-            }
-        }
-    }
 ];
 // Tool name constants for type safety
 export const TOOL_NAMES = {
@@ -814,14 +692,11 @@ export const TOOL_NAMES = {
     EXTRACT_SCHEMA: 'extract_schema',
     // Multi-Element Extractors
     BATCH_ELEMENT_SCRAPER: 'batch_element_scraper',
-    ATTRIBUTE_HARVESTER: 'attribute_harvester',
     // Content Type Specific
     LINK_HARVESTER: 'link_harvester',
     MEDIA_EXTRACTOR: 'media_extractor',
     // DOM & HTML Extraction (Phase 1)
-    HTML_ELEMENTS_EXTRACTOR: 'html_elements_extractor',
     // Network Tools (Phase 1)
-    FETCH_XHR: 'fetch_xhr',
     NETWORK_RECORDER: 'network_recorder',
     API_FINDER: 'api_finder',
     // Pagination Tools
@@ -831,20 +706,17 @@ export const TOOL_NAMES = {
     SMART_SELECTOR_GENERATOR: 'smart_selector_generator',
     CONTENT_CLASSIFICATION: 'content_classification',
     // Phase 3: Media & Video
-    VIDEO_SOURCE_EXTRACTOR: 'video_source_extractor',
-    VIDEO_PLAYER_FINDER: 'video_player_finder',
-    STREAM_DETECTOR: 'stream_detector',
-    // 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

@@ -1,10 +1,9 @@
 import { handleBrowserInit } from '../handlers/browser-handlers.js';
 import { handleNavigate } from '../handlers/navigation-handlers.js';
-import { handleAdProtectionDetector, handleAdvancedVideoExtraction, handleDeobfuscateJS } from '../handlers/advanced-extraction-handlers.js';
-import { handleVideoDownloadLinkFinder } from '../handlers/advanced-video-media-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/";
@@ -48,15 +47,7 @@ async function main() {
         }
         // Logic Extraction (looking for player config)
         try {
-            const deobfuscated = await handleDeobfuscateJS({});
-            // Filter for relevant keys
-            if (deobfuscated && deobfuscated.content) {
-                const keyTerms = ['player', 'token', 'm3u8', 'mp4', 'config'];
-                const relevantScripts = deobfuscated.content
-                    .filter((c) => c.text && keyTerms.some(term => c.text.includes(term)))
-                    .map((c) => c.text.substring(0, 200) + "...");
-                report.infrastructure.event_handlers = relevantScripts;
-            }
+            console.log("Deobfuscation is now handled by Advanced Video Extraction.");
         }
         catch (e) {
             console.log("Deobfuscation skipped");
@@ -79,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 });
             }
@@ -91,8 +82,7 @@ async function main() {
         // Assuming videoAssets structure, we'd loop and add to report.targets
         // For now, dump the raw result
         report.targets_raw = videoAssets;
-        const downloadLinks = await handleVideoDownloadLinkFinder({});
-        report.download_links = downloadLinks;
+        report.download_links = "Handled by Advanced Video Extraction";
         console.log("--- MASTER REPORT JSON ---");
         console.log(JSON.stringify(report, null, 2));
         console.log("--- END REPORT ---");

package/dist/workflows/media-extraction-workflow.js

@@ -3,8 +3,7 @@ import { handleNavigate } from '../handlers/navigation-handlers.js';
 import { handleRandomScroll } from '../handlers/interaction-handlers.js';
 import { handleElementScreenshot } from '../handlers/visual-tools-handlers.js';
 import { handleNetworkRecorder } from '../handlers/smart-data-extractors.js';
-import { handleAdvancedVideoExtraction, handleDeobfuscateJS, handleAdProtectionDetector } from '../handlers/advanced-extraction-handlers.js';
-import { handleVideoDownloadLinkFinder } from '../handlers/advanced-video-media-handlers.js';
+import { handleAdvancedVideoExtraction, handleAdProtectionDetector } from '../handlers/advanced-extraction-handlers.js';
 async function main() {
     const targetUrl = process.argv[2];
     if (!targetUrl) {
@@ -45,9 +44,7 @@ async function main() {
     }
     // 6. Obfuscation Bypass
     if (!foundMedia) {
-        console.log("Deep Scan empty. Attempting Deobfuscation...");
-        const deobfuscated = await handleDeobfuscateJS({});
-        console.log("Deobfuscation Results:", deobfuscated);
+        console.log("Deep Scan empty. Deobfuscation is now handled by Advanced Video Extraction.");
     }
     // 7. Network Traffic
     if (!foundMedia) {
@@ -57,9 +54,7 @@ async function main() {
     }
     // Phase 3: Redirect & Link Validation
     console.log("\n--- Phase 3: Redirect & Link Validation ---");
-    console.log("Dumping page download links...");
-    const links = await handleVideoDownloadLinkFinder({});
-    console.log("Page Video Links:", links);
+    console.log("Direct download link finding is now integrated into Advanced Video Extraction.");
     // Phase 4: Fallback
     console.log("\n--- Phase 4: Fallback / Manual Aid ---");
     if (!foundMedia) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.17.10",
+  "version": "2.17.12",
   "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/advanced-video-media-handlers.js

@@ -1,139 +0,0 @@
-import { getPageInstance } from '../browser-manager.js';
-/**
- * Extract raw video sources from <video> tags and <source> elements
- */
-export async function handleVideoSourceExtractor(args) {
-    const { url } = args;
-    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: 'domcontentloaded' });
-    const sources = await page.evaluate(() => {
-        return Array.from(document.querySelectorAll('video')).map((v, i) => ({
-            index: i,
-            src: v.src,
-            currentSrc: v.currentSrc,
-            sources: Array.from(v.querySelectorAll('source')).map(s => ({ src: s.src, type: s.type })),
-            poster: v.poster
-        }));
-    });
-    return { content: [{ type: 'text', text: JSON.stringify(sources, null, 2) }] };
-}
-/**
- * Identify common video players and configuration
- */
-export async function handleVideoPlayerFinder(args) {
-    const { url } = args;
-    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: 'domcontentloaded' });
-    const players = await page.evaluate(() => {
-        const detected = [];
-        // @ts-ignore
-        if (window.jwplayer)
-            detected.push('JWPlayer');
-        // @ts-ignore
-        if (window.videojs)
-            detected.push('VideoJS');
-        // Check for iframes
-        document.querySelectorAll('iframe').forEach(f => {
-            if (f.src.includes('youtube.com/embed'))
-                detected.push('YouTube Embed');
-            if (f.src.includes('vimeo.com'))
-                detected.push('Vimeo Embed');
-        });
-        return [...new Set(detected)];
-    });
-    return { content: [{ type: 'text', text: `Detected Players: ${players.join(', ') || 'None found'}` }] };
-}
-/**
- * Detect HLS (m3u8) / DASH (mpd) streams in network traffic
- */
-export async function handleStreamDetector(args) {
-    const page = getPageInstance();
-    if (!page)
-        throw new Error('Browser not initialized. Call browser_init first.');
-    const duration = args.duration || 10000;
-    const streams = [];
-    const handler = (response) => {
-        const url = response.url();
-        if (url.includes('.m3u8') || url.includes('.mpd')) {
-            streams.push({ url, type: url.includes('.m3u8') ? 'HLS' : 'DASH', status: response.status() });
-        }
-    };
-    page.on('response', handler);
-    await new Promise(resolve => setTimeout(resolve, duration));
-    page.off('response', handler);
-    return { content: [{ type: 'text', text: JSON.stringify(streams, null, 2) }] };
-}
-/**
- * Trace URL redirects
- */
-export async function handleRedirectTracer(args) {
-    const page = getPageInstance();
-    if (!page)
-        throw new Error('Browser not initialized. Call browser_init first.');
-    const chain = [];
-    const handler = (response) => {
-        if ([301, 302, 303, 307, 308].includes(response.status())) {
-            chain.push(`${response.url()} -> ${response.headers()['location']}`);
-        }
-    };
-    page.on('response', handler);
-    await page.goto(args.url, { waitUntil: 'networkidle2' });
-    page.off('response', handler);
-    return { content: [{ type: 'text', text: JSON.stringify({ finalUrl: page.url(), redirectChain: chain }, null, 2) }] };
-}
-/**
- * Find direct video download links
- */
-export async function handleVideoDownloadLinkFinder(args) {
-    const page = getPageInstance();
-    if (!page)
-        throw new Error('Browser not initialized. Call browser_init first.');
-    const exts = args.extensions || ['.mp4', '.mkv', '.avi', '.mov', '.webm'];
-    const links = await page.evaluate((extensions) => {
-        return Array.from(document.querySelectorAll('a'))
-            .filter(a => extensions.some(ext => a.href.toLowerCase().endsWith(ext)))
-            .map(a => ({ text: a.textContent, href: a.href }));
-    }, exts);
-    return { content: [{ type: 'text', text: JSON.stringify(links, null, 2) }] };
-}
-// --- Implementation of missing "Ghost" handlers required by index.ts ---
-// Aliases or specific implementations
-export const handleVideoLinkFinder = handleVideoDownloadLinkFinder;
-export async function handleVideoDownloadButton(args) {
-    // Basic implementation trying to find "Download" buttons contextually
-    const page = getPageInstance();
-    if (!page)
-        throw new Error('Browser not initialized');
-    const downloadProbability = await page.evaluate(() => {
-        const buttons = Array.from(document.querySelectorAll('button, a'));
-        return buttons.filter(b => b.textContent?.toLowerCase().includes('download')).map(b => ({
-            text: b.textContent,
-            outerHTML: b.outerHTML.substring(0, 100)
-        }));
-    });
-    return { content: [{ type: 'text', text: JSON.stringify(downloadProbability, null, 2) }] };
-}
-export async function handleVideoPlayPushSource(args) {
-    return { content: [{ type: 'text', text: "Video Play Push Source detected (Simulated)" }] };
-}
-export async function handleVideoPlayButtonClick(args) {
-    const page = getPageInstance();
-    if (!page)
-        throw new Error('Browser not initialized');
-    // Try to click the first play button found
-    const clicked = await page.evaluate(() => {
-        const playBtn = document.querySelector('button[aria-label="Play"], .vjs-big-play-button, .ytp-play-button');
-        if (playBtn instanceof HTMLElement) {
-            playBtn.click();
-            return true;
-        }
-        return false;
-    });
-    return { content: [{ type: 'text', text: clicked ? "Clicked Play Button" : "No Play Button Found" }] };
-}