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

package/dist/handlers/unified-search-handler.js

@@ -0,0 +1,137 @@
+// @ts-nocheck
+import { getPageInstance } from '../browser-manager.js';
+import { withErrorHandling } from '../system-utils.js';
+import { validateWorkflow } from '../workflow-validation.js';
+/**
+ * Unified Search Content Handler
+ * Merges Keyword Search and Regex Pattern Matcher
+ */
+export async function handleSearchContent(args) {
+    return await withErrorHandling(async () => {
+        validateWorkflow('search_content', { requireBrowser: true, requirePage: true });
+        // Logic based on type
+        if (args.type === 'regex') {
+            return await handleRegexPatternMatcher(args);
+        }
+        else {
+            return await handleKeywordSearch(args);
+        }
+    }, 'Search Content Failed');
+}
+/**
+ * Unified Find Element Advanced Handler
+ * Merges XPath and Advanced CSS Selectors
+ */
+export async function handleFindElementAdvanced(args) {
+    return await withErrorHandling(async () => {
+        validateWorkflow('find_element_advanced', { requireBrowser: true, requirePage: true });
+        if (args.type === 'xpath') {
+            return await handleXPathSupport(args);
+        }
+        else {
+            return await handleAdvancedCSSSelectors(args);
+        }
+    }, 'Find Element Advanced Failed');
+}
+// --- Internal Sub-Handlers (Preserved Logic) ---
+async function handleKeywordSearch(args) {
+    const { url, query, caseSensitive = false, wholeWord = false, context = 50 } = args;
+    const keywords = Array.isArray(query) ? query : [query]; // Handling if someone passes array (unlikely with new schema but good for compat)
+    const page = getPageInstance();
+    if (url && page.url() !== url)
+        await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
+    const results = await page.evaluate((kws, caseSens, whole, ctx) => {
+        const allMatches = [];
+        kws.forEach(keyword => {
+            const flags = caseSens ? 'g' : 'gi';
+            const pattern = whole ? `\\b${keyword}\\b` : keyword;
+            const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, null);
+            let node;
+            while (node = walker.nextNode()) {
+                const text = node.textContent || '';
+                const nodeRegex = new RegExp(pattern, flags);
+                let match;
+                while ((match = nodeRegex.exec(text)) !== null) {
+                    allMatches.push({
+                        keyword,
+                        match: match[0],
+                        context: text.substring(Math.max(0, match.index - ctx), Math.min(text.length, match.index + match[0].length + ctx))
+                    });
+                }
+            }
+        });
+        return { totalMatches: allMatches.length, matches: allMatches.slice(0, 100) };
+    }, keywords, caseSensitive, wholeWord, context);
+    return {
+        content: [{ type: 'text', text: `Keyword Search Results (${results.totalMatches}):\n${JSON.stringify(results.matches, null, 2)}` }]
+    };
+}
+async function handleRegexPatternMatcher(args) {
+    const { url, query, flags = 'g', selector } = args;
+    const page = getPageInstance();
+    if (url && page.url() !== url)
+        await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
+    const results = await page.evaluate((pat, flgs, sel) => {
+        const content = sel ? document.querySelector(sel)?.textContent || '' : document.body.innerText;
+        const regex = new RegExp(pat, flgs);
+        const matches = [];
+        let match;
+        let count = 0;
+        while ((match = regex.exec(content)) !== null && count < 1000) {
+            count++;
+            matches.push({ match: match[0], index: match.index, groups: match.slice(1) });
+            if (match.index === regex.lastIndex)
+                regex.lastIndex++;
+        }
+        return { totalMatches: matches.length, matches: matches.slice(0, 100) };
+    }, query, flags, selector || '');
+    return { content: [{ type: 'text', text: `Regex Results (${results.totalMatches}):\n${JSON.stringify(results.matches, null, 2)}` }] };
+}
+async function handleXPathSupport(args) {
+    const { url, query, returnType = 'elements' } = args;
+    const page = getPageInstance();
+    if (url && page.url() !== url)
+        await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
+    const results = await page.evaluate((xp, type) => {
+        const xpathResult = document.evaluate(xp, document, null, XPathResult.ANY_TYPE, null);
+        const elements = [];
+        let node = xpathResult.iterateNext();
+        while (node) {
+            if (node.nodeType === Node.ELEMENT_NODE) {
+                const el = node;
+                elements.push({
+                    tagName: el.tagName.toLowerCase(),
+                    text: el.textContent?.substring(0, 100),
+                    attributes: Array.from(el.attributes).reduce((acc, a) => { acc[a.name] = a.value; return acc; }, {})
+                });
+            }
+            node = xpathResult.iterateNext();
+        }
+        return { count: elements.length, elements };
+    }, query, returnType);
+    return { content: [{ type: 'text', text: `XPath Results (${results.count}):\n${JSON.stringify(results.elements, null, 2)}` }] };
+}
+async function handleAdvancedCSSSelectors(args) {
+    const { url, query, operation = 'query', returnType = 'elements' } = args;
+    const page = getPageInstance();
+    if (url && page.url() !== url)
+        await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
+    const results = await page.evaluate((sel, op) => {
+        let elements = [];
+        if (op === 'closest')
+            elements = document.querySelector(sel) ? [document.querySelector(sel).closest(sel)].filter(Boolean) : [];
+        else if (op === 'matches')
+            elements = Array.from(document.querySelectorAll('*')).filter(el => el.matches(sel));
+        else
+            elements = Array.from(document.querySelectorAll(sel));
+        return {
+            count: elements.length,
+            elements: elements.map(el => ({
+                tagName: el.tagName.toLowerCase(),
+                className: el.className,
+                text: el.textContent?.substring(0, 100)
+            })).slice(0, 50)
+        };
+    }, query, operation);
+    return { content: [{ type: 'text', text: `CSS Results (${results.count}):\n${JSON.stringify(results.elements, null, 2)}` }] };
+}

