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

package/dist/browser-manager.js

@@ -4,15 +4,7 @@ import { ExtensionManager } from './extension-manager.js';
 import * as path from 'path';
 import * as net from 'net';
 import { execSync, spawn } from 'child_process';
-import { config as dotenvConfig } from 'dotenv';
 import { BraveInstaller } from './brave-installer.js';
-// Load environment variables from .env file
-// Silence dotenv output
-const originalWrite = process.stdout.write;
-// @ts-ignore
-process.stdout.write = () => true;
-dotenvConfig();
-process.stdout.write = originalWrite;
 // Browser error categorization
 export var BrowserErrorType;
 (function (BrowserErrorType) {

package/dist/debug-logger.js

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Log to a file in the project root (up one level from src, or relative to where it runs)
+// We try to find a writable location.
+const LOG_FILE = path.join(process.cwd(), 'mcp-server-debug.log');
+export function logDebug(message, data) {
+    const timestamp = new Date().toISOString();
+    let logMessage = `[${timestamp}] ${message}`;
+    if (data) {
+        try {
+            logMessage += `\nData: ${JSON.stringify(data, null, 2)}`;
+        }
+        catch (e) {
+            logMessage += `\nData: [Circular or Non-Serializable]`;
+        }
+    }
+    logMessage += '\n' + '-'.repeat(40) + '\n';
+    try {
+        fs.appendFileSync(LOG_FILE, logMessage);
+    }
+    catch (error) {
+        // If we can't write to file, fallback to stderr (which is safe for MCP)
+        console.error(`[DEBUG FAILED] ${message}`);
+    }
+}

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

@@ -280,86 +280,6 @@ ${JSON.stringify(videoData, null, 2)}
         };
     }, 'Failed to extract advanced video sources');
 }
