brave-real-browser-mcp-server 2.12.8 → 2.12.10

package/dist/handlers/advanced-video-media-handlers.js

@@ -275,32 +275,97 @@ export async function handleVideoPlayPushSource(args) {
             }
         };
         page.on('response', responseHandler);
-        // Try to find and click play button
+        // Enhanced play button selectors
         const playSelectors = [
             'button[class*="play"]',
             '[class*="play-button"]',
+            '[class*="btn-play"]',
             '[aria-label*="Play"]',
+            '[aria-label*="play"]',
+            'button[title*="Play"]',
+            'button[title*="play"]',
             '.video-play',
             '#play-button',
+            '#playButton',
+            '.play-btn',
+            'video', // Direct video element
+            // Icon-based play buttons
+            '[class*="fa-play"]',
+            '[class*="icon-play"]',
+            'i[class*="play"]',
         ];
         let clicked = false;
+        let clickMethod = 'none';
+        // Try clicking play buttons
         for (const selector of playSelectors) {
             try {
-                await page.click(selector, { timeout: 2000 });
-                clicked = true;
-                break;
+                if (selector === 'video') {
+                    // Try to play video directly
+                    const played = await page.evaluate(() => {
+                        const videos = document.querySelectorAll('video');
+                        let success = false;
+                        videos.forEach((video) => {
+                            try {
+                                video.play();
+                                success = true;
+                            }
+                            catch (e) { }
+                        });
+                        return success;
+                    });
+                    if (played) {
+                        clicked = true;
+                        clickMethod = 'video.play()';
+                        break;
+                    }
+                }
+                else {
+                    const element = await page.$(selector);
+                    if (element) {
+                        await element.click();
+                        clicked = true;
+                        clickMethod = selector;
+                        break;
+                    }
+                }
             }
             catch (e) {
                 // Try next selector
             }
         }
-        // Wait for sources to load
-        await sleep(3000);
+        // If no play button found, try clicking center of iframe
+        if (!clicked) {
+            try {
+                const iframeClicked = await page.evaluate(() => {
+                    const iframe = document.querySelector('iframe');
+                    if (iframe) {
+                        const rect = iframe.getBoundingClientRect();
+                        const event = new MouseEvent('click', {
+                            view: window,
+                            bubbles: true,
+                            cancelable: true,
+                            clientX: rect.left + rect.width / 2,
+                            clientY: rect.top + rect.height / 2
+                        });
+                        iframe.dispatchEvent(event);
+                        return true;
+                    }
+                    return false;
+                });
+                if (iframeClicked) {
+                    clicked = true;
+                    clickMethod = 'iframe-click';
+                }
+            }
+            catch (e) { }
+        }
+        // Wait for sources to load (longer wait for iframe-based)
+        await sleep(5000);
         page.off('response', responseHandler);
         return {
             content: [{
                     type: 'text',
-                    text: `✅ Video sources captured\n\nPlay button clicked: ${clicked}\nSources found: ${videoSources.length}\n\n${JSON.stringify(videoSources, null, 2)}`,
+                    text: `✅ Video sources captured\n\n📊 Status:\n  • Interaction attempted: ${clicked ? 'Yes' : 'No'}\n  • Method: ${clickMethod}\n  • Sources found: ${videoSources.length}\n\n${videoSources.length > 0 ? JSON.stringify(videoSources, null, 2) : '💡 Tip: This site may use iframe-embedded videos. Try navigating to the iframe URL and using advanced_video_extraction.'}`,
                 }],
         };
     }, 'Failed to capture video play sources');
@@ -316,46 +381,119 @@ export async function handleVideoPlayButtonClick(args) {
         });
         const page = getCurrentPage();
         const customSelector = args.selector;