package/dist/index.js

@@ -1,14 +1,83 @@
 #!/usr/bin/env node
-import 'dotenv/config';
-// CRITICAL: Redirect console.log to console.error to prevent stdout pollution
-// Antigravity AI IDE and other MCP clients require stdout to be exclusively for JSON-RPC
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+import { logDebug } from './debug-logger.js';
+// CRITICAL: Patch console.log immediately
 const originalConsoleLog = console.log;
 console.log = (...args) => {
+    logDebug('Captured stdout log:', args);
     console.error(...args);
 };
+// Robust .env loading (Manual & Silent)
+// Import unified handlers
+import { handleUnifiedCaptcha } from './handlers/unified-captcha-handler.js';
+import { handleSearchContent, handleFindElementAdvanced } from './handlers/unified-search-handler.js';
+import { handleDeepAnalysis } from './handlers/deep-analysis-handler.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..');
+const envPath = path.join(projectRoot, '.env');
+// Manual .env parser to avoid stdout pollution from dotenv package
+const loadEnvFile = (filePath) => {
+    try {
+        if (!fs.existsSync(filePath))
+            return false;
+        const content = fs.readFileSync(filePath, 'utf-8');
+        content.split('\n').forEach(line => {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#')) {
+                const [key, ...valueParts] = trimmed.split('=');
+                if (key && valueParts.length > 0) {
+                    const value = valueParts.join('=').replace(/(^"|"$)/g, '').trim();
+                    if (!process.env[key.trim()]) {
+                        process.env[key.trim()] = value;
+                    }
+                }
+            }
+        });
+        return true;
+    }
+    catch (e) {
+        logDebug('Error loading .env file', e);
+        return false;
+    }
+};
+if (loadEnvFile(envPath)) {
+    logDebug(`Loaded .env manually from: ${envPath}`);
+}
+else {
+    // Try CWD
+    const cwdEnv = path.join(process.cwd(), '.env');
+    if (loadEnvFile(cwdEnv)) {
+        logDebug(`Loaded .env manually from CWD: ${cwdEnv}`);
+    }
+    else {
+        logDebug(`Warning: No .env found at ${envPath} or CWD`);
+    }
+}
+logDebug('Server Starting...', {
+    cwd: process.cwd(),
+    nodeVersion: process.version,
+    projectRoot,
+    bravePath: process.env.BRAVE_PATH || 'Not Set'
+});
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+// Log uncaught exceptions
+process.on('uncaughtException', (error) => {
+    logDebug('CRITICAL: Uncaught Exception', {
+        message: error.message,
+        stack: error.stack
+    });
+    console.error('CRITICAL: Uncaught Exception', error);
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason) => {
+    logDebug('CRITICAL: Unhandled Rejection', reason);
+    console.error('CRITICAL: Unhandled Rejection', reason);
+});
 import { TOOLS, SERVER_INFO, CAPABILITIES, TOOL_NAMES, } from "./tool-definitions.js";
 import { withErrorHandling } from "./system-utils.js";
 import { validateMCPResponse } from "./mcp-response-validator.js";
