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

package/dist/handlers/data-quality-handlers.js

@@ -74,94 +74,6 @@ export async function handleDataDeduplication(args) {
 /**
  * Missing Data Handler - Detect and handle missing data
  */
-export async function handleMissingDataHandler(args) {
-    const { data, requiredFields, strategy = 'report' } = args;
-    try {
-        if (!Array.isArray(data)) {
-            throw new Error('Data must be an array');
-        }
-        const results = [];
-        const missingReport = {};
-        let totalMissing = 0;
-        data.forEach((item, index) => {
-            const itemMissing = {};
-            let hasMissing = false;
-            if (requiredFields && Array.isArray(requiredFields)) {
-                requiredFields.forEach(field => {
-                    const value = item[field];
-                    if (value === undefined || value === null || value === '') {
-                        itemMissing[field] = true;
-                        hasMissing = true;
-                        totalMissing++;
-                        if (!missingReport[field]) {
-                            missingReport[field] = { count: 0, indices: [] };
-                        }
-                        missingReport[field].count++;
-                        missingReport[field].indices.push(index);
-                    }
-                });
-            }
-            // Handle missing data based on strategy
-            let processedItem = { ...item };
-            switch (strategy) {
-                case 'remove':
-                    if (!hasMissing)
-                        results.push(processedItem);
-                    break;
-                case 'fill':
-                    Object.keys(itemMissing).forEach(field => {
-                        if (typeof item[field] === 'number') {
-                            processedItem[field] = 0;
-                        }
-                        else if (typeof item[field] === 'string') {
-                            processedItem[field] = 'N/A';
-                        }
-                        else {
-                            processedItem[field] = null;
-                        }
-                    });
-                    results.push(processedItem);
-                    break;
-                case 'flag':
-                    processedItem._hasMissingData = hasMissing;
-                    processedItem._missingFields = Object.keys(itemMissing);
-                    results.push(processedItem);
-                    break;
-                case 'report':
-                default:
-                    results.push(processedItem);
-                    break;
-            }
-        });
-        const itemsWithMissing = Object.values(missingReport).length > 0 ?
-            [...new Set(Object.values(missingReport).flatMap((r) => r.indices))].length : 0;
-        const missingRate = ((totalMissing / (data.length * (requiredFields?.length || 1))) * 100).toFixed(2);
-        let summary = `Missing Data Analysis:\n\nStatistics:\n- Total Items: ${data.length}\n- Items with Missing Data: ${itemsWithMissing}\n- Total Missing Fields: ${totalMissing}\n- Missing Rate: ${missingRate}%\n- Strategy: ${strategy}`;
-        if (Object.keys(missingReport).length > 0) {
-            summary += `\n\nMissing Fields Report:\n${Object.entries(missingReport).map(([field, info]) => `- ${field}: ${info.count} occurrences (indices: ${info.indices.slice(0, 5).join(', ')}${info.indices.length > 5 ? '...' : ''})`).join('\n')}`;
-        }
-        summary += `\n\nProcessed Items: ${results.length}`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Missing Data Handler Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}
 /**
  * Data Type Validator - Validate data types against schema
  */
@@ -343,135 +255,3 @@ export async function handleOutlierDetection(args) {
 /**
  * Consistency Checker - Check data consistency across fields
  */
-export async function handleConsistencyChecker(args) {
-    const { data, rules } = args;
-    try {
-        if (!Array.isArray(data)) {
-            throw new Error('Data must be an array');
-        }
-        if (!rules || !Array.isArray(rules)) {
-            throw new Error('Rules must be provided as an array');
-        }
-        const violations = [];
-        const ruleResults = {};
-        rules.forEach(rule => {
-            ruleResults[rule.name] = { passed: 0, failed: 0, violations: [] };
-        });
-        data.forEach((item, index) => {
-            rules.forEach(rule => {
-                let passed = true;
-                let reason = '';
-                try {
-                    switch (rule.type) {
-                        case 'required':
-                            if (item[rule.field] === undefined || item[rule.field] === null || item[rule.field] === '') {
-                                passed = false;
-                                reason = `Field '${rule.field}' is required but missing`;
-                            }
-                            break;
-                        case 'range':
-                            const value = parseFloat(item[rule.field]);
-                            if (isNaN(value) || value < rule.min || value > rule.max) {
-                                passed = false;
-                                reason = `Field '${rule.field}' value ${value} is outside range [${rule.min}, ${rule.max}]`;
-                            }
-                            break;
-                        case 'pattern':
-                            const regex = new RegExp(rule.pattern);
-                            if (!regex.test(String(item[rule.field]))) {
-                                passed = false;
-                                reason = `Field '${rule.field}' does not match pattern ${rule.pattern}`;
-                            }
-                            break;
-                        case 'dependency':
-                            if (item[rule.field] && !item[rule.dependsOn]) {
-                                passed = false;
-                                reason = `Field '${rule.field}' requires '${rule.dependsOn}' to be present`;
-                            }
-                            break;
-                        case 'unique':
-                            // Check uniqueness within dataset
-                            const duplicates = data.filter(d => d[rule.field] === item[rule.field]);
-                            if (duplicates.length > 1) {
-                                passed = false;
-                                reason = `Field '${rule.field}' value '${item[rule.field]}' is not unique`;
-                            }
-                            break;
-                        case 'comparison':
-                            const val1 = parseFloat(item[rule.field1]);
-                            const val2 = parseFloat(item[rule.field2]);
-                            let comparisonPassed = false;
-                            switch (rule.operator) {
-                                case '>':
-                                    comparisonPassed = val1 > val2;
-                                    break;
-                                case '<':
-                                    comparisonPassed = val1 < val2;
-                                    break;
-                                case '>=':
-                                    comparisonPassed = val1 >= val2;
-                                    break;
-                                case '<=':
-                                    comparisonPassed = val1 <= val2;
-                                    break;
-                                case '==':
-                                    comparisonPassed = val1 === val2;
-                                    break;
-                                case '!=':
-                                    comparisonPassed = val1 !== val2;
-                                    break;
-                            }
-                            if (!comparisonPassed) {
-                                passed = false;
-                                reason = `Comparison failed: ${rule.field1} (${val1}) ${rule.operator} ${rule.field2} (${val2})`;
-                            }
-                            break;
-                    }
-                }
-                catch (err) {
-                    passed = false;
-                    reason = `Error checking rule: ${err.message}`;
-                }
-                if (passed) {
-                    ruleResults[rule.name].passed++;
-                }
-                else {
-                    ruleResults[rule.name].failed++;
-                    const violation = {
-                        index,
-                        item,
-                        rule: rule.name,
-                        reason
-                    };
-                    ruleResults[rule.name].violations.push(violation);
-                    violations.push(violation);
-                }
-            });
-        });
-        const consistencyRate = (((data.length - violations.length) / data.length) * 100).toFixed(2);
-        let summary = `Consistency Check Results:\n\nSummary:\n- Total Items: ${data.length}\n- Rules Checked: ${rules.length}\n- Total Violations: ${violations.length}\n- Consistency Rate: ${consistencyRate}%`;
-        summary += `\n\nRule Results:\n${Object.entries(ruleResults).map(([name, result]) => `- ${name}: ${result.passed} passed, ${result.failed} failed`).join('\n')}`;
-        if (violations.length > 0) {
-            summary += `\n\nViolations (Top 10):\n${violations.slice(0, 10).map((v, i) => `${i + 1}. Index ${v.index} - Rule: ${v.rule}\n   Reason: ${v.reason}`).join('\n')}`;
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Consistency Checker Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}

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