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

package/dist/browser-manager.js

@@ -907,3 +907,10 @@ export function getContentPriorityConfig() {
 export function updateContentPriorityConfig(config) {
     contentPriorityConfig = { ...contentPriorityConfig, ...config };
 }
+// Additional convenience exports for video extraction modules
+export function getBrowser() {
+    return browserInstance;
+}
+export function getPage() {
+    return pageInstance;
+}

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

@@ -0,0 +1,373 @@
+// Video extraction handlers for MCP tools
+import { ExtractionStrategy } from '../video-extraction/types.js';
+import { htmlElementsFinder, videoSelectors } from '../video-extraction/dom-extractors.js';
+import { networkRecorder, requestChainTracer } from '../video-extraction/network-extractors.js';
+import { validateWorkflow, recordExecution } from '../workflow-validation.js';
+import { withErrorHandling } from '../system-utils.js';
+import { getPage } from '../browser-manager.js';
+// Wrapper function for workflow validation
+async function withVideoExtractionWorkflowValidation(toolName, operation) {
+    // Validate workflow state
+    const workflowResult = validateWorkflow(toolName);
+    if (!workflowResult.isValid) {
+        throw new Error(`Workflow validation failed for ${toolName}: ${workflowResult.errorMessage}`);
+    }
+    try {
+        const result = await operation();
+        recordExecution(toolName, {}, true);
+        return result;
+    }
+    catch (error) {
+        recordExecution(toolName, {}, false, error instanceof Error ? error.message : String(error));
+        throw error;
+    }
+}
+// HTML Elements Video Extractor
+export async function handleHtmlElementsExtraction(args) {
+    return withVideoExtractionWorkflowValidation('html_elements_extraction', async () => {
+        return withErrorHandling(async () => {
+            const startTime = Date.now();
+            const allSources = [];
+            const errors = [];
+            const warnings = [];
+            try {
+                // Initialize HTML elements finder
+                await htmlElementsFinder.initialize();
+                // Extract from video tags
+                if (args.extractVideoTags !== false) {
+                    try {
+                        const videoTagSources = await htmlElementsFinder.findVideoTags();
+                        allSources.push(...videoTagSources);
+                    }
+                    catch (error) {
+                        errors.push({
+                            strategy: ExtractionStrategy.DOM_ANALYSIS,
+                            message: 'Failed to extract video tags',
+                            details: error,
+                            isFatal: false
+                        });
+                    }
+                }
+                // Extract from iframes
+                if (args.extractIframes !== false) {
+                    try {
+                        const iframeSources = await htmlElementsFinder.findIframeSources();
+                        allSources.push(...iframeSources);
+                    }
+                    catch (error) {
+                        errors.push({
+                            strategy: ExtractionStrategy.DOM_ANALYSIS,
+                            message: 'Failed to extract iframe sources',
+                            details: error,
+                            isFatal: false
+                        });
+                    }
+                }
+                // Extract from embeds
+                if (args.extractEmbeds !== false) {
+                    try {
+                        const embedSources = await htmlElementsFinder.findEmbedSources();
+                        allSources.push(...embedSources);
+                    }
+                    catch (error) {
+                        errors.push({
+                            strategy: ExtractionStrategy.DOM_ANALYSIS,
+                            message: 'Failed to extract embed sources',
+                            details: error,
+                            isFatal: false
+                        });
+                    }
+                }
+                // Extract from meta tags
+                if (args.extractMetaTags !== false) {
+                    try {
+                        const metaSources = await htmlElementsFinder.findMetaVideoSources();
+                        allSources.push(...metaSources);
+                    }
+                    catch (error) {
+                        errors.push({
+                            strategy: ExtractionStrategy.DOM_ANALYSIS,
+                            message: 'Failed to extract meta tag sources',
+                            details: error,
+                            isFatal: false
+                        });
+                    }
+                }
+                // Extract from data attributes
+                if (args.extractDataAttributes !== false) {
+                    try {
+                        const dataSources = await htmlElementsFinder.findDataAttributesSources();
+                        allSources.push(...dataSources);
+                    }
+                    catch (error) {
+                        errors.push({
+                            strategy: ExtractionStrategy.DOM_ANALYSIS,
+                            message: 'Failed to extract data attribute sources',
+                            details: error,
+                            isFatal: false
+                        });
+                    }
+                }
+                // Get current page info for metadata
+                const page = getPage();
+                const pageUrl = page ? await page.url() : 'unknown';
+                const pageTitle = page ? await page.title() : undefined;
+                // Deduplicate sources
+                const uniqueSources = deduplicateSources(allSources);
+                const result = {
+                    sources: uniqueSources,
+                    metadata: {
+                        title: pageTitle,
+                        extractionTime: Date.now() - startTime,
+                        strategiesUsed: [ExtractionStrategy.DOM_ANALYSIS],
+                        hostersFound: [...new Set(uniqueSources.map(s => s.hoster).filter(Boolean))]
+                    },
+                    errors,
+                    warnings
+                };
+                return {
+                    content: result,
+                    isError: false
+                };
+            }
+            catch (error) {
+                throw new Error(`HTML elements extraction failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }, 'handleHtmlElementsExtraction');
+    });
+}
+// Network Recording Video Extractor
+export async function handleNetworkVideoExtraction(args) {
+    return withVideoExtractionWorkflowValidation('network_video_extraction', async () => {
+        return withErrorHandling(async () => {
+            const startTime = Date.now();
+            const errors = [];
+            const warnings = [];
+            try {
+                // Start network recording
+                await networkRecorder.startRecording({
+                    interceptRequests: args.interceptRequests || false,
+                    captureResponses: args.captureResponses || true,
+                    filterResourceTypes: args.filterResourceTypes,
+                    maxRecords: args.maxRecords || 1000
+                });
+                // Record for specified duration or default 10 seconds
+                const duration = args.recordingDuration || 10000;
+                await new Promise(resolve => setTimeout(resolve, duration));
+                // Stop recording and get video sources
+                const requests = await networkRecorder.stopRecording();
+                const videoSources = await networkRecorder.getVideoRequests();
+                // Get API endpoints that might contain video data
+                const apiEndpoints = await networkRecorder.getAPIEndpoints();
+                if (apiEndpoints.length > 0) {
+                    warnings.push(`Found ${apiEndpoints.length} API endpoints that might contain video data`);
+                }
+                // Extract tokens for authentication
+                const tokens = await networkRecorder.extractTokensFromRequests();
+                if (tokens.authTokens.length > 0) {
+                    warnings.push(`Found ${tokens.authTokens.length} authentication tokens`);
+                }
+                // Get current page info for metadata
+                const page = getPage();
+                const pageUrl = page ? await page.url() : 'unknown';
+                const pageTitle = page ? await page.title() : undefined;
+                const result = {
+                    sources: videoSources,
+                    metadata: {
+                        title: pageTitle,
+                        extractionTime: Date.now() - startTime,
+                        strategiesUsed: [ExtractionStrategy.NETWORK_RECORDING],
+                        hostersFound: [...new Set(videoSources.map(s => s.hoster).filter(Boolean))]
+                    },
+                    errors,
+                    warnings
+                };
+                return {
+                    content: result,
+                    isError: false
+                };
+            }
+            catch (error) {
+                throw new Error(`Network video extraction failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }, 'handleNetworkVideoExtraction');
+    });
+}
+// Video Selectors Generator
+export async function handleVideoSelectorGeneration(args) {
+    return withVideoExtractionWorkflowValidation('video_selector_generation', async () => {
+        return withErrorHandling(async () => {
+            try {
+                await videoSelectors.initialize();
+                const selectors = await videoSelectors.generateVideoSelectors();
+                return {
+                    content: selectors,
+                    isError: false
+                };
+            }
+            catch (error) {
+                throw new Error(`Video selector generation failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }, 'handleVideoSelectorGeneration');
+    });
+}
+// Comprehensive Video Extraction (combines all strategies)
+export async function handleComprehensiveVideoExtraction(args) {
+    return withVideoExtractionWorkflowValidation('comprehensive_video_extraction', async () => {
+        return withErrorHandling(async () => {
+            const startTime = Date.now();
+            const allSources = [];
+            const errors = [];
+            const warnings = [];
+            const strategiesUsed = [];
+            try {
+                // DOM Analysis
+                if (args.enableDOMAnalysis !== false) {
+                    try {
+                        const domResult = await handleHtmlElementsExtraction({
+                            extractVideoTags: true,
+                            extractIframes: true,
+                            extractEmbeds: true,
+                            extractMetaTags: true,
+                            extractDataAttributes: true
+                        });
+                        allSources.push(...domResult.content.sources);
+                        errors.push(...domResult.content.errors);
+                        warnings.push(...domResult.content.warnings);
+                        strategiesUsed.push(ExtractionStrategy.DOM_ANALYSIS);
+                    }
+                    catch (error) {
+                        errors.push({
+                            strategy: ExtractionStrategy.DOM_ANALYSIS,
+                            message: 'DOM analysis failed',
+                            details: error,
+                            isFatal: false
+                        });
+                    }
+                }
+                // Network Recording
+                if (args.enableNetworkRecording !== false) {
+                    try {
+                        const networkResult = await handleNetworkVideoExtraction({
+                            interceptRequests: false,
+                            captureResponses: true,
+                            recordingDuration: args.recordingDuration || 10000
+                        });
+                        allSources.push(...networkResult.content.sources);
+                        errors.push(...networkResult.content.errors);
+                        warnings.push(...networkResult.content.warnings);
+                        strategiesUsed.push(ExtractionStrategy.NETWORK_RECORDING);
+                    }
+                    catch (error) {
+                        errors.push({
+                            strategy: ExtractionStrategy.NETWORK_RECORDING,
+                            message: 'Network recording failed',
+                            details: error,
+                            isFatal: false
+                        });
+                    }
+                }
+                // Filter by formats if specified
+                let filteredSources = allSources;
+                if (args.filterFormats && args.filterFormats.length > 0) {
+                    filteredSources = allSources.filter(source => args.filterFormats.includes(source.format));
+                    if (filteredSources.length < allSources.length) {
+                        warnings.push(`Filtered ${allSources.length - filteredSources.length} sources by format`);
+                    }
+                }
+                // Deduplicate and limit sources
+                let uniqueSources = deduplicateSources(filteredSources);
+                if (args.maxSources && uniqueSources.length > args.maxSources) {
+                    // Sort by confidence and keep top sources
+                    uniqueSources = uniqueSources
+                        .sort((a, b) => b.confidence - a.confidence)
+                        .slice(0, args.maxSources);
+                    warnings.push(`Limited results to top ${args.maxSources} sources by confidence`);
+                }
+                // Get current page info for metadata
+                const page = getPage();
+                const pageUrl = page ? await page.url() : 'unknown';
+                const pageTitle = page ? await page.title() : undefined;
+                const result = {
+                    sources: uniqueSources,
+                    metadata: {
+                        title: pageTitle,
+                        extractionTime: Date.now() - startTime,
+                        strategiesUsed,
+                        hostersFound: [...new Set(uniqueSources.map(s => s.hoster).filter(Boolean))]
+                    },
+                    errors,
+                    warnings
+                };
+                return {
+                    content: result,
+                    isError: false
+                };
+            }
+            catch (error) {
+                throw new Error(`Comprehensive video extraction failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }, 'handleComprehensiveVideoExtraction');
+    });
+}
+// URL Redirect Tracer
+export async function handleURLRedirectTrace(args) {
+    return withVideoExtractionWorkflowValidation('url_redirect_trace', async () => {
+        return withErrorHandling(async () => {
+            try {
+                // Start recording to capture redirects
+                await networkRecorder.startRecording({
+                    interceptRequests: false,
+                    captureResponses: true
+                });
+                // Record for specified duration
+                const duration = args.recordingDuration || 5000;
+                await new Promise(resolve => setTimeout(resolve, duration));
+                // Stop recording
+                await networkRecorder.stopRecording();
+                // Get redirect information
+                const finalUrls = await requestChainTracer.getFinalUrls();
+                let redirectChains = {};
+                if (args.targetUrl) {
+                    const chainForTarget = await requestChainTracer.traceRedirects(args.targetUrl);
+                    redirectChains[args.targetUrl] = chainForTarget;
+                }
+                else {
+                    // Get redirect chains for all URLs
+                    for (const [originalUrl] of Object.entries(finalUrls)) {
+                        const chain = await requestChainTracer.traceRedirects(originalUrl);
+                        if (chain.length > 1) {
+                            redirectChains[originalUrl] = chain;
+                        }
+                    }
+                }
+                return {
+                    content: {
+                        redirectChains,
+                        finalUrls
+                    },
+                    isError: false
+                };
+            }
+            catch (error) {
+                throw new Error(`URL redirect trace failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }, 'handleURLRedirectTrace');
+    });
+}
+// Helper function to deduplicate video sources
+function deduplicateSources(sources) {
+    const seen = new Set();
+    const unique = [];
+    for (const source of sources) {
+        // Create a key based on URL and format
+        const key = `${source.url}|${source.format}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            unique.push(source);
+        }
+    }
+    return unique;
+}
+// Export all handlers
+export { withVideoExtractionWorkflowValidation };

package/dist/index.js

@@ -43,6 +43,8 @@ import { handleOCREngine, handleAudioCaptchaSolver, handlePuzzleCaptchaHandler }
 import { handleFullPageScreenshot, handleElementScreenshot, handlePDFGeneration, handleVideoRecording, handleVisualComparison } from './handlers/visual-tools-handlers.js';
 // Import API integration handlers
 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';
 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`);
@@ -233,6 +235,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return await handleWebhookSupport(args);
             case TOOL_NAMES.ALL_WEBSITE_API_FINDER:
                 return await handleAllWebsiteAPIFinder(args);
+            // Video Extraction Tools
+            case TOOL_NAMES.HTML_ELEMENTS_EXTRACTION:
+                return await handleHtmlElementsExtraction(args);
+            case TOOL_NAMES.NETWORK_VIDEO_EXTRACTION:
+                return await handleNetworkVideoExtraction(args);
+            case TOOL_NAMES.VIDEO_SELECTOR_GENERATION:
+                return await handleVideoSelectorGeneration(args);
+            case TOOL_NAMES.COMPREHENSIVE_VIDEO_EXTRACTION:
+                return await handleComprehensiveVideoExtraction(args);
+            case TOOL_NAMES.URL_REDIRECT_TRACE:
+                return await handleURLRedirectTrace(args);
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/tool-definitions.js

@@ -581,6 +581,138 @@ export const TOOLS = [
             required: ['text'],
         },
     },
+    // Video Extraction Tools
+    {
+        name: 'html_elements_extraction',
+        description: 'Extract video sources from HTML elements (video tags, iframes, embeds, meta tags, data attributes)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                extractVideoTags: {
+                    type: 'boolean',
+                    description: 'Extract sources from <video> and <source> tags',
+                    default: true
+                },
+                extractIframes: {
+                    type: 'boolean',
+                    description: 'Extract sources from <iframe> elements',
+                    default: true
+                },
+                extractEmbeds: {
+                    type: 'boolean',
+                    description: 'Extract sources from <embed> and <object> elements',
+                    default: true
+                },
+                extractMetaTags: {
+                    type: 'boolean',
+                    description: 'Extract sources from Open Graph and Twitter Card meta tags',
+                    default: true
+                },
+                extractDataAttributes: {
+                    type: 'boolean',
+                    description: 'Extract sources from data-* attributes',
+                    default: true
+                }
+            }
+        }
+    },
+    {
+        name: 'network_video_extraction',
+        description: 'Extract video sources from network requests and responses',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                interceptRequests: {
+                    type: 'boolean',
+                    description: 'Intercept and analyze network requests',
+                    default: false
+                },
+                captureResponses: {
+                    type: 'boolean',
+                    description: 'Capture and analyze network responses',
+                    default: true
+                },
+                filterResourceTypes: {
+                    type: 'array',
+                    description: 'Filter by resource types (xhr, fetch, media, etc.)',
+                    items: { type: 'string' }
+                },
+                maxRecords: {
+                    type: 'number',
+                    description: 'Maximum number of network requests to record',
+                    default: 1000
+                },
+                recordingDuration: {
+                    type: 'number',
+                    description: 'Duration to record network traffic (ms)',
+                    default: 10000
+                }
+            }
+        }
+    },
+    {
+        name: 'video_selector_generation',
+        description: 'Generate CSS selectors for video-related elements on the page',
+        inputSchema: {
+            type: 'object',
+            properties: {}
+        }
+    },
+    {
+        name: 'comprehensive_video_extraction',
+        description: 'Extract video sources using all available strategies (DOM + Network)',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                enableDOMAnalysis: {
+                    type: 'boolean',
+                    description: 'Enable DOM-based video extraction',
+                    default: true
+                },
+                enableNetworkRecording: {
+                    type: 'boolean',
+                    description: 'Enable network-based video extraction',
+                    default: true
+                },
+                recordingDuration: {
+                    type: 'number',
+                    description: 'Duration to record network traffic (ms)',
+                    default: 10000
+                },
+                maxSources: {
+                    type: 'number',
+                    description: 'Maximum number of video sources to return',
+                    default: 50
+                },
+                filterFormats: {
+                    type: 'array',
+                    description: 'Filter results by video format',
+                    items: {
+                        type: 'string',
+                        enum: ['mp4', 'webm', 'avi', 'mkv', 'hls', 'dash', 'ts', 'flv', 'blob']
+                    }
+                }
+            }
+        }
+    },
+    {
+        name: 'url_redirect_trace',
+        description: 'Trace URL redirects and get final destinations',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                targetUrl: {
+                    type: 'string',
+                    description: 'Specific URL to trace redirects for'
+                },
+                recordingDuration: {
+                    type: 'number',
+                    description: 'Duration to record network traffic (ms)',
+                    default: 5000
+                }
+            }
+        }
+    },
     // Data Validation Tools
     {
         name: 'schema_validator',
@@ -1051,6 +1183,12 @@ export const TOOL_NAMES = {
     REST_API_ENDPOINT_FINDER: 'rest_api_endpoint_finder',
     WEBHOOK_SUPPORT: 'webhook_support',
     ALL_WEBSITE_API_FINDER: 'all_website_api_finder',
+    // Video Extraction Tools
+    HTML_ELEMENTS_EXTRACTION: 'html_elements_extraction',
+    NETWORK_VIDEO_EXTRACTION: 'network_video_extraction',
+    VIDEO_SELECTOR_GENERATION: 'video_selector_generation',
+    COMPREHENSIVE_VIDEO_EXTRACTION: 'comprehensive_video_extraction',
+    URL_REDIRECT_TRACE: 'url_redirect_trace',
 };
 // Tool categories for organization
 export const TOOL_CATEGORIES = {