@@ -23,29 +92,23 @@ import { handleSaveContentAsMarkdown } from "./handlers/file-handlers.js";
 // Import new data extraction handlers
 import { handleExtractJSON, handleScrapeMetaTags, handleExtractSchema, } from "./handlers/data-extraction-handlers.js";
 // Import multi-element handlers
-import { handleBatchElementScraper, handleAttributeHarvester, handleLinkHarvester, handleMediaExtractor, } from "./handlers/multi-element-handlers.js";
+import { handleBatchElementScraper, handleLinkHarvester, handleMediaExtractor, } from "./handlers/multi-element-handlers.js";
 // Import pagination handlers
 import { handleBreadcrumbNavigator, } from "./handlers/navigation-handlers.js";
 // Import AI-powered handlers
 import { handleSmartSelectorGenerator, handleContentClassification, } from "./handlers/ai-powered-handlers.js";
 // Import search & filter handlers
-import { handleKeywordSearch, handleRegexPatternMatcher, handleXPathSupport, handleAdvancedCSSSelectors, } from "./handlers/search-filter-handlers.js";
-// Import data quality handlers
-import { handleDataTypeValidator, } from "./handlers/data-quality-handlers.js";
-// Import captcha handlers
-import { handleOCREngine, handleAudioCaptchaSolver, handlePuzzleCaptchaHandler, } from "./handlers/captcha-handlers.js";
+// Import visual tools handlers
 // Import visual tools handlers
 import { handleElementScreenshot, handleVideoRecording, } from "./handlers/visual-tools-handlers.js";
 // Import smart data extractors
-import { handleHtmlElementsExtractor, handleFetchXHR, handleNetworkRecorder, handleImageExtractorAdvanced, handleVideoSourceExtractor, handleUrlRedirectTracer, handleApiFinder, } from "./handlers/smart-data-extractors.js";
+import { handleNetworkRecorder, handleImageExtractorAdvanced, handleUrlRedirectTracer, handleApiFinder, } from "./handlers/smart-data-extractors.js";
 // Import dynamic session handlers
 import { handleAjaxContentWaiter, } from "./handlers/dynamic-session-handlers.js";
 // Import monitoring & reporting handlers
 import { handleProgressTracker, } from "./handlers/monitoring-reporting-handlers.js";
-// Import advanced video & media handlers
-import { handleVideoPlayerFinder, handleStreamDetector, handleVideoDownloadLinkFinder, } from "./handlers/advanced-video-media-handlers.js";
 // Import advanced extraction handlers (Ad-bypass & Obfuscation)
