brave-real-browser-mcp-server 2.9.9 → 2.9.10

package/dist/handlers/browser-handlers.js

@@ -49,7 +49,7 @@ export async function handleBrowserClose() {
     });
 }
 // Workflow validation wrapper
-async function withWorkflowValidation(toolName, args, operation) {
+export async function withWorkflowValidation(toolName, args, operation) {
     // Validate workflow state before execution
     const validation = validateWorkflow(toolName, args);
     // Defensive check: if validation is undefined or null, allow execution (test environment)

package/dist/handlers/specialized-tools-handlers.js

@@ -0,0 +1,464 @@
+// Specialized Tools Handlers for Video Extraction, Links Finding, AJAX, and User Agent Tools
+import { getBrowser, getPage } from '../browser-manager.js';
+import { withWorkflowValidation } from './browser-handlers.js';
+import { withErrorHandling } from '../system-utils.js';
+// Links Finders Handler
+export async function handleLinksFinders(args) {
+    return withWorkflowValidation('links_finders', args, async () => {
+        return withErrorHandling(async () => {
+            const browser = getBrowser();
+            const page = getPage();
+            if (!browser || !page) {
+                throw new Error('Browser not initialized. Call browser_init first.');
+            }
+            const { includeExternal = true, includeInternal = true, includeMediaLinks = true, includeEmailPhone = false, filterDomains = [] } = args;
+            const links = await page.evaluate((options) => {
+                const { includeExternal, includeInternal, includeMediaLinks, includeEmailPhone, filterDomains } = options;
+                const results = [];
+                const currentDomain = window.location.hostname;
+                // Find all anchor links
+                const anchors = document.querySelectorAll('a[href]');
+                anchors.forEach((anchor) => {
+                    const href = anchor.href;
+                    const isExternal = !href.includes(currentDomain);
+                    if ((isExternal && includeExternal) || (!isExternal && includeInternal)) {
+                        if (filterDomains.length === 0 || filterDomains.some((domain) => href.includes(domain))) {
+                            results.push({
+                                type: 'anchor',
+                                url: href,
+                                text: anchor.textContent?.trim() || '',
+                                isExternal,
+                                title: anchor.title || ''
+                            });
+                        }
+                    }
+                });
+                // Find media links if requested
+                if (includeMediaLinks) {
+                    const mediaElements = document.querySelectorAll('img[src], video[src], audio[src], source[src]');
+                    mediaElements.forEach((element) => {
+                        results.push({
+                            type: 'media',
+                            url: element.src,
+                            mediaType: element.tagName.toLowerCase(),
+                            alt: element.alt || '',
+                            title: element.title || ''
+                        });
+                    });
+                }
+                // Find email and phone links if requested
+                if (includeEmailPhone) {
+                    const emailPhoneLinks = document.querySelectorAll('a[href^="mailto:"], a[href^="tel:"]');
+                    emailPhoneLinks.forEach((link) => {
+                        results.push({
+                            type: link.href.startsWith('mailto:') ? 'email' : 'phone',
+                            url: link.href,
+                            text: link.textContent?.trim() || ''
+                        });
+                    });
+                }
+                return results;
+            }, { includeExternal, includeInternal, includeMediaLinks, includeEmailPhone, filterDomains });
+            return {
+                success: true,
+                links,
+                total: links.length,
+                message: `Found ${links.length} links on the page`
+            };
+        }, 'Failed to find links');
+    });
+}
+// Video Play Sources Finder Handler
+export async function handleVideoPlaySourcesFinder(args) {
+    return withWorkflowValidation('video_play_sources_finder', args, async () => {
+        return withErrorHandling(async () => {
+            const browser = getBrowser();
+            const page = getPage();
+            if (!browser || !page) {
+                throw new Error('Browser not initialized. Call browser_init first.');
+            }
+            const { includeHLS = true, includeDASH = true, includeDirectMP4 = true, includeBlob = true, recordingDuration = 15000 } = args;
+            // Start network monitoring
+            const networkSources = [];
+            await page.setRequestInterception(true);
+            page.on('request', (request) => {
+                request.continue();
+            });
+            page.on('response', async (response) => {
+                try {
+                    const url = response.url();
+                    const contentType = response.headers()['content-type'] || '';
+                    // Check for video sources
+                    const isVideoSource = ((includeHLS && (url.includes('.m3u8') || contentType.includes('application/x-mpegURL'))) ||
+                        (includeDASH && (url.includes('.mpd') || contentType.includes('application/dash+xml'))) ||
+                        (includeDirectMP4 && (url.includes('.mp4') || contentType.includes('video/mp4'))) ||
+                        (includeBlob && url.startsWith('blob:')));
+                    if (isVideoSource) {
+                        networkSources.push({
+                            url,
+                            type: url.includes('.m3u8') ? 'HLS' :
+                                url.includes('.mpd') ? 'DASH' :
+                                    url.includes('.mp4') ? 'MP4' :
+                                        url.startsWith('blob:') ? 'BLOB' : 'UNKNOWN',
+                            contentType,
+                            size: response.headers()['content-length'] || 'unknown',
+                            status: response.status()
+                        });
+                    }
+                }
+                catch (error) {
+                    // Ignore response processing errors
+                }
+            });
+            // Wait for network activity
+            await new Promise(resolve => setTimeout(resolve, recordingDuration));
+            await page.setRequestInterception(false);
+            // Also search DOM for video sources
+            const domSources = await page.evaluate((options) => {
+                const { includeHLS, includeDASH, includeDirectMP4, includeBlob } = options;
+                const sources = [];
+                // Video elements
+                const videos = document.querySelectorAll('video');
+                videos.forEach((video) => {
+                    if (video.src)
+                        sources.push({ url: video.src, type: 'VIDEO_TAG', source: 'dom' });
+                    const sourceTags = video.querySelectorAll('source');
+                    sourceTags.forEach((source) => {
+                        if (source.src)
+                            sources.push({ url: source.src, type: source.type || 'VIDEO_SOURCE', source: 'dom' });
+                    });
+                });
+                // Search for sources in page text/scripts
+                const scripts = document.querySelectorAll('script');
+                scripts.forEach((script) => {
+                    const content = script.textContent || '';
+                    if (includeHLS) {
+                        const hlsMatches = content.match(/https?:\/\/[^\s"']+\.m3u8[^\s"']*/g);
+                        if (hlsMatches) {
+                            hlsMatches.forEach(url => sources.push({ url, type: 'HLS', source: 'script' }));
+                        }
+                    }
+                    if (includeDASH) {
+                        const dashMatches = content.match(/https?:\/\/[^\s"']+\.mpd[^\s"']*/g);
+                        if (dashMatches) {
+                            dashMatches.forEach(url => sources.push({ url, type: 'DASH', source: 'script' }));
+                        }
+                    }
+                    if (includeDirectMP4) {
+                        const mp4Matches = content.match(/https?:\/\/[^\s"']+\.mp4[^\s"']*/g);
+                        if (mp4Matches) {
+                            mp4Matches.forEach(url => sources.push({ url, type: 'MP4', source: 'script' }));
+                        }
+                    }
+                });
+                return sources;
+            }, { includeHLS, includeDASH, includeDirectMP4, includeBlob });
+            const allSources = [...networkSources, ...domSources];
+            const uniqueSources = allSources.filter((source, index, array) => array.findIndex(s => s.url === source.url) === index);
+            return {
+                success: true,
+                sources: uniqueSources,
+                networkSources: networkSources.length,
+                domSources: domSources.length,
+                total: uniqueSources.length,
+                message: `Found ${uniqueSources.length} video play sources`
+            };
+        }, 'Failed to find video play sources');
+    });
+}
+// Video Player Hostars Sources Finder Handler
+export async function handleVideoPlayerHostarsSourcesFinder(args) {
+    return withWorkflowValidation('video_player_hostars_sources_finder', args, async () => {
+        return withErrorHandling(async () => {
+            const browser = getBrowser();
+            const page = getPage();
+            if (!browser || !page) {
+                throw new Error('Browser not initialized. Call browser_init first.');
+            }
+            const { platforms = ['all'], extractEmbedCodes = true, extractAPIKeys = false } = args;
+            const hostingSources = await page.evaluate((options) => {
+                const { platforms, extractEmbedCodes, extractAPIKeys } = options;
+                const sources = [];
+                // Define hosting platform patterns
+                const hostingPatterns = {
+                    youtube: [
+                        /(?:youtube\.com|youtu\.be)/i,
+                        /\/embed\/([a-zA-Z0-9_-]+)/,
+                        /watch\?v=([a-zA-Z0-9_-]+)/
+                    ],
+                    vimeo: [
+                        /vimeo\.com/i,
+                        /\/video\/(\d+)/,
+                        /player\.vimeo\.com\/video\/(\d+)/
+                    ],
+                    dailymotion: [
+                        /dailymotion\.com/i,
+                        /\/video\/([a-zA-Z0-9_-]+)/
+                    ],
+                    twitch: [
+                        /twitch\.tv/i,
+                        /\/videos\/(\d+)/,
+                        /\/embed\/([a-zA-Z0-9_-]+)/
+                    ],
+                    facebook: [
+                        /facebook\.com/i,
+                        /\/watch/,
+                        /\/videos/
+                    ],
+                    instagram: [
+                        /instagram\.com/i,
+                        /\/p\/([a-zA-Z0-9_-]+)/
+                    ],
+                    tiktok: [
+                        /tiktok\.com/i,
+                        /@[^\/]+\/video\/(\d+)/
+                    ]
+                };
+                // Search in iframes
+                const iframes = document.querySelectorAll('iframe');
+                iframes.forEach((iframe) => {
+                    const src = iframe.src;
+                    if (!src)
+                        return;
+                    for (const [platform, patterns] of Object.entries(hostingPatterns)) {
+                        if (platforms.includes('all') || platforms.includes(platform)) {
+                            if (patterns[0].test(src)) {
+                                const videoId = src.match(patterns[1] || patterns[0]);
+                                sources.push({
+                                    platform,
+                                    url: src,
+                                    videoId: videoId ? videoId[1] : null,
+                                    type: 'iframe',
+                                    embedCode: extractEmbedCodes ? iframe.outerHTML : null
+                                });
+                            }
+                        }
+                    }
+                });
+                // Search in links
+                const links = document.querySelectorAll('a[href]');
+                links.forEach((link) => {
+                    const href = link.href;
+                    for (const [platform, patterns] of Object.entries(hostingPatterns)) {
+                        if (platforms.includes('all') || platforms.includes(platform)) {
+                            if (patterns[0].test(href)) {
+                                const videoId = href.match(patterns[1] || patterns[0]);
+                                sources.push({
+                                    platform,
+                                    url: href,
+                                    videoId: videoId ? videoId[1] : null,
+                                    type: 'link',
+                                    linkText: link.textContent?.trim() || ''
+                                });
+                            }
+                        }
+                    }
+                });
+                // Search in script content for API calls and video IDs
+                const scripts = document.querySelectorAll('script');
+                scripts.forEach((script) => {
+                    const content = script.textContent || '';
+                    for (const [platform, patterns] of Object.entries(hostingPatterns)) {
+                        if (platforms.includes('all') || platforms.includes(platform)) {
+                            const matches = content.match(patterns[1] || patterns[0]);
+                            if (matches) {
+                                matches.forEach(match => {
+                                    sources.push({
+                                        platform,
+                                        url: match,
+                                        type: 'script',
+                                        source: 'javascript'
+                                    });
+                                });
+                            }
+                        }
+                    }
+                });
+                return sources;
+            }, { platforms, extractEmbedCodes, extractAPIKeys });
+            return {
+                success: true,
+                sources: hostingSources,
+                platforms: [...new Set(hostingSources.map((s) => s.platform))],
+                total: hostingSources.length,
+                message: `Found ${hostingSources.length} hosting platform sources`
+            };
+        }, 'Failed to find video hosting sources');
+    });
+}
+// AJAX Finders Handler
+export async function handleAjaxFinders(args) {
+    return withWorkflowValidation('ajax_finders', args, async () => {
+        return withErrorHandling(async () => {
+            const browser = getBrowser();
+            const page = getPage();
+            if (!browser || !page) {
+                throw new Error('Browser not initialized. Call browser_init first.');
+            }
+            const { interceptXHR = true, interceptFetch = true, recordResponses = true, filterByContentType = ['application/json', 'text/html', 'application/xml'], monitoringDuration = 10000 } = args;
+            const ajaxRequests = [];
+            // Intercept network requests
+            await page.setRequestInterception(true);
+            page.on('request', (request) => {
+                const resourceType = request.resourceType();
+                if (resourceType === 'xhr' || resourceType === 'fetch') {
+                    ajaxRequests.push({
+                        url: request.url(),
+                        method: request.method(),
+                        headers: request.headers(),
+                        postData: request.postData(),
+                        resourceType,
+                        timestamp: Date.now(),
+                        type: 'request'
+                    });
+                }
+                request.continue();
+            });
+            if (recordResponses) {
+                page.on('response', async (response) => {
+                    try {
+                        const request = response.request();
+                        const resourceType = request.resourceType();
+                        if (resourceType === 'xhr' || resourceType === 'fetch') {
+                            const contentType = response.headers()['content-type'] || '';
+                            const shouldRecord = filterByContentType.length === 0 ||
+                                filterByContentType.some((type) => contentType.includes(type));
+                            if (shouldRecord) {
+                                let responseBody = '';
+                                try {
+                                    responseBody = await response.text();
+                                }
+                                catch (e) {
+                                    responseBody = '[Unable to read response body]';
+                                }
+                                ajaxRequests.push({
+                                    url: response.url(),
+                                    status: response.status(),
+                                    headers: response.headers(),
+                                    contentType,
+                                    body: responseBody.substring(0, 10000), // Limit body size
+                                    timestamp: Date.now(),
+                                    type: 'response'
+                                });
+                            }
+                        }
+                    }
+                    catch (error) {
+                        // Ignore response processing errors
+                    }
+                });
+            }
+            // Wait for AJAX activity
+            await new Promise(resolve => setTimeout(resolve, monitoringDuration));
+            await page.setRequestInterception(false);
+            // Group requests and responses
+            const groupedRequests = ajaxRequests.reduce((acc, item) => {
+                const key = item.url;
+                if (!acc[key])
+                    acc[key] = { requests: [], responses: [] };
+                if (item.type === 'request') {
+                    acc[key].requests.push(item);
+                }
+                else {
+                    acc[key].responses.push(item);
+                }
+                return acc;
+            }, {});
+            return {
+                success: true,
+                ajaxRequests: groupedRequests,
+                totalRequests: ajaxRequests.filter(r => r.type === 'request').length,
+                totalResponses: ajaxRequests.filter(r => r.type === 'response').length,
+                uniqueEndpoints: Object.keys(groupedRequests).length,
+                message: `Monitored AJAX activity for ${monitoringDuration}ms`
+            };
+        }, 'Failed to monitor AJAX requests');
+    });
+}
+// User Agent Finders Handler
+export async function handleUserAgentFinders(args) {
+    return withWorkflowValidation('user_agent_finders', args, async () => {
+        return withErrorHandling(async () => {
+            const browser = getBrowser();
+            const page = getPage();
+            if (!browser || !page) {
+                throw new Error('Browser not initialized. Call browser_init first.');
+            }
+            const { detectFingerprinting = true, analyzeHeaders = true, findCustomUA = true, trackingDetection = true } = args;
+            const userAgentInfo = await page.evaluate((options) => {
+                const { detectFingerprinting, analyzeHeaders, findCustomUA, trackingDetection } = options;
+                const info = {};
+                // Get current user agent
+                info.currentUserAgent = navigator.userAgent;
+                info.platform = navigator.platform;
+                info.language = navigator.language;
+                info.languages = navigator.languages;
+                // Detect fingerprinting attempts
+                if (detectFingerprinting) {
+                    info.fingerprinting = {
+                        canvas: !!document.createElement('canvas').getContext,
+                        webgl: !!document.createElement('canvas').getContext('webgl'),
+                        audioContext: !!window.AudioContext || !!window.webkitAudioContext,
+                        webrtc: !!(window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection),
+                        deviceMemory: navigator.deviceMemory || 'unknown',
+                        hardwareConcurrency: navigator.hardwareConcurrency || 'unknown',
+                        maxTouchPoints: navigator.maxTouchPoints || 0
+                    };
+                }
+                // Check for custom UA requirements in scripts
+                if (findCustomUA) {
+                    const scripts = document.querySelectorAll('script');
+                    const uaRequirements = [];
+                    scripts.forEach(script => {
+                        const content = script.textContent || '';
+                        // Look for User-Agent checks
+                        const uaPatterns = [
+                            /userAgent\s*[=!]==?\s*['"]([^'"]+)['"]/gi,
+                            /navigator\.userAgent\.indexOf\(['"]([^'"]+)['"]\)/gi,
+                            /User-Agent:\s*['"]([^'"]+)['"]/gi
+                        ];
+                        uaPatterns.forEach(pattern => {
+                            const matches = content.match(pattern);
+                            if (matches) {
+                                uaRequirements.push(...matches);
+                            }
+                        });
+                    });
+                    info.customUARequirements = [...new Set(uaRequirements)];
+                }
+                return info;
+            }, { detectFingerprinting, analyzeHeaders, findCustomUA, trackingDetection });
+            // Get actual request headers from network
+            const requestHeaders = {};
+            if (analyzeHeaders) {
+                await page.setRequestInterception(true);
+                const headerPromise = new Promise((resolve) => {
+                    page.once('request', (request) => {
+                        resolve(request.headers());
+                        request.continue();
+                    });
+                });
+                // Trigger a request to capture headers
+                await page.reload({ waitUntil: 'domcontentloaded' });
+                const headers = await headerPromise;
+                requestHeaders.actual = headers;
+                await page.setRequestInterception(false);
+            }
+            return {
+                success: true,
+                userAgentInfo,
+                requestHeaders,
+                message: 'User-Agent analysis completed'
+            };
+        }, 'Failed to analyze User-Agent');
+    });
+}
+// Export handlers for all specialized tools
+export const specializedToolsHandlers = {
+    links_finders: handleLinksFinders,
+    video_play_sources_finder: handleVideoPlaySourcesFinder,
+    video_player_hostars_sources_finder: handleVideoPlayerHostarsSourcesFinder,
+    ajax_finders: handleAjaxFinders,
+    user_agent_finders: handleUserAgentFinders,
+    // Add more handlers as needed...
+};

package/dist/index.js

@@ -45,6 +45,8 @@ import { handleFullPageScreenshot, handleElementScreenshot, handlePDFGeneration,
 import { handleRESTAPIEndpointFinder, handleWebhookSupport, handleAllWebsiteAPIFinder } from './handlers/api-integration-handlers.js';
 // Import video extraction handlers
 import { handleHtmlElementsExtraction, handleNetworkVideoExtraction, handleVideoSelectorGeneration, handleComprehensiveVideoExtraction, handleURLRedirectTrace } from './handlers/video-extraction-handlers.js';
+// Import specialized tools handlers
+import { handleLinksFinders, handleVideoPlaySourcesFinder, handleVideoPlayerHostarsSourcesFinder, handleAjaxFinders, handleUserAgentFinders } from './handlers/specialized-tools-handlers.js';
 console.error('🔍 [DEBUG] All modules loaded successfully');
 console.error(`🔍 [DEBUG] Server info: ${JSON.stringify(SERVER_INFO)}`);
 console.error(`🔍 [DEBUG] Available tools: ${TOOLS.length} tools loaded`);
@@ -246,6 +248,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return await handleComprehensiveVideoExtraction(args);
             case TOOL_NAMES.URL_REDIRECT_TRACE:
                 return await handleURLRedirectTrace(args);
+            // Specialized Video and Links Extraction Tools
+            case TOOL_NAMES.LINKS_FINDERS:
+                return await handleLinksFinders(args);
+            case TOOL_NAMES.VIDEO_PLAY_SOURCES_FINDER:
+                return await handleVideoPlaySourcesFinder(args);
+            case TOOL_NAMES.VIDEO_PLAYER_HOSTARS_SOURCES_FINDER:
+                return await handleVideoPlayerHostarsSourcesFinder(args);
+            case TOOL_NAMES.AJAX_FINDERS:
+                return await handleAjaxFinders(args);
+            case TOOL_NAMES.USER_AGENT_FINDERS:
+                return await handleUserAgentFinders(args);
+            // Regex Pattern Finders (alias for existing regex_pattern_matcher)
+            case TOOL_NAMES.REGEX_PATTERN_FINDERS:
+                return await handleRegexPatternMatcher(args);
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/tool-definitions.js

@@ -1106,6 +1106,435 @@ export const TOOLS = [
             required: ['url'],
         },
     },
+    // Specialized Video and Links Extraction Tools
+    {
+        name: 'links_finders',
+        description: 'Find and extract all types of links from page (HTTP, HTTPS, FTP, email, phone, etc.)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                includeExternal: {
+                    type: 'boolean',
+                    description: 'Include external links',
+                    default: true
+                },
+                includeInternal: {
+                    type: 'boolean',
+                    description: 'Include internal links',
+                    default: true
+                },
+                includeMediaLinks: {
+                    type: 'boolean',
+                    description: 'Include media file links',
+                    default: true
+                },
+                includeEmailPhone: {
+                    type: 'boolean',
+                    description: 'Include email and phone links',
+                    default: false
+                },
+                filterDomains: {
+                    type: 'array',
+                    description: 'Filter links by specific domains',
+                    items: { type: 'string' }
+                }
+            }
+        }
+    },
+    {
+        name: 'video_play_sources_finder',
+        description: 'Find direct video play sources and streaming URLs',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                includeHLS: {
+                    type: 'boolean',
+                    description: 'Include HLS (.m3u8) sources',
+                    default: true
+                },
+                includeDASH: {
+                    type: 'boolean',
+                    description: 'Include DASH (.mpd) sources',
+                    default: true
+                },
+                includeDirectMP4: {
+                    type: 'boolean',
+                    description: 'Include direct MP4 sources',
+                    default: true
+                },
+                includeBlob: {
+                    type: 'boolean',
+                    description: 'Include blob URLs',
+                    default: true
+                },
+                recordingDuration: {
+                    type: 'number',
+                    description: 'Network recording duration (ms)',
+                    default: 15000
+                }
+            }
+        }
+    },
+    {
+        name: 'video_player_hostars_sources_finder',
+        description: 'Find video sources from popular hosting platforms (YouTube, Vimeo, Dailymotion, etc.)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                platforms: {
+                    type: 'array',
+                    description: 'Specific platforms to search',
+                    items: {
+                        type: 'string',
+                        enum: ['youtube', 'vimeo', 'dailymotion', 'twitch', 'facebook', 'instagram', 'tiktok', 'all']
+                    },
+                    default: ['all']
+                },
+                extractEmbedCodes: {
+                    type: 'boolean',
+                    description: 'Extract embed codes',
+                    default: true
+                },
+                extractAPIKeys: {
+                    type: 'boolean',
+                    description: 'Extract API keys from network requests',
+                    default: false
+                }
+            }
+        }
+    },
+    {
+        name: 'video_sources_links_finders',
+        description: 'Comprehensive video source links extraction from all possible locations',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                searchInJS: {
+                    type: 'boolean',
+                    description: 'Search in JavaScript code',
+                    default: true
+                },
+                searchInJSON: {
+                    type: 'boolean',
+                    description: 'Search in JSON responses',
+                    default: true
+                },
+                searchInCSS: {
+                    type: 'boolean',
+                    description: 'Search in CSS files',
+                    default: false
+                },
+                searchInComments: {
+                    type: 'boolean',
+                    description: 'Search in HTML comments',
+                    default: true
+                },
+                deepScan: {
+                    type: 'boolean',
+                    description: 'Enable deep scanning mode',
+                    default: true
+                }
+            }
+        }
+    },
+    {
+        name: 'video_download_page',
+        description: 'Find and navigate to video download pages',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                searchKeywords: {
+                    type: 'array',
+                    description: 'Keywords to identify download pages',
+                    items: { type: 'string' },
+                    default: ['download', 'save', 'get', 'grab']
+                },
+                followRedirects: {
+                    type: 'boolean',
+                    description: 'Follow redirects to find actual download pages',
+                    default: true
+                },
+                maxDepth: {
+                    type: 'number',
+                    description: 'Maximum navigation depth',
+                    default: 3
+                }
+            }
+        }
+    },
+    {
+        name: 'video_sources_extracts',
+        description: 'Extract and process video sources with metadata',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                includeMetadata: {
+                    type: 'boolean',
+                    description: 'Include video metadata (duration, resolution, codec)',
+                    default: true
+                },
+                validateSources: {
+                    type: 'boolean',
+                    description: 'Validate source URLs accessibility',
+                    default: false
+                },
+                extractThumbnails: {
+                    type: 'boolean',
+                    description: 'Extract thumbnail URLs',
+                    default: true
+                },
+                extractSubtitles: {
+                    type: 'boolean',
+                    description: 'Extract subtitle tracks',
+                    default: true
+                }
+            }
+        }
+    },
+    {
+        name: 'video_download_button',
+        description: 'Find and interact with video download buttons',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                buttonSelectors: {
+                    type: 'array',
+                    description: 'Custom button selectors to search',
+                    items: { type: 'string' }
+                },
+                clickButton: {
+                    type: 'boolean',
+                    description: 'Automatically click found download buttons',
+                    default: false
+                },
+                waitAfterClick: {
+                    type: 'number',
+                    description: 'Wait time after clicking (ms)',
+                    default: 3000
+                }
+            }
+        }
+    },
+    {
+        name: 'video_play_push_sources',
+        description: 'Find video sources from push/streaming services',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                includeWebSocket: {
+                    type: 'boolean',
+                    description: 'Include WebSocket streaming sources',
+                    default: true
+                },
+                includeWebRTC: {
+                    type: 'boolean',
+                    description: 'Include WebRTC sources',
+                    default: true
+                },
+                includePush: {
+                    type: 'boolean',
+                    description: 'Include server push sources',
+                    default: true
+                },
+                monitoringDuration: {
+                    type: 'number',
+                    description: 'Duration to monitor for push sources (ms)',
+                    default: 20000
+                }
+            }
+        }
+    },
+    {
+        name: 'original_video_hosters_finder',
+        description: 'Find original video hosting sources bypassing CDNs',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                bypassCDN: {
+                    type: 'boolean',
+                    description: 'Attempt to bypass CDN and find original sources',
+                    default: true
+                },
+                traceOrigin: {
+                    type: 'boolean',
+                    description: 'Trace back to original hosting domain',
+                    default: true
+                },
+                includeBackupSources: {
+                    type: 'boolean',
+                    description: 'Include backup/mirror sources',
+                    default: true
+                },
+                deepNetworkAnalysis: {
+                    type: 'boolean',
+                    description: 'Perform deep network analysis',
+                    default: true
+                }
+            }
+        }
+    },
+    {
+        name: 'ajax_finders',
+        description: 'Find and monitor AJAX requests and endpoints',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                interceptXHR: {
+                    type: 'boolean',
+                    description: 'Intercept XMLHttpRequest calls',
+                    default: true
+                },
+                interceptFetch: {
+                    type: 'boolean',
+                    description: 'Intercept Fetch API calls',
+                    default: true
+                },
+                recordResponses: {
+                    type: 'boolean',
+                    description: 'Record AJAX response data',
+                    default: true
+                },
+                filterByContentType: {
+                    type: 'array',
+                    description: 'Filter by response content types',
+                    items: { type: 'string' },
+                    default: ['application/json', 'text/html', 'application/xml']
+                },
+                monitoringDuration: {
+                    type: 'number',
+                    description: 'Duration to monitor AJAX calls (ms)',
+                    default: 10000
+                }
+            }
+        }
+    },
+    {
+        name: 'ajax_extracts',
+        description: 'Extract and process data from AJAX responses',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                parseJSON: {
+                    type: 'boolean',
+                    description: 'Parse JSON responses',
+                    default: true
+                },
+                parseXML: {
+                    type: 'boolean',
+                    description: 'Parse XML responses',
+                    default: true
+                },
+                extractVideoSources: {
+                    type: 'boolean',
+                    description: 'Extract video sources from AJAX responses',
+                    default: true
+                },
+                extractAPIEndpoints: {
+                    type: 'boolean',
+                    description: 'Extract API endpoints from responses',
+                    default: true
+                },
+                saveRawData: {
+                    type: 'boolean',
+                    description: 'Save raw response data',
+                    default: false
+                }
+            }
+        }
+    },
+    {
+        name: 'user_agent_finders',
+        description: 'Find and analyze User-Agent strings and browser fingerprinting',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                detectFingerprinting: {
+                    type: 'boolean',
+                    description: 'Detect browser fingerprinting attempts',
+                    default: true
+                },
+                analyzeHeaders: {
+                    type: 'boolean',
+                    description: 'Analyze all browser headers',
+                    default: true
+                },
+                findCustomUA: {
+                    type: 'boolean',
+                    description: 'Find custom User-Agent requirements',
+                    default: true
+                },
+                trackingDetection: {
+                    type: 'boolean',
+                    description: 'Detect tracking mechanisms',
+                    default: true
+                }
+            }
+        }
+    },
+    {
+        name: 'user_agent_extracts',
+        description: 'Extract and generate User-Agent strings for bypassing restrictions',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                generateMobile: {
+                    type: 'boolean',
+                    description: 'Generate mobile User-Agent strings',
+                    default: true
+                },
+                generateDesktop: {
+                    type: 'boolean',
+                    description: 'Generate desktop User-Agent strings',
+                    default: true
+                },
+                generateBot: {
+                    type: 'boolean',
+                    description: 'Generate bot/crawler User-Agent strings',
+                    default: false
+                },
+                targetPlatforms: {
+                    type: 'array',
+                    description: 'Target specific platforms',
+                    items: {
+                        type: 'string',
+                        enum: ['windows', 'mac', 'linux', 'android', 'ios']
+                    },
+                    default: ['windows', 'mac', 'android']
+                }
+            }
+        }
+    },
+    {
+        name: 'regex_pattern_finders',
+        description: 'Advanced regex pattern finding and matching (alias for regex_pattern_matcher)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                patterns: {
+                    type: 'array',
+                    description: 'Array of regex patterns to search',
+                    items: { type: 'string' }
+                },
+                flags: {
+                    type: 'string',
+                    description: 'Regex flags (g, i, m, s, u, y)',
+                    default: 'gi'
+                },
+                extractGroups: {
+                    type: 'boolean',
+                    description: 'Extract capture groups from matches',
+                    default: true
+                },
+                searchScope: {
+                    type: 'string',
+                    enum: ['html', 'text', 'scripts', 'network', 'all'],
+                    description: 'Scope of search',
+                    default: 'all'
+                }
+            },
+            required: ['patterns']
+        }
+    },
 ];
 // Tool name constants for type safety
 export const TOOL_NAMES = {
@@ -1189,6 +1618,21 @@ export const TOOL_NAMES = {
     VIDEO_SELECTOR_GENERATION: 'video_selector_generation',
     COMPREHENSIVE_VIDEO_EXTRACTION: 'comprehensive_video_extraction',
     URL_REDIRECT_TRACE: 'url_redirect_trace',
+    // Specialized Video and Links Extraction Tools
+    LINKS_FINDERS: 'links_finders',
+    VIDEO_PLAY_SOURCES_FINDER: 'video_play_sources_finder',
+    VIDEO_PLAYER_HOSTARS_SOURCES_FINDER: 'video_player_hostars_sources_finder',
+    VIDEO_SOURCES_LINKS_FINDERS: 'video_sources_links_finders',
+    VIDEO_DOWNLOAD_PAGE: 'video_download_page',
+    VIDEO_SOURCES_EXTRACTS: 'video_sources_extracts',
+    VIDEO_DOWNLOAD_BUTTON: 'video_download_button',
+    VIDEO_PLAY_PUSH_SOURCES: 'video_play_push_sources',
+    ORIGINAL_VIDEO_HOSTERS_FINDER: 'original_video_hosters_finder',
+    AJAX_FINDERS: 'ajax_finders',
+    AJAX_EXTRACTS: 'ajax_extracts',
+    USER_AGENT_FINDERS: 'user_agent_finders',
+    USER_AGENT_EXTRACTS: 'user_agent_extracts',
+    REGEX_PATTERN_FINDERS: 'regex_pattern_finders',
 };
 // Tool categories for organization
 export const TOOL_CATEGORIES = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.9.9",
+  "version": "2.9.10",
   "description": "MCP server for brave-real-browser",
   "type": "module",
   "main": "dist/index.js",