brave-real-browser-mcp-server 2.14.7 → 2.14.9

package/dist/handlers/dynamic-session-handlers.js

@@ -127,85 +127,6 @@ export async function handleCookieManager(args) {
 /**
  * Session Persistence - Save and restore browser session
  */
-export async function handleSessionPersistence(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('session_persistence', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const action = args.action || 'save'; // save, restore
-        if (action === 'save') {
-            const cookies = await page.cookies();
-            const localStorage = await page.evaluate(() => {
-                const items = {};
-                for (let i = 0; i < window.localStorage.length; i++) {
-                    const key = window.localStorage.key(i);
-                    if (key) {
-                        items[key] = window.localStorage.getItem(key);
-                    }
-                }
-                return items;
-            });
-            const sessionStorage = await page.evaluate(() => {
-                const items = {};
-                for (let i = 0; i < window.sessionStorage.length; i++) {
-                    const key = window.sessionStorage.key(i);
-                    if (key) {
-                        items[key] = window.sessionStorage.getItem(key);
-                    }
-                }
-                return items;
-            });
-            const sessionData = {
-                url: page.url(),
-                cookies,
-                localStorage,
-                sessionStorage,
-                timestamp: new Date().toISOString(),
-            };
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Session saved\n\n${JSON.stringify(sessionData, null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'restore') {
-            const sessionData = args.sessionData;
-            if (!sessionData) {
-                throw new Error('Session data is required for restore');
-            }
-            // Restore cookies
-            if (sessionData.cookies) {
-                await Promise.all(sessionData.cookies.map((cookie) => page.setCookie(cookie)));
-            }
-            // Restore localStorage
-            if (sessionData.localStorage) {
-                await page.evaluate((items) => {
-                    for (const [key, value] of Object.entries(items)) {
-                        window.localStorage.setItem(key, value);
-                    }
-                }, sessionData.localStorage);
-            }
-            // Restore sessionStorage
-            if (sessionData.sessionStorage) {
-                await page.evaluate((items) => {
-                    for (const [key, value] of Object.entries(items)) {
-                        window.sessionStorage.setItem(key, value);
-                    }
-                }, sessionData.sessionStorage);
-            }
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Session restored from ${sessionData.timestamp}`,
-                    }],
-            };
-        }
-        throw new Error(`Unknown action: ${action}`);
-    }, 'Failed session persistence');
-}
 /**
  * Form Auto Fill - Automatically fill form fields
  */
@@ -385,131 +306,6 @@ export async function handleAjaxContentWaiter(args) {
 /**
  * Modal Popup Handler - Handle modal popups
  */
-export async function handleModalPopupHandler(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('modal_popup_handler', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const action = args.action || 'detect'; // detect, close, interact
-        if (action === 'detect') {
-            const modals = await page.evaluate(() => {
-                const results = [];
-                const modalSelectors = [
-                    '.modal',
-                    '[role="dialog"]',
-                    '[class*="popup"]',
-                    '[class*="overlay"]',
-                    '.dialog',
-                ];
-                modalSelectors.forEach(selector => {
-                    const elements = document.querySelectorAll(selector);
-                    elements.forEach((el) => {
-                        const isVisible = el.offsetWidth > 0 && el.offsetHeight > 0;
-                        if (isVisible) {
-                            results.push({
-                                selector,
-                                id: el.id || null,
-                                className: el.className,
-                                text: el.textContent?.trim().substring(0, 200) || '',
-                            });
-                        }
-                    });
-                });
-                return results;
-            });
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Found ${modals.length} visible modals\n\n${JSON.stringify(modals, null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'close') {
-            const closeSelector = args.closeSelector || '.close, [aria-label="Close"], button[class*="close"]';
-            try {
-                await page.click(closeSelector);
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `✅ Modal closed`,
-                        }],
-                };
-            }
-            catch (e) {
-                // Try pressing Escape
-                await page.keyboard.press('Escape');
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `✅ Pressed Escape key to close modal`,
-                        }],
-                };
-            }
-        }
-        throw new Error(`Unknown action: ${action}`);
-    }, 'Failed modal popup handler');
-}
 /**
  * Login Session Manager - Manage login sessions
  */
-export async function handleLoginSessionManager(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('login_session_manager', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const action = args.action || 'check'; // check, login, logout
-        if (action === 'check') {
-            const isLoggedIn = await page.evaluate(() => {
-                // Check common indicators of logged-in state
-                const indicators = [
-                    document.querySelector('[class*="logout"]'),
-                    document.querySelector('[class*="profile"]'),
-                    document.querySelector('[class*="account"]'),
-                    document.cookie.includes('session') || document.cookie.includes('token'),
-                    localStorage.getItem('token') !== null,
-                ];
-                return indicators.some(indicator => Boolean(indicator));
-            });
-            const cookies = await page.cookies();
-            const sessionCookies = cookies.filter(c => c.name.toLowerCase().includes('session') ||
-                c.name.toLowerCase().includes('token') ||
-                c.name.toLowerCase().includes('auth'));
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Login Status Check\n\nLikely Logged In: ${isLoggedIn}\nSession Cookies: ${sessionCookies.length}\n\n${JSON.stringify(sessionCookies.map(c => ({ name: c.name, domain: c.domain })), null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'login') {
-            const username = args.username;
-            const password = args.password;
-            const usernameSelector = args.usernameSelector || 'input[type="email"], input[type="text"], input[name*="user"], input[name*="email"]';
-            const passwordSelector = args.passwordSelector || 'input[type="password"]';
-            const submitSelector = args.submitSelector || 'button[type="submit"], input[type="submit"]';
-            if (!username || !password) {
-                throw new Error('Username and password are required');
-            }
-            // Fill username
-            await page.waitForSelector(usernameSelector, { timeout: 5000 });
-            await page.type(usernameSelector, username);
-            // Fill password
-            await page.waitForSelector(passwordSelector, { timeout: 5000 });
-            await page.type(passwordSelector, password);
-            // Submit
-            await page.click(submitSelector);
-            await page.waitForNavigation({ waitUntil: 'networkidle2', timeout: 10000 }).catch(() => { });
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Login attempted\n\nUsername: ${username}\nCurrent URL: ${page.url()}`,
-                    }],
-            };
-        }
-        throw new Error(`Unknown action: ${action}`);
-    }, 'Failed login session manager');
-}