-import { handleAdvancedVideoExtraction, handleDeobfuscateJS, handleMultiLayerRedirectTrace, handleAdProtectionDetector, } from "./handlers/advanced-extraction-handlers.js";
+import { handleAdvancedVideoExtraction, handleMultiLayerRedirectTrace, handleAdProtectionDetector, } from "./handlers/advanced-extraction-handlers.js";
 // Initialize MCP server
 const server = new Server(SERVER_INFO, { capabilities: CAPABILITIES });
 // Register initialize handler (CRITICAL - missing handler can cause crash)
@@ -121,9 +184,6 @@ export async function executeToolByName(name, args) {
                 break;
             // Smart Data Extractors
             // DOM & HTML Extraction
-            case TOOL_NAMES.HTML_ELEMENTS_EXTRACTOR:
-                result = await handleHtmlElementsExtractor(args || {});
-                break;
             case TOOL_NAMES.EXTRACT_JSON:
                 result = await handleExtractJSON(args || {});
                 break;
@@ -137,9 +197,6 @@ export async function executeToolByName(name, args) {
             case TOOL_NAMES.BATCH_ELEMENT_SCRAPER:
                 result = await handleBatchElementScraper(args);
                 break;
-            case TOOL_NAMES.ATTRIBUTE_HARVESTER:
-                result = await handleAttributeHarvester(args);
-                break;
             // Content Type Specific
             case TOOL_NAMES.LINK_HARVESTER:
                 result = await handleLinkHarvester(args || {});
@@ -163,32 +220,17 @@ export async function executeToolByName(name, args) {
                 result = await handleContentClassification(args);
                 break;
             // Search & Filter Tools
-            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;
-            // Data Quality & Validation
-            case TOOL_NAMES.DATA_TYPE_VALIDATOR:
-                result = await handleDataTypeValidator(args);
-                break;
-            // Advanced Captcha Handling
-            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;
+            // --- Search & Filter (Consolidated) ---
+            case TOOL_NAMES.SEARCH_CONTENT:
+                return await handleSearchContent(args);
+            case TOOL_NAMES.FIND_ELEMENT_ADVANCED:
+                return await handleFindElementAdvanced(args);
+            // --- Deep Analysis ---
+            case TOOL_NAMES.DEEP_ANALYSIS:
+                return await handleDeepAnalysis(args);
+            // --- Advanced Captcha Handling (Consolidated) ---
+            case TOOL_NAMES.SOLVE_CAPTCHA:
+                return await handleUnifiedCaptcha({ strategy: 'auto', ...args });
             // Screenshot & Visual Tools
             case TOOL_NAMES.ELEMENT_SCREENSHOT:
                 result = await handleElementScreenshot(args);
@@ -197,9 +239,6 @@ export async function executeToolByName(name, args) {
                 result = await handleVideoRecording(args);
                 break;
             // Smart Data Extractors (Advanced)
-            case "fetch_xhr":
-                result = await handleFetchXHR(args || {});
-                break;
             case "network_recorder":
                 result = await handleNetworkRecorder(args || {});
                 break;
@@ -209,9 +248,6 @@ export async function executeToolByName(name, args) {
             case "image_extractor_advanced":
                 result = await handleImageExtractorAdvanced(args || {});
                 break;
-            case "video_source_extractor":
-                result = await handleVideoSourceExtractor(args || {});
-                break;
             case "url_redirect_tracer":
                 result = await handleUrlRedirectTracer(args);
                 break;
@@ -224,22 +260,10 @@ export async function executeToolByName(name, args) {
                 result = await handleProgressTracker(args || {});
                 break;
             // Advanced Video & Media Download Tools
-            case "video_player_finder":
-                result = await handleVideoPlayerFinder(args || {});
-                break;
-            case "stream_detector":
-                result = await handleStreamDetector(args || {});
-                break;
-            case "video_download_link_finder":
-                result = await handleVideoDownloadLinkFinder(args || {});
-                break;
             // Advanced Extraction Tools (Ad-Bypass & Obfuscation)
             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;