-/**
- * Deobfuscate JavaScript - Attempt to decode obfuscated JavaScript
- */
-export async function handleDeobfuscateJS(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('deobfuscate_js', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const deobfuscationResults = await page.evaluate(() => {
-            const results = [];
-            document.querySelectorAll('script').forEach((script, index) => {
-                const content = script.textContent || '';
-                if (content.length < 100)
-                    return;
-                const analysis = {
-                    scriptIndex: index,
-                    obfuscationType: [],
-                    extractedData: {
-                        urls: [],
-                        domains: [],
-                        apiKeys: [],
-                        base64Strings: []
-                    }
-                };
-                // Detect obfuscation types
-                if (content.includes('eval('))
-                    analysis.obfuscationType.push('eval');
-                if (content.includes('atob('))
-                    analysis.obfuscationType.push('base64');
-                if (content.match(/0x[0-9a-f]{4}/gi))
-                    analysis.obfuscationType.push('hex');
-                if (content.match(/_0x[0-9a-f]+/gi))
-                    analysis.obfuscationType.push('identifier_obfuscation');
-                if (content.includes('\\x'))
-                    analysis.obfuscationType.push('hex_escape');
-                if (analysis.obfuscationType.length === 0)
-                    return;
-                // Extract URLs
-                const urlPattern = /https?:\/\/[^\s"'<>]+/gi;
-                const urls = content.match(urlPattern);
-                if (urls) {
-                    analysis.extractedData.urls = [...new Set(urls)];
-                }
-                // Extract base64 encoded strings
-                const base64Pattern = /["']([A-Za-z0-9+/]{20,}={0,2})["']/g;
-                let match;
-                while ((match = base64Pattern.exec(content)) !== null) {
-                    try {
-                        const decoded = atob(match[1]);
-                        if (decoded.includes('http') || decoded.includes('video') || decoded.includes('.m3u8')) {
-                            analysis.extractedData.base64Strings.push({
-                                original: match[1].substring(0, 50) + '...',
-                                decoded: decoded.substring(0, 200)
-                            });
-                        }
-                    }
-                    catch (e) {
-                        // Not valid base64
-                    }
-                }
-                // Extract potential domains
-                const domainPattern = /[a-z0-9][a-z0-9-]*\.(com|net|org|io|tv|online|xyz|cc)/gi;
-                const domains = content.match(domainPattern);
-                if (domains) {
-                    analysis.extractedData.domains = [...new Set(domains)];
-                }
-                results.push(analysis);
-            });
-            return results.filter(r => r.obfuscationType.length > 0);
-        });
-        return {
-            content: [{
-                    type: 'text',
-                    text: `🔓 Deobfuscation Results:\n\nFound ${deobfuscationResults.length} obfuscated scripts\n\n${JSON.stringify(deobfuscationResults, null, 2)}`
-                }]
-        };
-    }, 'Failed to deobfuscate JavaScript');
-}
 /**
  * Multi-Layer Redirect Tracer - Follow multiple redirect layers to find final video source
  */

package/dist/handlers/deep-analysis-handler.js

@@ -0,0 +1,119 @@
+// @ts-nocheck
+import { getCurrentPage } from '../browser-manager.js';
+import { withErrorHandling, sleep } from '../system-utils.js';
+import { validateWorkflow } from '../workflow-validation.js';
+/**
+ * Deep Analysis Tool
+ * Captures a comprehensive snapshot of the page including network traces, console logs, and DOM state.
+ */
+export async function handleDeepAnalysis(args) {
+    return await withErrorHandling(async () => {
+        validateWorkflow('deep_analysis', {
+            requireBrowser: true,
+            requirePage: true,
+        });
+        const page = getCurrentPage();
+        const { url, duration = 5000, screenshots = true, network = true, logs = true, dom = true } = args;
+        // Navigate if URL provided
+        if (url && page.url() !== url) {
+            await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+        }
+        // Storage for captured data
+        const capturedData = {
+            network: [],
+            console: [],
+            error: null
+        };
+        // Setup Listeners
+        const listeners = [];
+        if (network) {
+            const netHandler = (req) => {
+                capturedData.network.push({
+                    type: 'request',
+                    url: req.url(),
+                    method: req.method(),
+                    resource: req.resourceType(),
+                    timestamp: Date.now()
+                });
+            };
+            page.on('request', netHandler);
+            listeners.push(() => page.off('request', netHandler));
+        }
+        if (logs) {
+            const logHandler = (msg) => {
+                capturedData.console.push({
+                    type: msg.type(),
+                    text: msg.text(),
+                    timestamp: Date.now()
+                });
+            };
+            page.on('console', logHandler);
+            listeners.push(() => page.off('console', logHandler));
+        }
+        // Wait and Record
+        await sleep(duration);
+        // Cleanup Listeners
+        listeners.forEach(cleanup => cleanup());
+        // Take Snapshot
+        const result = {
+            timestamp: new Date().toISOString(),
+            url: page.url(),
+            title: await page.title(),
+            recordingDuration: duration,
+            networkRequests: capturedData.network.length,
+            consoleLogs: capturedData.console.length,
+            data: {
+                network: capturedData.network,
+                console: capturedData.console
+            }
+        };
+        if (dom) {
+            result.data.dom = await page.evaluate(() => {
+                // Simplified DOM snapshot
+                const cleanText = (text) => text?.replace(/\\s+/g, ' ').trim() || '';
+                return {
+                    title: document.title,
+                    headings: Array.from(document.querySelectorAll('h1, h2, h3')).map(h => ({ tag: h.tagName, text: cleanText(h.textContent) })),
+                    buttons: Array.from(document.querySelectorAll('button, a.btn, input[type="submit"]')).map(b => cleanText(b.textContent)),
+                    links: Array.from(document.querySelectorAll('a')).slice(0, 50).map(a => ({ text: cleanText(a.textContent), href: a.href })),
+                    inputs: Array.from(document.querySelectorAll('input, textarea, select')).map(i => ({ tag: i.tagName, type: i.type, id: i.id, placeholder: i.placeholder }))
+                };
+            });
+        }
+        if (screenshots) {
+            result.data.screenshot = await page.screenshot({ encoding: 'base64', type: 'webp', quality: 50 });
+        }
+        const summary = `
+🔍 Deep Analysis Report
+═══════════════════════
+
+📍 URL: ${result.url}
+⏱️ Duration: ${duration}ms
+📅 Time: ${result.timestamp}
+
+📊 Statistics:
+  • Network Requests: ${result.networkRequests}
+  • Console Logs: ${result.consoleLogs}
+  ${dom ? `• DOM Elements: ${result.data.dom.headings.length} headings, ${result.data.dom.buttons.length} buttons, ${result.data.dom.links.length} links` : ''}
+
+${logs && result.data.console.length > 0 ? `
+📝 Recent Console Logs (Last 5):
+${result.data.console.slice(-5).map(l => `  [${l.type}] ${l.text}`).join('\n')}
+` : ''}
+
+${dom ? `
+🏗️ Page Structure:
+  • Headings: ${result.data.dom.headings.map(h => h.text).join(', ')}
+  • Interactive: ${result.data.dom.buttons.length} buttons
+` : ''}
+`;
+        return {
+            content: [
+                { type: 'text', text: summary },
+                ...(screenshots ? [{ type: 'image', data: result.data.screenshot, netType: 'image/webp' }] : [])
+            ],
+            // Return full dataset as JSON for programmatic use if needed (MCP usually just text/image)
+            // We embed the summary logic here.
+        };
+    }, 'Deep Analysis Failed');
+}

package/dist/handlers/multi-element-handlers.js

@@ -67,66 +67,6 @@ export async function handleBatchElementScraper(args) {
         };
     }, 'Failed to batch scrape elements');
 }
-/**
- * सभी elements के attributes (href, src, data-*) collect करता है
- */
-export async function handleAttributeHarvester(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('attribute_harvester', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const selector = args.selector;
-        const attributes = args.attributes || [];
-        const maxElements = args.maxElements || 100;
-        const attributeData = await page.evaluate(({ selector, attributes, maxElements }) => {
-            const elements = document.querySelectorAll(selector);
-            const result = {
-                selector,
-                count: Math.min(elements.length, maxElements),
-                attributes: [],
-            };
-            let count = 0;
-            elements.forEach((element, index) => {
-                if (count >= maxElements)
-                    return;
-                const attrs = {};
-                if (attributes.length > 0) {
-                    // Extract specific attributes
-                    attributes.forEach((attr) => {
-                        const value = element.getAttribute(attr);
-                        if (value !== null) {
-                            attrs[attr] = value;
-                        }
-                    });
-                }
-                else {
-                    // Extract all attributes
-                    Array.from(element.attributes).forEach((attr) => {
-                        attrs[attr.name] = attr.value;
-                    });
-                }
-                if (Object.keys(attrs).length > 0) {
-                    result.attributes.push({
-                        element: index,
-                        attrs,
-                    });
-                    count++;
-                }
-            });
-            return result;
-        }, { selector, attributes, maxElements });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Harvested attributes from ${attributeData.count} elements\n\n${JSON.stringify(attributeData, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to harvest attributes');
-}
 /**
  * Internal/external links classification के साथ collect करता है
  */