package/dist/handlers/monitoring-reporting-handlers.js

@@ -110,91 +110,9 @@ export async function handleProgressTracker(args) {
         throw new Error(`Unknown action: ${action}`);
     }, 'Failed progress tracker');
 }
-/**
- * Error Logger - Log and track errors
- */
-export async function handleErrorLogger(args) {
-    return await withErrorHandling(async () => {
-        const action = args.action || 'log'; // log, get, clear
-        if (action === 'log') {
-            const error = {
-                id: `err_${Date.now()}`,
-                message: args.message || 'Unknown error',
-                type: args.type || 'error',
-                timestamp: new Date().toISOString(),
-                context: args.context || {},
-                stackTrace: args.stackTrace || null,
-            };
-            monitoringState.errors.push(error);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Error logged: ${error.message}\n\n${JSON.stringify(error, null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'get') {
-            const limit = args.limit || 10;
-            const errorType = args.type;
-            let filteredErrors = monitoringState.errors;
-            if (errorType) {
-                filteredErrors = filteredErrors.filter((err) => err.type === errorType);
-            }
-            const recentErrors = filteredErrors.slice(-limit);
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Retrieved ${recentErrors.length} error(s)\n\nTotal Errors: ${monitoringState.errors.length}\n\n${JSON.stringify(recentErrors, null, 2)}`,
-                    }],
-            };
-        }
-        if (action === 'clear') {
-            const count = monitoringState.errors.length;
-            monitoringState.errors = [];
-            return {
-                content: [{
-                        type: 'text',
-                        text: `✅ Cleared ${count} error(s)`,
-                    }],
-            };
-        }
-        throw new Error(`Unknown action: ${action}`);
-    }, 'Failed error logger');
-}
 /**
  * Success Rate Reporter - Report success metrics
  */
-export async function handleSuccessRateReporter(args) {
-    return await withErrorHandling(async () => {
-        const timeRange = args.timeRange || 'all'; // all, last_hour, last_day
-        let operations = monitoringState.operations;
-        if (timeRange === 'last_hour') {
-            const hourAgo = Date.now() - (60 * 60 * 1000);
-            operations = operations.filter((op) => op.startTime >= hourAgo);
-        }
-        else if (timeRange === 'last_day') {
-            const dayAgo = Date.now() - (24 * 60 * 60 * 1000);
-            operations = operations.filter((op) => op.startTime >= dayAgo);
-        }
-        const total = operations.length;
-        const completed = operations.filter((op) => op.status === 'completed').length;
-        const failed = operations.filter((op) => op.status === 'failed').length;
-        const inProgress = operations.filter((op) => op.status === 'in_progress').length;
-        const successRate = total > 0 ? ((completed / total) * 100).toFixed(2) : 0;
-        const failureRate = total > 0 ? ((failed / total) * 100).toFixed(2) : 0;
-        // Calculate average duration
-        const completedOps = operations.filter((op) => op.duration !== undefined);
-        const avgDuration = completedOps.length > 0
-            ? (completedOps.reduce((sum, op) => sum + op.duration, 0) / completedOps.length).toFixed(2)
-            : 0;
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Success Rate Report (${timeRange})\n\nTotal Operations: ${total}\nCompleted: ${completed}\nFailed: ${failed}\nIn Progress: ${inProgress}\n\nSuccess Rate: ${successRate}%\nFailure Rate: ${failureRate}%\nAverage Duration: ${avgDuration}ms\n\nUptime: ${((Date.now() - monitoringState.startTime) / 1000 / 60).toFixed(2)} minutes`,
-                }],
-        };
-    }, 'Failed success rate reporter');
-}
 /**
  * Data Quality Metrics - Report data quality metrics
  */