-        const playSelectors = customSelector ? [customSelector] : [
+        // Enhanced play button selectors
+        const defaultSelectors = [
             'button[class*="play"]',
             '[class*="play-button"]',
+            '[class*="btn-play"]',
             '[aria-label*="Play"]',
+            '[aria-label*="play"]',
             'button[title*="Play"]',
+            'button[title*="play"]',
             '.video-play',
+            '.play-btn',
             '#play-button',
-            'video', // Direct video element
+            '#playButton',
+            // Icon-based
+            'button i[class*="play"]',
+            'button i[class*="fa-play"]',
+            '[class*="fa-play"]',
+            '[class*="icon-play"]',
+            // Video element
+            'video',
         ];
+        const playSelectors = customSelector ? [customSelector] : defaultSelectors;
+        const results = {
+            attempted: [],
+            clicked: false,
+            method: 'none',
+            selector: null
+        };
         for (const selector of playSelectors) {
             try {
-                const element = await page.$(selector);
-                if (element) {
-                    if (selector === 'video') {
-                        // For video element, use play() method
-                        await page.evaluate(() => {
-                            const video = document.querySelector('video');
-                            if (video)
+                if (selector === 'video') {
+                    // For video element, use play() method
+                    const played = await page.evaluate(() => {
+                        const videos = document.querySelectorAll('video');
+                        let success = false;
+                        videos.forEach((video) => {
+                            try {
                                 video.play();
+                                success = true;
+                            }
+                            catch (e) { }
                         });
+                        return success;
+                    });
+                    results.attempted.push({ selector, found: played });
+                    if (played) {
+                        results.clicked = true;
+                        results.method = 'video.play()';
+                        results.selector = selector;
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `✅ Play button clicked\n\n📊 Details:\n  • Method: ${results.method}\n  • Selector: ${selector}\n  • Attempts: ${results.attempted.length}`,
+                                }],
+                        };
                     }
-                    else {
+                }
+                else {
+                    const element = await page.$(selector);
+                    results.attempted.push({ selector, found: !!element });
+                    if (element) {
                         await element.click();
+                        results.clicked = true;
+                        results.method = 'element.click()';
+                        results.selector = selector;
+                        return {
+                            content: [{
+                                    type: 'text',
+                                    text: `✅ Play button clicked\n\n📊 Details:\n  • Method: ${results.method}\n  • Selector: ${selector}\n  • Attempts: ${results.attempted.length}`,
+                                }],
+                        };
                     }
-                    return {
-                        content: [{
-                                type: 'text',
-                                text: `✅ Play button clicked: ${selector}`,
-                            }],
-                    };
                 }
             }
             catch (e) {
-                // Try next selector
+                results.attempted.push({ selector, error: String(e) });
             }
         }
+        // Fallback: Try clicking iframe center
+        try {
+            const iframeInfo = await page.evaluate(() => {
+                const iframe = document.querySelector('iframe');
+                if (iframe) {
+                    const rect = iframe.getBoundingClientRect();
+                    return {
+                        found: true,
+                        x: rect.left + rect.width / 2,
+                        y: rect.top + rect.height / 2,
+                        src: iframe.src
+                    };
+                }
+                return { found: false };
+            });
+            if (iframeInfo.found) {
+                await page.mouse.click(iframeInfo.x, iframeInfo.y);
+                results.clicked = true;
+                results.method = 'iframe-click';
+                results.selector = 'iframe (center)';
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `✅ Play action attempted\n\n📊 Details:\n  • Method: iframe center click\n  • Iframe src: ${iframeInfo.src}\n  • Position: (${Math.round(iframeInfo.x)}, ${Math.round(iframeInfo.y)})\n\n💡 Tip: For iframe-based videos, navigate to iframe URL first`,
+                        }],
+                };
+            }
+        }
+        catch (e) {
+            results.attempted.push({ selector: 'iframe-fallback', error: String(e) });
+        }
         return {
             content: [{
                     type: 'text',
-                    text: `❌ No play button found`,
+                    text: `⚠️ No direct play button found\n\n📊 Attempts: ${results.attempted.length}\n💡 Suggestions:\n  • This site uses iframe-embedded videos\n  • Use iframe_extractor to find video iframe\n  • Navigate to iframe URL\n  • Then use advanced_video_extraction\n\nAttempted selectors:\n${results.attempted.map((a) => `  • ${a.selector}: ${a.found ? '✓ found' : '✗ not found'}`).join('\n')}`,
                 }],
         };
     }, 'Failed to click play button');
