brave-real-browser-mcp-server 2.14.9 → 2.14.10

package/dist/handlers/search-filter-handlers.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { getPageInstance } from '../browser-manager.js';
 /**
  * Keyword Search - Advanced keyword search in page content
@@ -19,7 +18,7 @@ export async function handleKeywordSearch(args) {
             keywordList.forEach(keyword => {
                 const flags = caseSens ? 'g' : 'gi';
                 const pattern = whole ? `\\b${keyword}\\b` : keyword;
-                const regex = new RegExp(pattern, flags);
+                //const regex = new RegExp(pattern, flags);
                 const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, null);
                 let node;
                 while (node = walker.nextNode()) {
@@ -61,7 +60,7 @@ export async function handleKeywordSearch(args) {
                 matchesByKeyword: grouped,
                 allMatches: allMatches.slice(0, 100) // Limit to first 100
             };
-        }, keywords, caseSensitive, wholeWord, context);
+        }, Array.isArray(keywords) ? keywords : [keywords], caseSensitive, wholeWord, context);
         const resultText = `✅ Keyword Search Results\n\nTotal Matches: ${results.totalMatches}\n\nKeywords searched: ${Array.isArray(keywords) ? keywords.join(', ') : keywords}\n\nMatches by keyword:\n${JSON.stringify(results.matchesByKeyword, null, 2)}\n\nFirst 100 matches:\n${JSON.stringify(results.allMatches, null, 2)}`;
         return {
             content: [
@@ -74,12 +73,7 @@ export async function handleKeywordSearch(args) {
     }
     catch (error) {
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: `❌ Keyword search failed: ${error.message}`,
-                },
-            ],
+            content: [{ type: 'text', text: `❌ Keyword search failed: ${error.message}` }],
             isError: true,
         };
     }
@@ -109,14 +103,16 @@ export async function handleRegexPatternMatcher(args) {
             const regex = new RegExp(pat, flgs);
             const matches = [];
             let match;
-            while ((match = regex.exec(content)) !== null) {
+            // Safety check for infinite loop
+            let count = 0;
+            while ((match = regex.exec(content)) !== null && count < 1000) {
+                count++;
                 matches.push({
                     match: match[0],
                     index: match.index,
                     groups: match.slice(1),
                     context: content.substring(Math.max(0, match.index - 50), Math.min(content.length, match.index + match[0].length + 50))
                 });
-                // Prevent infinite loop for zero-width matches
                 if (match.index === regex.lastIndex) {
                     regex.lastIndex++;
                 }
@@ -130,24 +126,11 @@ export async function handleRegexPatternMatcher(args) {
         }, pattern, flags, selector || '');
         const resultText = `✅ Regex Pattern Matcher Results\n\nPattern: ${results.pattern}\nFlags: ${results.flags}\nTotal Matches: ${results.totalMatches}\n\nMatches (first 100):\n${JSON.stringify(results.matches, null, 2)}`;
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: resultText,
-                },
-            ],
+            content: [{ type: 'text', text: resultText }],
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `❌ Regex pattern matcher failed: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
+        return { content: [{ type: 'text', text: `❌ Regex pattern matcher failed: ${error.message}` }], isError: true };
     }
 }
 /**
@@ -205,24 +188,11 @@ export async function handleXPathSupport(args) {
         }, xpath, returnType);
         const resultText = `✅ XPath Query Results\n\nXPath: ${xpath}\nElements Found: ${results.count}\n\nElements:\n${JSON.stringify(results.elements, null, 2)}`;
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: resultText,
-                },
-            ],
+            content: [{ type: 'text', text: resultText }],
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `❌ XPath query failed: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
+        return { content: [{ type: 'text', text: `❌ XPath query failed: ${error.message}` }], isError: true };
     }
 }
 /**
@@ -285,24 +255,11 @@ export async function handleAdvancedCSSSelectors(args) {
         }, selector, operation, returnType);
         const resultText = `✅ Advanced CSS Selector Results\n\nSelector: ${selector}\nOperation: ${operation}\nElements Found: ${results.count}\n\nElements (first 10):\n${JSON.stringify(results.elements.slice(0, 10), null, 2)}`;
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: resultText,
-                },
-            ],
+            content: [{ type: 'text', text: resultText }],
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `❌ CSS selector query failed: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
+        return { content: [{ type: 'text', text: `❌ CSS selector query failed: ${error.message}` }], isError: true };
     }
 }
 /**
@@ -419,23 +376,10 @@ export async function handleVisualElementFinder(args) {
         }, criteria);
         const resultText = `✅ Visual Element Finder Results\n\nCriteria: ${JSON.stringify(criteria, null, 2)}\nTotal Matches: ${results.totalMatches}\n\nTop Matches:\n${JSON.stringify(results.topMatches, null, 2)}`;
         return {
-            content: [
-                {
-                    type: 'text',
-                    text: resultText,
-                },
-            ],
+            content: [{ type: 'text', text: resultText }],
         };
     }
     catch (error) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `❌ Visual element finder failed: ${error.message}`,
-                },
-            ],
-            isError: true,
-        };
+        return { content: [{ type: 'text', text: `❌ Visual element finder failed: ${error.message}` }], isError: true };
     }
 }

package/dist/mcp-server.js

@@ -10,6 +10,16 @@ import { handleGetContent, handleFindSelector } from './handlers/content-handler
 import { handleSaveContentAsMarkdown } from './handlers/file-handlers.js';
 import { handleExtractList, handleExtractJSON, handleScrapeMetaTags, handleExtractSchema } from './handlers/data-extraction-handlers.js';
 import { handleBatchElementScraper, handleNestedDataExtraction, handleAttributeHarvester, handleLinkHarvester, handleMediaExtractor, } from './handlers/multi-element-handlers.js';
+import { handleMultiPageScraper, handleBreadcrumbNavigator } from './handlers/advanced-scraping-handlers.js';
+import { handleHtmlElementsExtractor, handleTagsFinder, handleLinksFinder, handleXpathLinks, handleShadowDomExtractor, handleIframeExtractor, handleEmbedPageExtractor } from './handlers/dom-handlers.js';
+import { handleNetworkRecorder, handleAjaxExtractor, handleFetchXhr, handleApiFinder } from './handlers/network-handlers.js';
+import { handleHtmlToText, handleDuplicateRemover } from './handlers/data-transform-handlers.js';
+import { handleConsistencyChecker } from './handlers/data-quality-handlers.js';
+import { handleSmartSelectorGenerator, handleContentClassification, handleSentimentAnalysis, handleSummaryGenerator, handleTranslationSupport } from './handlers/ai-powered-handlers.js';
+import { handleKeywordSearch, handleRegexPatternMatcher, handleXPathSupport, handleAdvancedCSSSelectors, handleVisualElementFinder } from './handlers/search-filter-handlers.js';
+import { handleVideoSourceExtractor, handleVideoPlayerFinder, handleStreamDetector, handleRedirectTracer, handleVideoDownloadLinkFinder } from './handlers/advanced-video-media-handlers.js';
+import { handleOCREngine, handleAudioCaptchaSolver, handlePuzzleCaptchaHandler } from './handlers/captcha-handlers.js';
+import { handleAdvancedVideoExtraction, handleDeobfuscateJS, handleMultiLayerRedirectTrace, handleAdProtectionDetector } from './handlers/advanced-extraction-handlers.js';
 export async function createMcpServer() {
     const server = new Server(SERVER_INFO, { capabilities: CAPABILITIES });
     // Register initialize handler
@@ -105,6 +115,129 @@ export async function createMcpServer() {
                 case TOOL_NAMES.MEDIA_EXTRACTOR:
                     result = await handleMediaExtractor(args || {});
                     break;
+                // Phase 1: Pagination & Navigation
+                case TOOL_NAMES.MULTI_PAGE_SCRAPER:
+                    result = await handleMultiPageScraper(args);
+                    break;
+                case TOOL_NAMES.BREADCRUMB_NAVIGATOR:
+                    result = await handleBreadcrumbNavigator(args);
+                    break;
+                // Phase 1: DOM & HTML
+                case TOOL_NAMES.HTML_ELEMENTS_EXTRACTOR:
+                    result = await handleHtmlElementsExtractor(args);
+                    break;
+                case TOOL_NAMES.TAGS_FINDER:
+                    result = await handleTagsFinder(args);
+                    break;
+                case TOOL_NAMES.LINKS_FINDER:
+                    result = await handleLinksFinder(args);
+                    break;
+                case TOOL_NAMES.XPATH_LINKS:
+                    result = await handleXpathLinks(args);
+                    break;
+                case TOOL_NAMES.SHADOW_DOM_EXTRACTOR:
+                    result = await handleShadowDomExtractor(args);
+                    break;
+                case TOOL_NAMES.IFRAME_EXTRACTOR:
+                    result = await handleIframeExtractor();
+                    break;
+                case TOOL_NAMES.EMBED_PAGE_EXTRACTOR:
+                    result = await handleEmbedPageExtractor();
+                    break;
+                // Phase 1: Network Tools
+                case TOOL_NAMES.NETWORK_RECORDER:
+                    result = await handleNetworkRecorder(args);
+                    break;
+                case TOOL_NAMES.AJAX_EXTRACTOR:
+                    result = await handleAjaxExtractor(args);
+                    break;
+                case TOOL_NAMES.FETCH_XHR:
+                    result = await handleFetchXhr(args);
+                    break;
+                case TOOL_NAMES.API_FINDER:
+                    result = await handleApiFinder(args);
+                    break;
+                // Phase 1: Data Transform
+                case TOOL_NAMES.HTML_TO_TEXT:
+                    result = await handleHtmlToText(args);
+                    break;
+                case TOOL_NAMES.DUPLICATE_REMOVER:
+                    result = await handleDuplicateRemover(args);
+                    break;
+                // Phase 2: AI & Smart Features
+                case TOOL_NAMES.SMART_SELECTOR_GENERATOR:
+                    result = await handleSmartSelectorGenerator(args);
+                    break;
+                case TOOL_NAMES.CONTENT_CLASSIFICATION:
+                    result = await handleContentClassification(args);
+                    break;
+                case TOOL_NAMES.SENTIMENT_ANALYSIS:
+                    result = await handleSentimentAnalysis(args);
+                    break;
+                case TOOL_NAMES.SUMMARY_GENERATOR:
+                    result = await handleSummaryGenerator(args);
+                    break;
+                case TOOL_NAMES.TRANSLATION_SUPPORT:
+                    result = await handleTranslationSupport(args);
+                    break;
+                // Phase 2: Search & Filter
+                case TOOL_NAMES.KEYWORD_SEARCH:
+                    result = await handleKeywordSearch(args);
+                    break;
+                case TOOL_NAMES.REGEX_PATTERN_MATCHER:
+                    result = await handleRegexPatternMatcher(args);
+                    break;
+                case TOOL_NAMES.XPATH_SUPPORT:
+                    result = await handleXPathSupport(args);
+                    break;
+                case TOOL_NAMES.ADVANCED_CSS_SELECTORS:
+                    result = await handleAdvancedCSSSelectors(args);
+                    break;
+                case TOOL_NAMES.VISUAL_ELEMENT_FINDER:
+                    result = await handleVisualElementFinder(args);
+                    break;
+                // Phase 3: Media & Video
+                case TOOL_NAMES.VIDEO_SOURCE_EXTRACTOR:
+                    result = await handleVideoSourceExtractor(args);
+                    break;
+                case TOOL_NAMES.VIDEO_PLAYER_FINDER:
+                    result = await handleVideoPlayerFinder(args);
+                    break;
+                case TOOL_NAMES.STREAM_DETECTOR:
+                    result = await handleStreamDetector(args);
+                    break;
+                case TOOL_NAMES.REDIRECT_TRACER:
+                    result = await handleRedirectTracer(args);
+                    break;
+                case TOOL_NAMES.VIDEO_DOWNLOAD_LINK_FINDER:
+                    result = await handleVideoDownloadLinkFinder(args);
+                    break;
+                // Phase 4: Captcha & Security
+                case TOOL_NAMES.OCR_ENGINE:
+                    result = await handleOCREngine(args);
+                    break;
+                case TOOL_NAMES.AUDIO_CAPTCHA_SOLVER:
+                    result = await handleAudioCaptchaSolver(args);
+                    break;
+                case TOOL_NAMES.PUZZLE_CAPTCHA_HANDLER:
+                    result = await handlePuzzleCaptchaHandler(args);
+                    break;
+                // Advanced Extraction (Security/Bypass)
+                case "advanced_video_extraction":
+                    result = await handleAdvancedVideoExtraction(args);
+                    break;
+                case "deobfuscate_js":
+                    result = await handleDeobfuscateJS(args);
+                    break;
+                case "multi_layer_redirect_trace":
+                    result = await handleMultiLayerRedirectTrace(args);
+                    break;
+                case "ad_protection_detector":
+                    result = await handleAdProtectionDetector(args);
+                    break;
+                case "consistency_checker":
+                    result = await handleConsistencyChecker(args);
+                    break;
                 default:
                     throw new Error(`Unknown tool: ${name}`);
             }

package/dist/tool-definitions.js

@@ -1161,9 +1161,102 @@ export const TOOLS = [
         description: 'Detect ad-protection mechanisms including ad-block detection, anti-debugger code, popup layers, and hidden elements.',
         inputSchema: {
             type: 'object',
-            properties: {},
+            properties: {
+                url: { type: 'string', description: 'URL of the page to analyze (optional)' },
+                selector: { type: 'string', description: 'CSS selector for content to analyze (optional)' },
+                text: { type: 'string', description: 'Direct text to analyze (optional)' },
+                criteria: { type: 'object', description: 'Visual criteria (visible, color, size, etc.)' },
+            },
         },
     },
+    {
+        name: 'sentiment_analysis',
+        description: 'Analyze the sentiment of text or page content',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Text to analyze' },
+                url: { type: 'string', description: 'URL to analyze' },
+                selector: { type: 'string', description: 'Selector to extract text from' }
+            }
+        }
+    },
+    {
+        name: 'summary_generator',
+        description: 'Generate a summary of text or page content',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Text to summarize' },
+                url: { type: 'string', description: 'URL to summarize' },
+                selector: { type: 'string', description: 'Selector to extract text from' },
+                maxLength: { type: 'number', description: 'Maximum length of summary' }
+            }
+        }
+    },
+    {
+        name: 'translation_support',
+        description: 'Detect language and translate text',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                text: { type: 'string', description: 'Text to translate' },
+                url: { type: 'string', description: 'URL to translate content from' },
+                targetLanguage: { type: 'string', description: 'Target language code (e.g. "es", "fr")' }
+            }
+        }
+    },
+    // 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: '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',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                extensions: { type: 'array', items: { type: 'string' } }
+            }
+        }
+    }
 ];
 // Tool name constants for type safety
 export const TOOL_NAMES = {
@@ -1191,6 +1284,19 @@ export const TOOL_NAMES = {
     // Content Type Specific
     LINK_HARVESTER: 'link_harvester',
     MEDIA_EXTRACTOR: 'media_extractor',
+    // DOM & HTML Extraction (Phase 1)
+    HTML_ELEMENTS_EXTRACTOR: 'html_elements_extractor',
+    TAGS_FINDER: 'tags_finder',
+    LINKS_FINDER: 'links_finder',
+    XPATH_LINKS: 'xpath_links',
+    SHADOW_DOM_EXTRACTOR: 'shadow_dom_extractor',
+    IFRAME_EXTRACTOR: 'iframe_extractor',
+    EMBED_PAGE_EXTRACTOR: 'embed_page_extractor',
+    // Network Tools (Phase 1)
+    AJAX_EXTRACTOR: 'ajax_extractor',
+    FETCH_XHR: 'fetch_xhr',
+    NETWORK_RECORDER: 'network_recorder',
+    API_FINDER: 'api_finder',
     // Pagination Tools
     MULTI_PAGE_SCRAPER: 'multi_page_scraper',
     BREADCRUMB_NAVIGATOR: 'breadcrumb_navigator',
@@ -1200,6 +1306,15 @@ export const TOOL_NAMES = {
     // AI-Powered Features
     SMART_SELECTOR_GENERATOR: 'smart_selector_generator',
     CONTENT_CLASSIFICATION: 'content_classification',
+    SENTIMENT_ANALYSIS: 'sentiment_analysis',
+    SUMMARY_GENERATOR: 'summary_generator',
+    TRANSLATION_SUPPORT: 'translation_support',
+    // Phase 3: Media & Video
+    VIDEO_SOURCE_EXTRACTOR: 'video_source_extractor',
+    VIDEO_PLAYER_FINDER: 'video_player_finder',
+    STREAM_DETECTOR: 'stream_detector',
+    REDIRECT_TRACER: 'redirect_tracer',
+    VIDEO_DOWNLOAD_LINK_FINDER: 'video_download_link_finder',
     // 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.14.9",
+  "version": "2.14.10",
   "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",