@@ -282,94 +200,6 @@ export async function handleDataQualityMetrics(args) {
 /**
  * Performance Monitor - Monitor browser and page performance
  */
-export async function handlePerformanceMonitor(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('performance_monitor', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const performanceData = await page.evaluate(() => {
-            const perfData = {
-                navigation: {},
-                resources: [],
-                memory: {},
-                timing: {},
-            };
-            // Navigation timing
-            if (performance.timing) {
-                const timing = performance.timing;
-                perfData.navigation = {
-                    domContentLoaded: timing.domContentLoadedEventEnd - timing.navigationStart,
-                    loadComplete: timing.loadEventEnd - timing.navigationStart,
-                    domInteractive: timing.domInteractive - timing.navigationStart,
-                    firstPaint: timing.responseEnd - timing.requestStart,
-                };
-            }
-            // Resource timing
-            if (performance.getEntriesByType) {
-                const resources = performance.getEntriesByType('resource');
-                perfData.resources = resources.slice(0, 20).map((resource) => ({
-                    name: resource.name.substring(0, 100),
-                    type: resource.initiatorType,
-                    duration: Math.round(resource.duration),
-                    size: resource.transferSize || 0,
-                }));
-            }
-            // Memory (if available)
-            if (performance.memory) {
-                const memory = performance.memory;
-                perfData.memory = {
-                    usedJSHeapSize: Math.round(memory.usedJSHeapSize / 1024 / 1024) + ' MB',
-                    totalJSHeapSize: Math.round(memory.totalJSHeapSize / 1024 / 1024) + ' MB',
-                    jsHeapSizeLimit: Math.round(memory.jsHeapSizeLimit / 1024 / 1024) + ' MB',
-                };
-            }
-            // Performance marks and measures
-            if (performance.getEntriesByType) {
-                const marks = performance.getEntriesByType('mark');
-                const measures = performance.getEntriesByType('measure');
-                perfData.timing.marks = marks.length;
-                perfData.timing.measures = measures.length;
-            }
-            return perfData;
-        });
-        // Calculate summary
-        const resourceCount = performanceData.resources.length;
-        const totalResourceDuration = performanceData.resources.reduce((sum, r) => sum + r.duration, 0);
-        const avgResourceDuration = resourceCount > 0 ? (totalResourceDuration / resourceCount).toFixed(2) : 0;
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Performance Monitor\n\nPage Load Metrics:\n${JSON.stringify(performanceData.navigation, null, 2)}\n\nResources (showing ${resourceCount}):\nAverage Load Time: ${avgResourceDuration}ms\n\nMemory Usage:\n${JSON.stringify(performanceData.memory, null, 2)}\n\nTop Resources:\n${JSON.stringify(performanceData.resources.slice(0, 10), null, 2)}`,
-                }],
-        };
-    }, 'Failed performance monitor');
-}
 /**
  * Get Monitoring Summary - Get overall monitoring summary
  */
-export async function handleGetMonitoringSummary(args) {
-    return await withErrorHandling(async () => {
-        const summary = {
-            uptime: ((Date.now() - monitoringState.startTime) / 1000 / 60).toFixed(2) + ' minutes',
-            operations: {
-                total: monitoringState.operations.length,
-                completed: monitoringState.operations.filter((op) => op.status === 'completed').length,
-                failed: monitoringState.operations.filter((op) => op.status === 'failed').length,
-                inProgress: monitoringState.operations.filter((op) => op.status === 'in_progress').length,
-            },
-            errors: {
-                total: monitoringState.errors.length,
-                recent: monitoringState.errors.slice(-5),
-            },
-            metrics: monitoringState.metrics,
-        };
-        return {
-            content: [{
-                    type: 'text',
-                    text: `✅ Monitoring Summary\n\n${JSON.stringify(summary, null, 2)}`,
-                }],
-        };
-    }, 'Failed to get monitoring summary');
-}

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

@@ -194,61 +194,6 @@ export async function handleAttributeHarvester(args) {
         };
     }, 'Failed to harvest attributes');
 }
-/**
- * सभी images URLs, alt text, dimensions के साथ extract करता है
- */
-export async function handleImageScraper(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('image_scraper', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const selector = args.selector || 'img';
-        const includeDataUrls = args.includeDataUrls || false;
-        const includeDimensions = args.includeDimensions !== false;
-        const imageData = await page.evaluate(({ selector, includeDataUrls, includeDimensions }) => {
-            const images = document.querySelectorAll(selector);
-            const results = [];
-            images.forEach((img, index) => {
-                const src = img.src || img.getAttribute('data-src') || '';
-                // Skip data URLs if not included
-                if (!includeDataUrls && src.startsWith('data:')) {
-                    return;
-                }
-                const imageInfo = {
-                    index,
-                    src,
-                    alt: img.alt || '',
-                    title: img.title || '',
-                };
-                if (includeDimensions) {
-                    imageInfo.width = img.naturalWidth || img.width || 0;
-                    imageInfo.height = img.naturalHeight || img.height || 0;
-                }
-                // Additional attributes
-                const srcset = img.srcset || img.getAttribute('data-srcset');
-                if (srcset) {
-                    imageInfo.srcset = srcset;
-                }
-                const loading = img.loading;
-                if (loading) {
-                    imageInfo.loading = loading;
-                }
-                results.push(imageInfo);
-            });
-            return results;
-        }, { selector, includeDataUrls, includeDimensions });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Scraped ${imageData.length} images\n\n${JSON.stringify(imageData, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to scrape images');
-}
 /**
  * Internal/external links classification के साथ collect करता है
  */
@@ -441,92 +386,3 @@ export async function handleMediaExtractor(args) {
         };
     }, 'Failed to extract media');
 }
-/**
- * Downloadable files (PDF, DOC, etc.) detect करता है
- */
-export async function handlePDFLinkFinder(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('pdf_link_finder', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const selector = args.selector || 'a[href]';
-        const includeOtherFiles = args.includeOtherFiles !== false;
-        const fileData = await page.evaluate(({ selector, includeOtherFiles }) => {
-            const links = document.querySelectorAll(selector);
-            const results = {
-                pdfs: [],
-                documents: [],
-                archives: [],
-                others: [],
-            };
-            const fileExtensions = {
-                pdf: ['pdf'],
-                documents: ['doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp'],
-                archives: ['zip', 'rar', '7z', 'tar', 'gz', 'bz2'],
-                others: ['txt', 'csv', 'json', 'xml'],
-            };
-            links.forEach((link, index) => {
-                const href = link.href;
-                const text = link.textContent?.trim() || '';
-                // Check file extension
-                const url = href.toLowerCase();
-                let fileType = '';
-                let category = '';
-                for (const [cat, exts] of Object.entries(fileExtensions)) {
-                    for (const ext of exts) {
-                        if (url.endsWith(`.${ext}`) || url.includes(`.${ext}?`) || url.includes(`.${ext}#`)) {
-                            fileType = ext;
-                            category = cat;
-                            break;
-                        }
-                    }
-                    if (fileType)
-                        break;
-                }
-                if (!fileType && !includeOtherFiles) {
-                    return;
-                }
-                const fileInfo = {
-                    index,
-                    href,
-                    text,
-                    fileType,
-                    fileName: href.split('/').pop()?.split('?')[0] || '',
-                };
-                // Get file size if available
-                const sizeAttr = link.getAttribute('data-size') || link.getAttribute('title');
-                if (sizeAttr) {
-                    fileInfo.size = sizeAttr;
-                }
-                // Categorize
-                if (category === 'pdf') {
-                    results.pdfs.push(fileInfo);
-                }
-                else if (category === 'documents') {
-                    results.documents.push(fileInfo);
-                }
-                else if (category === 'archives') {
-                    results.archives.push(fileInfo);
-                }
-                else if (includeOtherFiles) {
-                    results.others.push(fileInfo);
-                }
-            });
-            return results;
-        }, { selector, includeOtherFiles });
-        const totalFiles = fileData.pdfs.length +
-            fileData.documents.length +
-            fileData.archives.length +
-            fileData.others.length;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Found ${totalFiles} downloadable files\n\n${JSON.stringify(fileData, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to find PDF links');
-}