@@ -449,13 +587,17 @@ export async function handleNetworkRecordingFinder(args) {
                 const isStreamAsset = /\.m3u8(\?|$)|\.mpd(\?|$)|\.ts(\?|$)|\.vtt(\?|$)|\.mp4(\?|$)|\.webm(\?|$)/i.test(urlLower) ||
                     contentType.includes('application/vnd.apple.mpegurl') ||
                     contentType.includes('application/x-mpegurl');
-                if (filterType === 'video' && (contentType.includes('video') || resourceType === 'media' || isStreamAsset)) {
+                // Video API detection (like /api/v1/video, /stream, etc.)
+                const isVideoAPI = urlLower.includes('/video') ||
+                    urlLower.includes('/stream') ||
+                    (contentType.includes('application/octet-stream') && urlLower.includes('video'));
+                if (filterType === 'video' && (contentType.includes('video') || resourceType === 'media' || isStreamAsset || isVideoAPI)) {
                     shouldRecord = true;
                 }
                 else if (filterType === 'audio' && contentType.includes('audio')) {
                     shouldRecord = true;
                 }
-                else if (filterType === 'media' && (contentType.includes('video') || contentType.includes('audio') || isStreamAsset)) {
+                else if (filterType === 'media' && (contentType.includes('video') || contentType.includes('audio') || isStreamAsset || isVideoAPI)) {
                     shouldRecord = true;
                 }
                 if (shouldRecord) {
@@ -556,19 +698,32 @@ export async function handleNetworkRecordingExtractors(args) {
             apis: [],
         };
         let totalResponses = 0;
-        const responseHandler = async (response) => {
-            totalResponses++;
-            const url = response.url();
-            const contentType = response.headers()['content-type'] || '';
+        const responseHandler = (response) => {
             try {
-                // Video files
-                if (contentType.includes('video') || url.includes('.mp4') || url.includes('.webm')) {
+                totalResponses++;
+                const url = response.url();
+                const contentType = response.headers()['content-type'] || '';
+                // Video files (includes API video requests)
+                const isVideoFile = contentType.includes('video') ||
+                    url.includes('.mp4') ||
+                    url.includes('.webm') ||
+                    url.includes('.mov') ||
+                    url.includes('.avi') ||
+                    url.includes('.mkv');
+                // Video API patterns (like cherry.upns.online/api/v1/video)
+                const isVideoAPI = url.toLowerCase().includes('/video') ||
+                    url.toLowerCase().includes('/stream') ||
+                    url.toLowerCase().includes('/api') ||
+                    (contentType.includes('application/octet-stream') && url.includes('video'));
+                if (isVideoFile || isVideoAPI) {
                     if (verbose)
                         console.log(`[Extractor] 🎥 Video found: ${url.substring(0, 80)}`);
                     extractedData.videos.push({
                         url,
                         contentType,
                         size: response.headers()['content-length'],
+                        status: response.status(),
+                        type: isVideoAPI ? 'api' : 'direct',
                     });
                 }
                 // Audio files
@@ -580,30 +735,31 @@ export async function handleNetworkRecordingExtractors(args) {
                         contentType,
                     });
                 }
-                // Manifest files (HLS, DASH)
+                // Manifest files (HLS, DASH) - Don't try to read content in handler
                 if (url.includes('.m3u8') || url.includes('.mpd')) {
                     if (verbose)
                         console.log(`[Extractor] 📜 Manifest found: ${url.substring(0, 80)}`);
-                    const text = await response.text();
                     extractedData.manifests.push({
                         url,
                         type: url.includes('.m3u8') ? 'HLS' : 'DASH',
-                        content: text.substring(0, 500),
+                        contentType,
+                        status: response.status(),
                     });
                 }
-                // API responses with video data
-                if (contentType.includes('json') && (url.includes('video') || url.includes('media'))) {
+                // API responses with video data - Don't try to parse in handler
+                if (contentType.includes('json') && (url.includes('video') || url.includes('media') || url.includes('api') || url.includes('player'))) {
                     if (verbose)
                         console.log(`[Extractor] 📡 API found: ${url.substring(0, 80)}`);
-                    const json = await response.json();
                     extractedData.apis.push({
                         url,
-                        data: json,
+                        contentType,
+                        status: response.status(),
                     });
                 }
             }
             catch (e) {
-                // Response not available
+                if (verbose)
+                    console.log(`[Extractor] ⚠️ Error processing response: ${e}`);
             }
         };
         console.log(`[Extractor] 🎬 Starting extraction (${duration}ms)${navigateTo ? ` + navigating to ${navigateTo}` : ''}`);
@@ -768,6 +924,7 @@ export async function handleVideosSelectors(args) {
         const selectors = await page.evaluate(() => {
             const results = {
                 videoElements: [],
+                iframeElements: [],
                 playerContainers: [],
                 controlButtons: [],
                 sources: [],
@@ -781,15 +938,36 @@ export async function handleVideosSelectors(args) {
                     selector,
                     src: video.src,
                     hasControls: video.controls,
+                    type: 'direct_video'
                 });
             });
-            // Player containers
+            // Iframe elements (video sources)
+            document.querySelectorAll('iframe').forEach((iframe, idx) => {
+                const selector = iframe.id ? `#${iframe.id}` :
+                    iframe.className ? `.${iframe.className.split(' ')[0]}` :
+                        `iframe:nth-of-type(${idx + 1})`;
+                if (iframe.src) {
+                    results.iframeElements.push({
+                        selector,
+                        src: iframe.src,
+                        title: iframe.title || '',
+                        allow: iframe.getAttribute('allow') || '',
+                        type: 'iframe_video'
+                    });
+                }
+            });
+            // Player containers (check for both video and iframe)
             ['[class*="player"]', '[id*="player"]', '[data-player]'].forEach(sel => {
                 document.querySelectorAll(sel).forEach((el) => {
+                    const hasVideo = !!el.querySelector('video');
+                    const hasIframe = !!el.querySelector('iframe');
                     results.playerContainers.push({
                         selector: sel,
                         id: el.id,
                         className: el.className,
+                        hasVideo,
+                        hasIframe,
+                        contentType: hasVideo ? 'video' : hasIframe ? 'iframe' : 'empty'
                     });
                 });
             });
@@ -957,43 +1135,143 @@ export async function handleVideoDownloadButtonFinders(args) {
         const page = getCurrentPage();
         const downloadButtons = await page.evaluate(() => {
             const results = [];
+            const foundElements = new Set(); // Avoid duplicates
+            // Enhanced patterns for download buttons
             const buttonPatterns = [
-                'button[class*="download"]',
-                'a[class*="download"]',
+                // Direct download attributes
+                'a[download]',
+                'button[download]',
                 '[data-download]',
-                'button:contains("Download")',
-                'a:contains("Download")',
-                'button:contains("Save")',
+                '[data-download-url]',
+                '[data-file]',
+                '[data-link]',
+                // Class-based
+                'a[class*="download"]',
+                'button[class*="download"]',
+                'a[class*="btn-download"]',
+                '[class*="download-button"]',
+                '[class*="download-link"]',
+                '[class*="dlvideoLinks"]',
+                '[class*="btn-info"]',
+                '[class*="btn-primary"]',
+                // ID-based
+                '[id*="download"]',
+                '[id*="btn-download"]',
+                '[id*="downloadButton"]',
+                '[id*="Download"]',
+                // Href patterns
+                'a[href*="download"]',
+                'a[href*=".mp4"]',
+                'a[href*=".webm"]',
+                'a[href*=".mkv"]',
+                'a[href*=".avi"]',
+                'a[href*="/file/"]',
+                'a[href*="/stream/"]',
+                'a[href*="ddn."]',
+                'a[href*="igx."]',
+                // Onclick patterns
                 '[onclick*="download"]',
-                '[href*="download"]',
+                '[onclick*="Download"]',
+                '[onclick*="window.open"]',
+                // Icon-based (common patterns)
+                'a i[class*="download"]',
+                'button i[class*="download"]',
+                '.fa-download',
+                '.icon-download',
+                // Form submit buttons
+                'input[type="submit"][value*="Download"]',
+                'input[type="submit"][value*="Stream"]',
+                'button[type="submit"]',
+            ];
+            // Text-based search (case insensitive) - ENHANCED with GDL patterns
+            const searchTexts = [
+                'download', 'descargar', 'télécharger', 'baixar', 'скачать', 'save', 'get',
+                'gdl', '5gdl', '4gdl', '3gdl', '2gdl', '1gdl', '⚡5gdl', // GDL variations with lightning
+                'dl', 'down', 'grab', 'fetch', 'stream', 'watch', 'play', 'click'
             ];
             buttonPatterns.forEach(pattern => {
                 try {
-                    document.querySelectorAll(pattern).forEach((btn, idx) => {
+                    document.querySelectorAll(pattern).forEach((btn) => {
+                        // Avoid duplicates
+                        if (foundElements.has(btn))
+                            return;
+                        foundElements.add(btn);
                         const isVisible = btn.offsetWidth > 0 && btn.offsetHeight > 0;
+                        const text = btn.textContent?.trim() || '';
+                        const href = btn.href || btn.getAttribute('href') || '';
                         results.push({
                             pattern,
-                            index: idx,
-                            text: btn.textContent?.trim() || '',
-                            href: btn.href || btn.getAttribute('href'),
-                            dataDownload: btn.dataset.download,
+                            text,
+                            href,
+                            dataDownload: btn.dataset.download || btn.getAttribute('data-download'),
                             isVisible,
                             tag: btn.tagName.toLowerCase(),
                             className: btn.className,
                             id: btn.id,
+                            hasDownloadAttr: btn.hasAttribute('download'),
+                            onclick: btn.onclick ? 'present' : 'none'
                         });
                     });
                 }
                 catch (e) {
-                    // Pattern not supported
+                    // Pattern not supported or error
+                }
+            });
+            // Additional: Search for buttons/links with download-related text
+            document.querySelectorAll('a, button').forEach((el) => {
+                if (foundElements.has(el))
+                    return;
+                const text = el.textContent?.toLowerCase() || '';
+                const hasDownloadText = searchTexts.some(term => text.includes(term));
+                if (hasDownloadText) {
+                    foundElements.add(el);
+                    const isVisible = el.offsetWidth > 0 && el.offsetHeight > 0;
+                    results.push({
+                        pattern: 'text-based-search',
+                        text: el.textContent?.trim() || '',
+                        href: el.href || el.getAttribute('href') || '',
+                        dataDownload: el.dataset.download,
+                        isVisible,
+                        tag: el.tagName.toLowerCase(),
+                        className: el.className,
+                        id: el.id,
+                        matchedText: searchTexts.find(term => text.includes(term))
+                    });
                 }
             });
             return results;
         });
+        // Include option to filter by visibility
+        const includeHidden = args.includeHidden !== false; // Default: include hidden
+        const filteredButtons = includeHidden ? downloadButtons : downloadButtons.filter((btn) => btn.isVisible);
+        // If no buttons found, provide helpful context
+        let additionalInfo = '';
+        if (filteredButtons.length === 0) {
+            const pageContext = await page.evaluate(() => {
+                const allButtons = document.querySelectorAll('button, input[type="submit"], [role="button"]');
+                const allLinks = document.querySelectorAll('a[href]');
+                const allForms = document.querySelectorAll('form');
+                return {
+                    totalButtons: allButtons.length,
+                    totalLinks: allLinks.length,
+                    totalForms: allForms.length,
+                    sampleButtons: Array.from(allButtons).slice(0, 5).map((b) => ({
+                        text: b.textContent?.trim().substring(0, 50) || '',
+                        id: b.id,
+                        className: b.className
+                    })),
+                    sampleLinks: Array.from(allLinks).slice(0, 5).map((l) => ({
+                        text: l.textContent?.trim().substring(0, 50) || '',
+                        href: l.href?.substring(0, 100) || ''
+                    }))
+                };
+            });
+            additionalInfo = `\n\n💡 No download buttons found. Page has:\n  • ${pageContext.totalButtons} buttons\n  • ${pageContext.totalLinks} links\n  • ${pageContext.totalForms} forms\n\nSample elements:\n${JSON.stringify(pageContext, null, 2)}`;
+        }
         return {
             content: [{
                     type: 'text',
-                    text: `✅ Found ${downloadButtons.length} download buttons\n\n${JSON.stringify(downloadButtons, null, 2)}`,
+                    text: `✅ Found ${filteredButtons.length} download buttons (${downloadButtons.length} total, ${downloadButtons.filter((b) => !b.isVisible).length} hidden)\n\n${JSON.stringify(filteredButtons, null, 2)}${additionalInfo}`,
                 }],
         };
     }, 'Failed to find download buttons');

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

@@ -175,7 +175,7 @@ export async function handleXpathLinks(args) {
     }, 'Failed to find XPath links');
 }
 /**
- * AJAX Extractor - Extract AJAX/XHR request data
+ * AJAX Extractor - Extract AJAX/XHR request data with responses
  */
 export async function handleAjaxExtractor(args) {
     return await withErrorHandling(async () => {
@@ -186,29 +186,112 @@ export async function handleAjaxExtractor(args) {
         const page = getCurrentPage();
         const duration = args.duration || 15000;
         const url = args.url;
+        const forceReload = args.forceReload !== false; // Force reload by default
+        const includeResponses = args.includeResponses !== false;
         const requests = [];
+        const responses = [];
         const requestHandler = (request) => {
-            const resourceType = request.resourceType();
-            if (resourceType === 'xhr' || resourceType === 'fetch') {
-                requests.push({
-                    url: request.url(),
-                    method: request.method(),
-                    resourceType,
-                    headers: request.headers(),
-                    timestamp: new Date().toISOString(),
-                });
+            try {
+                const resourceType = request.resourceType();
+                if (resourceType === 'xhr' || resourceType === 'fetch') {
+                    requests.push({
+                        url: request.url(),
+                        method: request.method(),
+                        resourceType,
+                        headers: request.headers(),
+                        postData: request.postData(),
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
+            catch (e) {
+                // Ignore errors
+            }
+        };
+        const responseHandler = async (response) => {
+            try {
+                const resourceType = response.request().resourceType();
+                if (resourceType === 'xhr' || resourceType === 'fetch') {
+                    let body = null;
+                    if (includeResponses) {
+                        try {
+                            const text = await response.text();
+                            // Try to parse as JSON
+                            try {
+                                body = JSON.parse(text);
+                            }
+                            catch {
+                                body = text.substring(0, 500); // First 500 chars if not JSON
+                            }
+                        }
+                        catch { }
+                    }
+                    responses.push({
+                        url: response.url(),
+                        status: response.status(),
+                        statusText: response.statusText(),
+                        headers: response.headers(),
+                        body,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
+            catch (e) {
+                // Ignore errors
             }
         };
         page.on('request', requestHandler);
+        if (includeResponses) {
+            page.on('response', responseHandler);
+        }
         if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2' });
+            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
+        }
+        else if (forceReload && !url) {
+            // Force reload current page to capture AJAX requests
+            try {
+                await page.reload({ waitUntil: 'networkidle2', timeout: 30000 });
+            }
+            catch { }
+        }
+        // Trigger interactions to generate AJAX requests
+        try {
+            await page.evaluate(() => {
+                // Scroll to trigger lazy loading
+                window.scrollTo(0, document.body.scrollHeight / 2);
+                window.scrollTo(0, document.body.scrollHeight);
+                // Click visible buttons that might trigger AJAX
+                const clickableElements = document.querySelectorAll('button, [role="button"], .btn, [onclick]');
+                clickableElements.forEach((el) => {
+                    if (el.offsetWidth > 0 && el.offsetHeight > 0) {
+                        const text = el.textContent?.toLowerCase() || '';
+                        // Click safe elements (avoid dangerous buttons like delete, remove, etc.)
+                        if (text.includes('load') || text.includes('more') || text.includes('show')) {
+                            try {
+                                el.click();
+                            }
+                            catch { }
+                        }
+                    }
+                });
+            });
         }
+        catch { }
         await sleep(duration);
         page.off('request', requestHandler);
+        if (includeResponses) {
+            page.off('response', responseHandler);
+        }
+        const combined = {
+            totalRequests: requests.length,
+            totalResponses: responses.length,
+            requests: requests.slice(0, 50), // First 50
+            responses: responses.slice(0, 50), // First 50
+        };
         return {
             content: [{
                     type: 'text',
-                    text: `✅ Captured ${requests.length} AJAX/XHR requests\n\n${JSON.stringify(requests, null, 2)}`,
+                    text: `✅ Captured ${requests.length} AJAX/XHR requests and ${responses.length} responses\n\n${JSON.stringify(combined, null, 2)}${requests.length === 0 ? '\n\n💡 Tip: Page may not have AJAX requests, or use {"forceReload": true} to capture from page load' : ''}`,
                 }],
         };
     }, 'Failed to extract AJAX requests');
@@ -269,40 +352,109 @@ export async function handleNetworkRecorder(args) {
         const page = getCurrentPage();
         const duration = args.duration || 20000;
         const filterTypes = args.filterTypes || ['video', 'xhr', 'fetch', 'media'];
+        const navigateUrl = args.navigateUrl; // Optional: Navigate to URL to capture from start
+        const clearCache = args.clearCache || false;
+        const forceReload = args.forceReload !== false; // Force reload by default to capture events
         const networkActivity = [];
         const requestHandler = (request) => {
-            const resourceType = request.resourceType();
-            if (filterTypes.includes('all') || filterTypes.includes(resourceType)) {
-                networkActivity.push({
-                    type: 'request',
-                    url: request.url(),
-                    method: request.method(),
-                    resourceType,
-                    timestamp: new Date().toISOString(),
-                });
+            try {
+                const resourceType = request.resourceType();
+                if (filterTypes.includes('all') || filterTypes.includes(resourceType)) {
+                    networkActivity.push({
+                        type: 'request',
+                        url: request.url(),
+                        method: request.method(),
+                        resourceType,
+                        headers: request.headers(),
+                        postData: request.postData(),
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
+            catch (e) {
+                // Ignore request errors
             }
         };
-        const responseHandler = (response) => {
-            const resourceType = response.request().resourceType();
-            if (filterTypes.includes('all') || filterTypes.includes(resourceType)) {
-                networkActivity.push({
-                    type: 'response',
-                    url: response.url(),
-                    status: response.status(),
-                    resourceType,
-                    timestamp: new Date().toISOString(),
-                });
+        const responseHandler = async (response) => {
+            try {
+                const resourceType = response.request().resourceType();
+                if (filterTypes.includes('all') || filterTypes.includes(resourceType)) {
+                    const headers = response.headers();
+                    networkActivity.push({
+                        type: 'response',
+                        url: response.url(),
+                        status: response.status(),
+                        statusText: response.statusText(),
+                        resourceType,
+                        contentType: headers['content-type'] || '',
+                        contentLength: headers['content-length'] || '',
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            }
+            catch (e) {
+                // Ignore response errors
             }
         };
+        // Start monitoring FIRST
         page.on('request', requestHandler);
         page.on('response', responseHandler);
+        // Optional: Clear cache for fresh load
+        if (clearCache) {
+            try {
+                const client = await page.target().createCDPSession();
+                await client.send('Network.clearBrowserCache');
+                await client.detach();
+            }
+            catch { }
+        }
+        // Optional: Navigate to URL (capturing from start)
+        if (navigateUrl) {
+            try {
+                await page.goto(navigateUrl, { waitUntil: 'networkidle2', timeout: 30000 });
+            }
+            catch (e) {
+                // Continue monitoring even if navigation fails
+            }
+        }
+        else if (forceReload && !navigateUrl) {
+            // Force reload current page to capture network events
+            const currentUrl = page.url();
+            try {
+                await page.reload({ waitUntil: 'networkidle2', timeout: 30000 });
+            }
+            catch (e) {
+                // Continue monitoring even if reload fails
+            }
+        }
+        // Also trigger any lazy-loaded content by scrolling
+        try {
+            await page.evaluate(() => {
+                window.scrollTo(0, document.body.scrollHeight / 2);
+                window.scrollTo(0, document.body.scrollHeight);
+                window.scrollTo(0, 0);
+            });
+        }
+        catch { }
         await sleep(duration);
         page.off('request', requestHandler);
         page.off('response', responseHandler);
+        const summary = {
+            totalEvents: networkActivity.length,
+            requests: networkActivity.filter(e => e.type === 'request').length,
+            responses: networkActivity.filter(e => e.type === 'response').length,
+            byResourceType: networkActivity.reduce((acc, e) => {
+                acc[e.resourceType] = (acc[e.resourceType] || 0) + 1;
+                return acc;
+            }, {})
+        };
+        const tipMessage = networkActivity.length === 0 ?
+            `\n\n💡 Tips:\n  • Page was already loaded. Use {"navigateUrl": "https://example.com"} to capture from start\n  • Use {"filterTypes": ["all"]} to capture all network activity\n  • Use {"clearCache": true} for fresh page load` :
+            '';
         return {
             content: [{
                     type: 'text',
-                    text: `✅ Recorded ${networkActivity.length} network events\n\n${JSON.stringify(networkActivity.slice(0, 50), null, 2)}${networkActivity.length > 50 ? '\n\n... (showing first 50)' : ''}`,
+                    text: `✅ Recorded ${networkActivity.length} network events\n\n📊 Summary:\n${JSON.stringify(summary, null, 2)}\n\nEvents (first 50):\n${JSON.stringify(networkActivity.slice(0, 50), null, 2)}${networkActivity.length > 50 ? '\n\n... (showing first 50 of ' + networkActivity.length + ')' : ''}${tipMessage}`,
                 }],
         };
     }, 'Failed to record network');
@@ -384,13 +536,58 @@ export async function handleRegexPatternFinder(args) {
         }
         const matches = await page.evaluate(({ pattern, flags }) => {
             const regex = new RegExp(pattern, flags);
+            const results = [];
+            // 1. Search in body HTML
             const html = document.body.innerHTML;
-            const results = Array.from(html.matchAll(regex));
-            return results.slice(0, 100).map((match, idx) => ({
-                index: idx,
-                match: match[0],
-                groups: match.slice(1),
-            }));
+            Array.from(html.matchAll(regex)).forEach(match => {
+                results.push({
+                    source: 'html',
+                    match: match[0],
+                    groups: match.slice(1),
+                    index: match.index
+                });
+            });
+            // 2. Search in script tags
+            document.querySelectorAll('script').forEach((script, scriptIdx) => {
+                const content = script.textContent || '';
+                Array.from(content.matchAll(regex)).forEach(match => {
+                    results.push({
+                        source: `script[${scriptIdx}]`,
+                        match: match[0],
+                        groups: match.slice(1),
+                        index: match.index,
+                        scriptSrc: script.src || 'inline'
+                    });
+                });
+            });
+            // 3. Search in element attributes (href, src, data-* etc.)
+            document.querySelectorAll('*').forEach((el) => {
+                ['href', 'src', 'data-video', 'data-src', 'data-url'].forEach(attr => {
+                    const value = el.getAttribute(attr);
+                    if (value) {
+                        Array.from(value.matchAll(regex)).forEach(match => {
+                            results.push({
+                                source: `attribute[${attr}]`,
+                                match: match[0],
+                                groups: match.slice(1),
+                                element: el.tagName.toLowerCase(),
+                                attribute: attr,
+                                fullValue: value
+                            });
+                        });
+                    }
+                });
+            });
+            // Dedupe and limit
+            const seen = new Set();
+            const unique = results.filter(r => {
+                const key = `${r.source}:${r.match}`;
+                if (seen.has(key))
+                    return false;
+                seen.add(key);
+                return true;
+            });
+            return unique.slice(0, 100);
         }, { pattern, flags });
         return {
             content: [{
@@ -523,10 +720,15 @@ export async function handleVideoSourceExtractor(args) {
         });
         const page = getCurrentPage();
         const captureDuration = typeof args.captureDuration === 'number' ? args.captureDuration : 6000;
-        // DOM video elements
-        const videos = await page.evaluate(() => {
+        // DOM video elements + iframe detection
+        const videoData = await page.evaluate(() => {
+            const results = {
+                videos: [],
+                iframes: [],
+                embeddedPlayers: []
+            };
+            // 1. Direct video elements
             const videoElements = document.querySelectorAll('video');
-            const results = [];
             videoElements.forEach((video, idx) => {
                 const sources = [];
                 // Direct src
@@ -540,15 +742,49 @@ export async function handleVideoSourceExtractor(args) {
                         type: source.type || 'unknown',
                     });
                 });
-                results.push({
+                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
@@ -584,11 +820,22 @@ export async function handleVideoSourceExtractor(args) {
         catch { }
         await sleep(captureDuration);
         page.off('response', respHandler);
-        const result = { videos, manifests, segments };
+        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${JSON.stringify(result, null, 2)}`,
+                    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');
@@ -614,20 +861,65 @@ export async function handleVideoPlayerExtractor(args) {
             ];
             playerSelectors.forEach(selector => {
                 document.querySelectorAll(selector).forEach((el, idx) => {
-                    const videoEl = el.querySelector('video') || el.querySelector('iframe');
-                    if (videoEl) {
-                        results.push({
+                    const videoEl = el.querySelector('video');
+                    const iframeEl = el.querySelector('iframe');
+                    if (videoEl || iframeEl) {
+                        const playerInfo = {
                             selector,
                             index: idx,
-                            hasVideo: !!el.querySelector('video'),
-                            hasIframe: !!el.querySelector('iframe'),
-                            src: videoEl.src || videoEl.currentSrc || '',
+                            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 {
@@ -652,6 +944,7 @@ export async function handleVideoPlayerHosterFinder(args) {
             const results = [];
             const iframes = document.querySelectorAll('iframe');
             const platforms = {
+                // Popular platforms
                 'youtube.com': 'YouTube',
                 'youtu.be': 'YouTube',
                 'vimeo.com': 'Vimeo',
@@ -660,6 +953,23 @@ export async function handleVideoPlayerHosterFinder(args) {
                 '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();

package/dist/transports/sse-transport.js

@@ -113,7 +113,17 @@ export class SseTransport {
                     error: errorMessage,
                     timestamp: new Date().toISOString(),
                 });
-                res.status(500).json({ success: false, error: errorMessage });
+                // Return errors in MCP format (status 200 with isError flag)
+                res.json({
+                    success: true,
+                    result: {
+                        isError: true,
+                        content: [{
+                                type: 'text',
+                                text: errorMessage
+                            }]
+                    }
+                });
             }
         });
         // Browser automation endpoints with SSE notifications

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.12.8",
+  "version": "2.12.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",
@@ -37,11 +37,11 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.20.2",
-    "@types/turndown": "^5.0.5",
+    "@types/turndown": "^5.0.6",
     "ajv": "^8.12.0",
     "axios": "^1.6.5",
     "brave-real-browser": "^1.5.102",
-    "brave-real-launcher": "^1.2.18",
+    "brave-real-launcher": "^1.2.19",
     "brave-real-puppeteer-core": "^24.26.1",
     "cheerio": "^1.0.0-rc.12",
     "chrono-node": "^2.7.0",