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

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/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 करता है
  */

package/dist/handlers/smart-data-extractors.js

@@ -4,54 +4,6 @@
 import { getCurrentPage } from '../browser-manager.js';
 import { validateWorkflow } from '../workflow-validation.js';
 import { withErrorHandling, sleep } from '../system-utils.js';
-/**
- * HTML Elements Extractor - Extract all HTML elements with complete details
- */
-export async function handleHtmlElementsExtractor(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('html_elements_extractor', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const selector = args.selector || '*';
-        const maxElements = args.maxElements || 100;
-        const includeStyles = args.includeStyles || false;
-        const elements = await page.evaluate(({ selector, maxElements, includeStyles }) => {
-            const nodes = document.querySelectorAll(selector);
-            const results = [];
-            let count = 0;
-            nodes.forEach((el, index) => {
-                if (count >= maxElements)
-                    return;
-                const elementData = {
-                    index,
-                    tagName: el.tagName,
-                    id: el.id || null,
-                    className: el.className || null,
-                    textContent: el.textContent?.trim().substring(0, 200) || '',
-                    innerHTML: el.innerHTML?.substring(0, 200) || '',
-                    attributes: {},
-                };
-                Array.from(el.attributes).forEach((attr) => {
-                    elementData.attributes[attr.name] = attr.value;
-                });
-                if (includeStyles && el.style) {
-                    elementData.styles = el.style.cssText;
-                }
-                results.push(elementData);
-                count++;
-            });
-            return results;
-        }, { selector, maxElements, includeStyles });
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Extracted ${elements.length} HTML elements\n\n${JSON.stringify(elements, null, 2)}`,
-                }],
-        };
-    }, 'Failed to extract HTML elements');
-}
 /**
  * Tags Finder - Find specific HTML tags
  */
@@ -296,70 +248,6 @@ export async function handleAjaxExtractor(args) {
         };
     }, 'Failed to extract AJAX requests');
 }
-/**
- * Fetch XHR - Capture fetch and XHR requests
- */
-export async function handleFetchXHR(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('fetch_xhr', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const duration = args.duration || 15000;
-        const forceReload = args.forceReload !== false; // Default true to capture initial requests
-        const xhrData = [];
-        // Capture requests too for completeness
-        const requestHandler = (request) => {
-            try {
-                const resourceType = request.resourceType();
-                if (resourceType === 'xhr' || resourceType === 'fetch') {
-                    // Optional: Log request if needed, but for now we focus on responses with bodies
-                }
-            }
-            catch (e) { }
-        };
-        const responseHandler = async (response) => {
-            const request = response.request();
-            const resourceType = request.resourceType();
-            if (resourceType === 'xhr' || resourceType === 'fetch') {
-                try {
-                    const body = await response.text();
-                    xhrData.push({
-                        url: response.url(),
-                        status: response.status(),
-                        statusText: response.statusText(),
-                        headers: response.headers(),
-                        method: request.method(),
-                        postData: request.postData(),
-                        body: body.substring(0, 5000), // Increased limit
-                        timestamp: new Date().toISOString(),
-                    });
-                }
-                catch (e) {
-                    // Response body not available
-                }
-            }
-        };
-        page.on('response', responseHandler);
-        if (forceReload) {
-            try {
-                await page.reload({ waitUntil: 'networkidle2', timeout: 30000 });
-            }
-            catch (e) {
-                // Continue even if reload times out
-            }
-        }
-        await sleep(duration);
-        page.off('response', responseHandler);
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Captured ${xhrData.length} Fetch/XHR responses\n\n${JSON.stringify(xhrData, null, 2)}`,
-                }],
-        };
-    }, 'Failed to fetch XHR');
-}
 /**
  * Network Recorder - Record all network activity
  */
@@ -729,369 +617,6 @@ export async function handleImageExtractorAdvanced(args) {
         };
     }, 'Failed to extract images');
 }
-/**
- * Video Source Extractor - Extract video sources
- */
-export async function handleVideoSourceExtractor(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('video_source_extractor', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const captureDuration = typeof args.captureDuration === 'number' ? args.captureDuration : 6000;
-        // DOM video elements + iframe detection
-        const videoData = await page.evaluate(() => {
-            const results = {
-                videos: [],
-                iframes: [],
-                embeddedPlayers: []
-            };
-            // 1. Direct video elements
-            const videoElements = document.querySelectorAll('video');
-            videoElements.forEach((video, idx) => {
-                const sources = [];
-                // Direct src
-                if (video.src) {
-                    sources.push({ src: video.src, type: video.type || 'unknown' });
-                }
-                // Source elements
-                video.querySelectorAll('source').forEach((source) => {
-                    sources.push({
-                        src: source.src,
-                        type: source.type || 'unknown',
-                    });
-                });
-                results.videos.push({
-                    index: idx,
-                    poster: video.poster || '',
-                    sources,
-                    duration: video.duration || 0,
-                    width: video.videoWidth || video.width || 0,
-                    height: video.videoHeight || video.height || 0,
-                    type: 'direct_video'
-                });
-            });
-            // 2. Iframe video sources
-            const iframes = document.querySelectorAll('iframe');
-            iframes.forEach((iframe, idx) => {
-                if (iframe.src) {
-                    results.iframes.push({
-                        index: idx,
-                        src: iframe.src,
-                        title: iframe.title || '',
-                        id: iframe.id,
-                        className: iframe.className,
-                        width: iframe.width,
-                        height: iframe.height,
-                        type: 'iframe_video'
-                    });
-                }
-            });
-            // 3. Video players with iframes inside
-            const playerContainers = document.querySelectorAll('[class*="player"], [id*="player"], [data-player]');
-            playerContainers.forEach((container, idx) => {
-                const iframe = container.querySelector('iframe');
-                const video = container.querySelector('video');
-                if (iframe || video) {
-                    results.embeddedPlayers.push({
-                        index: idx,
-                        hasVideo: !!video,
-                        hasIframe: !!iframe,
-                        videoSrc: video ? (video.src || video.currentSrc) : null,
-                        iframeSrc: iframe ? iframe.src : null,
-                        containerId: container.id,
-                        containerClass: container.className
-                    });
-                }
-            });
-            return results;
-        });
-        // Network capture for manifests and segments
-        const manifests = [];
-        const segments = [];
-        const respHandler = async (response) => {
-            try {
-                const url = response.url();
-                const ct = (response.headers()['content-type'] || '').toLowerCase();
-                if (/\.m3u8(\?|$)|\.mpd(\?|$)/i.test(url) || ct.includes('application/vnd.apple.mpegurl') || ct.includes('application/x-mpegurl')) {
-                    const content = await response.text().catch(() => '');
-                    manifests.push({ url, type: url.includes('.mpd') ? 'DASH' : 'HLS', status: response.status(), content: content.slice(0, 2000) });
-                }
-                else if (/\.ts(\?|$)|\.m4s(\?|$)|\.mp4(\?|$)/i.test(url)) {
-                    segments.push({ url, status: response.status(), size: response.headers()['content-length'] });
-                }
-            }
-            catch { }
-        };
-        page.on('response', respHandler);
-        // Best-effort: click center of first iframe to trigger playback
-        try {
-            const pt = await page.evaluate(() => {
-                const ifr = document.querySelector('iframe');
-                if (!ifr)
-                    return null;
-                const r = ifr.getBoundingClientRect();
-                return { x: r.left + r.width / 2, y: r.top + r.height / 2 };
-            });
-            if (pt)
-                await page.mouse.click(pt.x, pt.y);
-        }
-        catch { }
-        await sleep(captureDuration);
-        page.off('response', respHandler);
-        const result = {
-            ...videoData,
-            manifests,
-            segments,
-            summary: {
-                totalVideos: videoData.videos.length,
-                totalIframes: videoData.iframes.length,
-                totalEmbeddedPlayers: videoData.embeddedPlayers.length,
-                totalManifests: manifests.length,
-                totalSegments: segments.length
-            }
-        };
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Extracted video sources\n\n📊 Summary:\n  • Direct <video> elements: ${videoData.videos.length}\n  • Iframe sources: ${videoData.iframes.length}\n  • Embedded players: ${videoData.embeddedPlayers.length}\n  • Manifests: ${manifests.length}\n  • Segments: ${segments.length}\n\n${JSON.stringify(result, null, 2)}`,
-                }],
-        };
-    }, 'Failed to extract video sources');
-}
-/**
- * Video Player Extractor - Extract video player information
- */
-export async function handleVideoPlayerExtractor(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('video_player_extractor', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const players = await page.evaluate(() => {
-            const results = [];
-            // Common video player classes/IDs
-            const playerSelectors = [
-                '[class*="video-player"]',
-                '[class*="player"]',
-                '[id*="player"]',
-                '[data-player]',
-            ];
-            playerSelectors.forEach(selector => {
-                document.querySelectorAll(selector).forEach((el, idx) => {
-                    const videoEl = el.querySelector('video');
-                    const iframeEl = el.querySelector('iframe');
-                    if (videoEl || iframeEl) {
-                        const playerInfo = {
-                            selector,
-                            index: idx,
-                            hasVideo: !!videoEl,
-                            hasIframe: !!iframeEl,
-                            className: el.className,
-                            id: el.id,
-                        };
-                        // Video element info
-                        if (videoEl) {
-                            playerInfo.videoSrc = videoEl.src || videoEl.currentSrc || '';
-                            playerInfo.videoPoster = videoEl.poster || '';
-                            playerInfo.videoType = 'direct';
-                        }
-                        // Iframe element info
-                        if (iframeEl) {
-                            playerInfo.iframeSrc = iframeEl.src || '';
-                            playerInfo.iframeTitle = iframeEl.title || '';
-                            playerInfo.iframeAllow = iframeEl.getAttribute('allow') || '';
-                            playerInfo.videoType = videoEl ? 'hybrid' : 'iframe';
-                        }
-                        results.push(playerInfo);
-                    }
-                });
-            });
-            // Also check standalone iframes (ALL iframes that might be video players)
-            document.querySelectorAll('iframe').forEach((iframe, idx) => {
-                const src = (iframe.src || '').toLowerCase();
-                // Check if iframe is likely a video player
-                const isLikelyVideoIframe = src.includes('embed') ||
-                    src.includes('player') ||
-                    src.includes('video') ||
-                    src.includes('stream') ||
-                    iframe.allow?.includes('autoplay') ||
-                    iframe.allow?.includes('encrypted-media');
-                // Include ALL iframes if they have src and are likely video players
-                if (iframe.src && isLikelyVideoIframe) {
-                    // Check if already added
-                    const alreadyAdded = results.some(r => r.iframeSrc === iframe.src);
-                    if (!alreadyAdded) {
-                        results.push({
-                            selector: iframe.id ? `#${iframe.id}` : `iframe:nth-of-type(${idx + 1})`,
-                            index: idx,
-                            hasVideo: false,
-                            hasIframe: true,
-                            iframeSrc: iframe.src,
-                            iframeTitle: iframe.title || '',
-                            iframeAllow: iframe.getAttribute('allow') || '',
-                            className: iframe.className,
-                            id: iframe.id,
-                            videoType: 'standalone_iframe',
-                            isVisible: iframe.offsetWidth > 0 && iframe.offsetHeight > 0
-                        });
-                    }
-                }
-            });
-            return results;
-        });
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Found ${players.length} video players\n\n${JSON.stringify(players, null, 2)}`,
-                }],
-        };
-    }, 'Failed to extract video players');
-}
-/**
- * Video Player Hoster Finder - Detect video hosting platform
- */
-export async function handleVideoPlayerHosterFinder(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('video_player_hoster_finder', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const hosters = await page.evaluate(() => {
-            const results = [];
-            const iframes = document.querySelectorAll('iframe');
-            const platforms = {
-                // Popular platforms
-                'youtube.com': 'YouTube',
-                'youtu.be': 'YouTube',
-                'vimeo.com': 'Vimeo',
-                'dailymotion.com': 'Dailymotion',
-                'facebook.com': 'Facebook',
-                'twitter.com': 'Twitter',
-                'twitch.tv': 'Twitch',
-                'streamable.com': 'Streamable',
-                // Custom video hosting platforms
-                'gdmirrorbot': 'GD Mirror Bot',
-                'multimoviesshg.com': 'MultiMovies StreamHG',
-                'streamhg.com': 'StreamHG',
-                'techinmind.space': 'Tech In Mind Player',
-                'premilkyway.com': 'Premium Milky Way CDN',
-                'p2pplay.pro': 'P2P Play',
-                'rpmhub.site': 'RPM Share',
-                'uns.bio': 'UpnShare',
-                'smoothpre.com': 'EarnVids/SmoothPre',
-                'doodstream.com': 'DoodStream',
-                'streamtape.com': 'StreamTape',
-                'mixdrop.co': 'MixDrop',
-                'upstream.to': 'UpStream',
-                'vidcloud': 'VidCloud',
-                'fembed': 'Fembed',
-                'mp4upload': 'MP4Upload',
-            };
-            iframes.forEach((iframe, idx) => {
-                const src = iframe.src.toLowerCase();
-                for (const [domain, platform] of Object.entries(platforms)) {
-                    if (src.includes(domain)) {
-                        results.push({
-                            index: idx,
-                            platform,
-                            src: iframe.src,
-                            title: iframe.title || '',
-                        });
-                        break;
-                    }
-                }
-            });
-            return results;
-        });
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Found ${hosters.length} video hosting platforms\n\n${JSON.stringify(hosters, null, 2)}`,
-                }],
-        };
-    }, 'Failed to find video hosters');
-}
-/**
- * Original Video Hoster Finder - Find original video source
- */
-export async function handleOriginalVideoHosterFinder(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('original_video_hoster_finder', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const captureDuration = typeof args.captureDuration === 'number' ? args.captureDuration : 6000;
-        const videoData = await page.evaluate(() => {
-            const results = {
-                directVideos: [],
-                iframeVideos: [],
-                possibleSources: [],
-            };
-            // Direct video elements
-            document.querySelectorAll('video').forEach((video) => {
-                const src = video.src || video.currentSrc;
-                if (src) {
-                    results.directVideos.push({ src, type: 'direct', poster: video.poster });
-                }
-                video.querySelectorAll('source').forEach((source) => {
-                    if (source.src) {
-                        results.directVideos.push({ src: source.src, type: source.type, quality: source.dataset.quality || 'unknown' });
-                    }
-                });
-            });
-            // Iframe videos
-            document.querySelectorAll('iframe').forEach((iframe) => {
-                if (iframe.src) {
-                    results.iframeVideos.push({ src: iframe.src, type: 'iframe' });
-                }
-            });
-            return results;
-        });
-        // Network-derived hosts (m3u8/mpd)
-        const hosts = new Set();
-        const respHandler = (response) => {
-            try {
-                const url = response.url();
-                if (/\.m3u8(\?|$)|\.mpd(\?|$)/i.test(url)) {
-                    try {
-                        hosts.add(new URL(url).hostname);
-                    }
-                    catch { }
-                }
-            }
-            catch { }
-        };
-        page.on('response', respHandler);
-        // Kick the player once
-        try {
-            const pt = await page.evaluate(() => {
-                const ifr = document.querySelector('iframe');
-                if (!ifr)
-                    return null;
-                const r = ifr.getBoundingClientRect();
-                return { x: r.left + r.width / 2, y: r.top + r.height / 2 };
-            });
-            if (pt)
-                await page.mouse.click(pt.x, pt.y);
-        }
-        catch { }
-        await sleep(captureDuration);
-        page.off('response', respHandler);
-        const possibleSources = Array.from(hosts).map(h => ({ host: h }));
-        const enriched = { ...videoData, possibleSources };
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Video sources found\n\n${JSON.stringify(enriched, null, 2)}`,
-                }],
-        };
-    }, 'Failed to find original video hoster');
-}
 /**
  * URL Redirect Tracer - Trace URL redirects
  */

package/dist/index.js

@@ -1,8 +1,79 @@
 #!/usr/bin/env node
-import 'dotenv/config';
+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)
+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";
@@ -17,7 +88,7 @@ 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
@@ -31,15 +102,13 @@ import { handleOCREngine, handleAudioCaptchaSolver, handlePuzzleCaptchaHandler,
 // 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)
@@ -115,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;
@@ -131,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 || {});
@@ -191,9 +254,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;
@@ -203,9 +263,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;
@@ -218,22 +275,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;

package/dist/tool-definitions.js

@@ -336,18 +336,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 +386,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',
@@ -616,16 +591,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 +678,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 +711,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 +731,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,9 +745,6 @@ 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',

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

@@ -1,7 +1,6 @@
 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';
@@ -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");
@@ -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,11 +1,11 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.17.9",
+  "version": "2.17.11",
   "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",
   "scripts": {
-    "preinstall": "npm view brave-real-puppeteer-core version > .latest-version 2>&1 || echo 'Version check skipped'",
+    "preinstall": "npm update && node scripts/check-version.js",
     "postinstall": "node scripts/patch-puppeteer-screen-recorder.cjs",
     "clean": "rimraf dist",
     "clean:cache": "npm cache clean --force",

package/scripts/check-version.js

@@ -0,0 +1,33 @@
+import { exec } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const packageName = 'brave-real-puppeteer-core';
+const outputFile = path.join(process.cwd(), '.latest-version');
+
+console.log(`Checking latest version for ${packageName}...`);
+
+exec(`npm view ${packageName} version`, (error, stdout, stderr) => {
+    if (error) {
+        console.error(`Error checking version: ${error.message}`);
+        console.log('Version check skipped');
+        return;
+    }
+
+    const version = stdout.trim();
+    if (version) {
+        console.log(`Latest version found: ${version}`);
+        try {
+            fs.writeFileSync(outputFile, version);
+            console.log(`Saved to ${outputFile}`);
+        } catch (err) {
+            console.error(`Failed to write .latest-version: ${err.message}`);
+        }
+    } else {
+        console.log('Version check returned empty. Skipped.');
+    }
+});

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" }] };
-}