brave-real-browser-mcp-server 2.17.10 → 2.17.12

package/dist/handlers/captcha-handlers.js

@@ -1,257 +0,0 @@
-// @ts-nocheck
-import { getPageInstance } from '../browser-manager.js';
-import Tesseract from 'tesseract.js';
-import { sleep } from '../system-utils.js';
-/**
- * OCR Engine - Extract text from captcha images using OCR
- */
-export async function handleOCREngine(args) {
-    const { url, selector, imageUrl, imageBuffer, language = 'eng' } = args;
-    try {
-        let imageSource;
-        if (imageBuffer) {
-            imageSource = Buffer.from(imageBuffer, 'base64');
-        }
-        else if (imageUrl) {
-            imageSource = imageUrl;
-        }
-        else if (selector) {
-            const page = getPageInstance();
-            if (!page) {
-                throw new Error('Browser not initialized. Call browser_init first.');
-            }
-            if (url && page.url() !== url) {
-                await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-            }
-            // Get image element and take screenshot
-            const element = await page.$(selector);
-            if (!element) {
-                throw new Error(`Element not found: ${selector}`);
-            }
-            const screenshot = await element.screenshot({ encoding: 'base64' });
-            imageSource = Buffer.from(screenshot, 'base64');
-        }
-        else {
-            throw new Error('No image source provided');
-        }
-        // Perform OCR
-        const result = await Tesseract.recognize(imageSource, language, {
-            logger: () => { } // Suppress logs
-        });
-        // Clean and process text
-        const text = result.data.text.trim();
-        const confidence = result.data.confidence;
-        // Extract words with their confidence
-        const words = result.data.words.map(word => ({
-            text: word.text,
-            confidence: word.confidence,
-            bbox: word.bbox
-        }));
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `OCR Results:\n- Extracted Text: ${text}\n- Confidence: ${confidence.toFixed(2)}%\n- Words Found: ${words.length}\n- Lines: ${result.data.lines.length}\n- Language: ${language}\n\nWords Detail:\n${words.map((w) => `  "${w.text}" (confidence: ${w.confidence.toFixed(2)}%)`).join('\n')}`
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `OCR Engine Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}
-/**
- * Audio Captcha Solver - Handle audio captchas
- */
-export async function handleAudioCaptchaSolver(args) {
-    const { url, audioSelector, audioUrl, downloadPath } = args;
-    try {
-        const page = getPageInstance();
-        if (!page) {
-            throw new Error('Browser not initialized. Call browser_init first.');
-        }
-        if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        }
-        let audioSource = audioUrl;
-        // If selector provided, extract audio URL
-        if (audioSelector && !audioUrl) {
-            audioSource = await page.evaluate((sel) => {
-                const element = document.querySelector(sel);
-                if (!element)
-                    return null;
-                if (element.tagName === 'AUDIO') {
-                    return element.src || element.currentSrc;
-                }
-                else if (element.tagName === 'SOURCE') {
-                    return element.src;
-                }
-                return element.getAttribute('src') || element.getAttribute('data-src');
-            }, audioSelector);
-        }
-        if (!audioSource) {
-            throw new Error('No audio source found');
-        }
-        // Download audio if path provided
-        let downloaded = false;
-        if (downloadPath) {
-            const response = await page.goto(audioSource);
-            if (response) {
-                const fs = await import('fs/promises');
-                const buffer = await response.buffer();
-                await fs.writeFile(downloadPath, buffer);
-                downloaded = true;
-            }
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Audio Captcha Analysis:\n- Audio URL: ${audioSource}\n- Downloaded: ${downloaded ? 'Yes' : 'No'}${downloaded ? `\n- Download Path: ${downloadPath}` : ''}\n\nNote: Audio captcha solving requires external speech-to-text API (Google Speech, AWS Transcribe, etc.)`
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Audio Captcha Solver Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}
-/**
- * Puzzle Captcha Handler - Handle slider and puzzle captchas
- */
-export async function handlePuzzleCaptchaHandler(args) {
-    const { url, puzzleSelector, sliderSelector, method = 'auto' } = args;
-    try {
-        const page = getPageInstance();
-        if (!page) {
-            throw new Error('Browser not initialized. Call browser_init first.');
-        }
-        if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        }
-        const result = await page.evaluate(async (puzzleSel, sliderSel, meth) => {
-            const puzzleElement = puzzleSel ? document.querySelector(puzzleSel) : null;
-            const sliderElement = sliderSel ? document.querySelector(sliderSel) : null;
-            if (!puzzleElement && !sliderElement) {
-                throw new Error('No puzzle or slider element found');
-            }
-            const info = {
-                puzzleFound: !!puzzleElement,
-                sliderFound: !!sliderElement
-            };
-            // Get puzzle dimensions if exists
-            if (puzzleElement) {
-                const rect = puzzleElement.getBoundingClientRect();
-                info.puzzle = {
-                    width: rect.width,
-                    height: rect.height,
-                    top: rect.top,
-                    left: rect.left,
-                    visible: rect.width > 0 && rect.height > 0
-                };
-                // Check for puzzle piece
-                const puzzlePiece = puzzleElement.querySelector('.puzzle-piece, [class*="piece"], [class*="puzzle"]');
-                if (puzzlePiece) {
-                    const pieceRect = puzzlePiece.getBoundingClientRect();
-                    info.puzzlePiece = {
-                        width: pieceRect.width,
-                        height: pieceRect.height,
-                        top: pieceRect.top,
-                        left: pieceRect.left
-                    };
-                }
-            }
-            // Get slider info if exists
-            if (sliderElement) {
-                const rect = sliderElement.getBoundingClientRect();
-                info.slider = {
-                    width: rect.width,
-                    height: rect.height,
-                    top: rect.top,
-                    left: rect.left,
-                    visible: rect.width > 0 && rect.height > 0,
-                    tagName: sliderElement.tagName.toLowerCase()
-                };
-            }
-            return info;
-        }, puzzleSelector || '', sliderSelector || '', method);
-        // If auto method, attempt to solve
-        if (method === 'auto' && sliderSelector) {
-            try {
-                const sliderElement = await page.$(sliderSelector);
-                if (sliderElement) {
-                    const box = await sliderElement.boundingBox();
-                    if (box) {
-                        // Simulate drag - this is a basic implementation
-                        // Real puzzle solving would need image analysis
-                        await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
-                        await page.mouse.down();
-                        // Move in small increments
-                        const targetDistance = result.puzzle?.width || 300;
-                        const steps = 20;
-                        const stepSize = targetDistance / steps;
-                        for (let i = 0; i < steps; i++) {
-                            await page.mouse.move(box.x + box.width / 2 + (stepSize * i), box.y + box.height / 2, { steps: 5 });
-                            await sleep(50 + Math.random() * 50); // Random delay for human-like behavior
-                        }
-                        await page.mouse.up();
-                        result.attemptedSolve = true;
-                        result.method = 'automated_drag';
-                    }
-                }
-            }
-            catch (solveError) {
-                result.solveError = solveError.message;
-            }
-        }
-        let summary = `Puzzle Captcha Analysis:\n- Puzzle Found: ${result.puzzleFound ? 'Yes' : 'No'}\n- Slider Found: ${result.sliderFound ? 'Yes' : 'No'}`;
-        if (result.puzzle) {
-            summary += `\n\nPuzzle Details:\n- Dimensions: ${result.puzzle.width}x${result.puzzle.height}\n- Position: (${result.puzzle.left}, ${result.puzzle.top})\n- Visible: ${result.puzzle.visible ? 'Yes' : 'No'}`;
-        }
-        if (result.puzzlePiece) {
-            summary += `\n\nPuzzle Piece:\n- Dimensions: ${result.puzzlePiece.width}x${result.puzzlePiece.height}\n- Position: (${result.puzzlePiece.left}, ${result.puzzlePiece.top})`;
-        }
-        if (result.slider) {
-            summary += `\n\nSlider Details:\n- Dimensions: ${result.slider.width}x${result.slider.height}\n- Position: (${result.slider.left}, ${result.slider.top})\n- Visible: ${result.slider.visible ? 'Yes' : 'No'}\n- Tag: ${result.slider.tagName}`;
-        }
-        if (result.attemptedSolve) {
-            summary += `\n\nSolve Attempt:\n- Method: ${result.method}\n- Status: ${result.solveError ? 'Failed' : 'Completed'}${result.solveError ? `\n- Error: ${result.solveError}` : ''}`;
-        }
-        summary += `\n\nNote: Advanced puzzle solving requires computer vision libraries (OpenCV, TensorFlow)`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Puzzle Captcha Handler Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}

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

@@ -1,82 +0,0 @@
-// @ts-nocheck
-import Ajv from 'ajv/dist/2020.js';
-const ajv = new Ajv();
-/**
- * Data Deduplication - Remove duplicate entries from scraped data
- */
-/**
- * Missing Data Handler - Detect and handle missing data
- */
-/**
- * Data Type Validator - Validate data types against schema
- */
-export async function handleDataTypeValidator(args) {
-    const { data, schema } = args;
-    try {
-        if (!schema) {
-            throw new Error('Schema is required');
-        }
-        const validate = ajv.compile(schema);
-        const validItems = [];
-        const invalidItems = [];
-        if (Array.isArray(data)) {
-            data.forEach((item, index) => {
-                const valid = validate(item);
-                if (valid) {
-                    validItems.push(item);
-                }
-                else {
-                    invalidItems.push({
-                        item,
-                        index,
-                        errors: validate.errors
-                    });
-                }
-            });
-        }
-        else {
-            const valid = validate(data);
-            if (valid) {
-                validItems.push(data);
-            }
-            else {
-                invalidItems.push({
-                    item: data,
-                    errors: validate.errors
-                });
-            }
-        }
-        const total = Array.isArray(data) ? data.length : 1;
-        const validationRate = ((validItems.length / total) * 100).toFixed(2);
-        let summary = `Data Type Validation Results:\n\nStatistics:\n- Total Items: ${total}\n- Valid Items: ${validItems.length}\n- Invalid Items: ${invalidItems.length}\n- Validation Rate: ${validationRate}%`;
-        if (invalidItems.length > 0) {
-            summary += `\n\nInvalid Items (Top 5):\n${invalidItems.slice(0, 5).map((inv, i) => {
-                const errorMsgs = inv.errors?.map((e) => `${e.instancePath || 'root'}: ${e.message}`).join(', ') || 'Unknown error';
-                return `${i + 1}. Index ${inv.index || 'N/A'}:\n   Errors: ${errorMsgs}`;
-            }).join('\n')}`;
-        }
-        summary += `\n\nSchema: ${JSON.stringify(schema, null, 2).substring(0, 200)}${JSON.stringify(schema).length > 200 ? '...' : ''}`;
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: summary
-                }
-            ]
-        };
-    }
-    catch (error) {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Data Type Validator Error: ${error.message}`
-                }
-            ],
-            isError: true
-        };
-    }
-}
-/**
- * Consistency Checker - Check data consistency across fields
- */

package/dist/handlers/search-filter-handlers.js

@@ -1,264 +0,0 @@
-import { getPageInstance } from '../browser-manager.js';
-/**
- * Keyword Search - Advanced keyword search in page content
- */
-export async function handleKeywordSearch(args) {
-    const { url, keywords, caseSensitive = false, wholeWord = false, context = 50 } = args;
-    try {
-        const page = getPageInstance();
-        if (!page) {
-            throw new Error('Browser not initialized. Call browser_init first.');
-        }
-        if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        }
-        const results = await page.evaluate((kws, caseSens, whole, ctx) => {
-            const allMatches = [];
-            const keywordList = Array.isArray(kws) ? kws : [kws];
-            keywordList.forEach(keyword => {
-                const flags = caseSens ? 'g' : 'gi';
-                const pattern = whole ? `\\b${keyword}\\b` : keyword;
-                //const regex = new RegExp(pattern, flags);
-                const walker = document.createTreeWalker(document.body, NodeFilter.SHOW_TEXT, null);
-                let node;
-                while (node = walker.nextNode()) {
-                    const text = node.textContent || '';
-                    let match;
-                    const nodeRegex = new RegExp(pattern, flags);
-                    while ((match = nodeRegex.exec(text)) !== null) {
-                        const start = Math.max(0, match.index - ctx);
-                        const end = Math.min(text.length, match.index + match[0].length + ctx);
-                        const contextText = text.substring(start, end);
-                        // Get element info
-                        const element = node.parentElement;
-                        const tagName = element?.tagName.toLowerCase() || 'text';
-                        const className = element?.className || '';
-                        const id = element?.id || '';
-                        allMatches.push({
-                            keyword,
-                            match: match[0],
-                            position: match.index,
-                            context: contextText,
-                            element: {
-                                tag: tagName,
-                                class: className,
-                                id: id
-                            }
-                        });
-                    }
-                }
-            });
-            // Group by keyword
-            const grouped = {};
-            allMatches.forEach(m => {
-                if (!grouped[m.keyword])
-                    grouped[m.keyword] = [];
-                grouped[m.keyword].push(m);
-            });
-            return {
-                totalMatches: allMatches.length,
-                matchesByKeyword: grouped,
-                allMatches: allMatches.slice(0, 100) // Limit to first 100
-            };
-        }, Array.isArray(keywords) ? keywords : [keywords], caseSensitive, wholeWord, context);
-        const resultText = `✅ Keyword Search Results\n\nTotal Matches: ${results.totalMatches}\n\nKeywords searched: ${Array.isArray(keywords) ? keywords.join(', ') : keywords}\n\nMatches by keyword:\n${JSON.stringify(results.matchesByKeyword, null, 2)}\n\nFirst 100 matches:\n${JSON.stringify(results.allMatches, null, 2)}`;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: resultText,
-                },
-            ],
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: 'text', text: `❌ Keyword search failed: ${error.message}` }],
-            isError: true,
-        };
-    }
-}
-/**
- * Regex Pattern Matcher - Search using regular expressions
- */
-export async function handleRegexPatternMatcher(args) {
-    const { url, pattern, flags = 'g', selector } = args;
-    try {
-        const page = getPageInstance();
-        if (!page) {
-            throw new Error('Browser not initialized. Call browser_init first.');
-        }
-        if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        }
-        const results = await page.evaluate((pat, flgs, sel) => {
-            let content;
-            if (sel) {
-                const element = document.querySelector(sel);
-                content = element ? element.textContent || '' : '';
-            }
-            else {
-                content = document.body.innerText;
-            }
-            const regex = new RegExp(pat, flgs);
-            const matches = [];
-            let match;
-            // Safety check for infinite loop
-            let count = 0;
-            while ((match = regex.exec(content)) !== null && count < 1000) {
-                count++;
-                matches.push({
-                    match: match[0],
-                    index: match.index,
-                    groups: match.slice(1),
-                    context: content.substring(Math.max(0, match.index - 50), Math.min(content.length, match.index + match[0].length + 50))
-                });
-                if (match.index === regex.lastIndex) {
-                    regex.lastIndex++;
-                }
-            }
-            return {
-                totalMatches: matches.length,
-                matches: matches.slice(0, 100),
-                pattern: pat,
-                flags: flgs
-            };
-        }, pattern, flags, selector || '');
-        const resultText = `✅ Regex Pattern Matcher Results\n\nPattern: ${results.pattern}\nFlags: ${results.flags}\nTotal Matches: ${results.totalMatches}\n\nMatches (first 100):\n${JSON.stringify(results.matches, null, 2)}`;
-        return {
-            content: [{ type: 'text', text: resultText }],
-        };
-    }
-    catch (error) {
-        return { content: [{ type: 'text', text: `❌ Regex pattern matcher failed: ${error.message}` }], isError: true };
-    }
-}
-/**
- * XPath Support - Query elements using XPath
- */
-export async function handleXPathSupport(args) {
-    const { url, xpath, returnType = 'elements' } = args;
-    try {
-        const page = getPageInstance();
-        if (!page) {
-            throw new Error('Browser not initialized. Call browser_init first.');
-        }
-        if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        }
-        const results = await page.evaluate((xp, type) => {
-            const xpathResult = document.evaluate(xp, document, null, XPathResult.ANY_TYPE, null);
-            const elements = [];
-            let node = xpathResult.iterateNext();
-            while (node) {
-                if (node.nodeType === Node.ELEMENT_NODE) {
-                    const element = node;
-                    elements.push({
-                        tagName: element.tagName.toLowerCase(),
-                        id: element.id,
-                        className: element.className,
-                        text: element.textContent?.substring(0, 200),
-                        attributes: Array.from(element.attributes).reduce((acc, attr) => {
-                            acc[attr.name] = attr.value;
-                            return acc;
-                        }, {}),
-                        innerHTML: type === 'html' ? element.innerHTML.substring(0, 500) : undefined
-                    });
-                }
-                else if (node.nodeType === Node.TEXT_NODE) {
-                    elements.push({
-                        type: 'text',
-                        content: node.textContent?.trim()
-                    });
-                }
-                else if (node.nodeType === Node.ATTRIBUTE_NODE) {
-                    const attr = node;
-                    elements.push({
-                        type: 'attribute',
-                        name: attr.name,
-                        value: attr.value
-                    });
-                }
-                node = xpathResult.iterateNext();
-            }
-            return {
-                count: elements.length,
-                elements
-            };
-        }, xpath, returnType);
-        const resultText = `✅ XPath Query Results\n\nXPath: ${xpath}\nElements Found: ${results.count}\n\nElements:\n${JSON.stringify(results.elements, null, 2)}`;
-        return {
-            content: [{ type: 'text', text: resultText }],
-        };
-    }
-    catch (error) {
-        return { content: [{ type: 'text', text: `❌ XPath query failed: ${error.message}` }], isError: true };
-    }
-}
-/**
- * Advanced CSS Selectors - Support for complex CSS selectors
- */
-export async function handleAdvancedCSSSelectors(args) {
-    const { url, selector, operation = 'query', returnType = 'elements' } = args;
-    try {
-        const page = getPageInstance();
-        if (!page) {
-            throw new Error('Browser not initialized. Call browser_init first.');
-        }
-        if (url && page.url() !== url) {
-            await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });
-        }
-        const results = await page.evaluate((sel, op, type) => {
-            let elements;
-            switch (op) {
-                case 'query':
-                    elements = Array.from(document.querySelectorAll(sel));
-                    break;
-                case 'closest':
-                    const firstEl = document.querySelector(sel);
-                    elements = firstEl ? [firstEl.closest(sel)].filter(Boolean) : [];
-                    break;
-                case 'matches':
-                    elements = Array.from(document.querySelectorAll('*')).filter(el => el.matches(sel));
-                    break;
-                default:
-                    elements = Array.from(document.querySelectorAll(sel));
-            }
-            const results = elements.map(element => {
-                const computed = window.getComputedStyle(element);
-                return {
-                    tagName: element.tagName.toLowerCase(),
-                    id: element.id,
-                    className: element.className,
-                    text: element.textContent?.substring(0, 200),
-                    attributes: Array.from(element.attributes).reduce((acc, attr) => {
-                        acc[attr.name] = attr.value;
-                        return acc;
-                    }, {}),
-                    computedStyles: type === 'styles' ? {
-                        display: computed.display,
-                        visibility: computed.visibility,
-                        position: computed.position,
-                        width: computed.width,
-                        height: computed.height,
-                        color: computed.color,
-                        backgroundColor: computed.backgroundColor
-                    } : undefined,
-                    innerHTML: type === 'html' ? element.innerHTML.substring(0, 500) : undefined,
-                    boundingRect: element.getBoundingClientRect()
-                };
-            });
-            return {
-                count: results.length,
-                elements: results
-            };
-        }, selector, operation, returnType);
-        const resultText = `✅ Advanced CSS Selector Results\n\nSelector: ${selector}\nOperation: ${operation}\nElements Found: ${results.count}\n\nElements (first 10):\n${JSON.stringify(results.elements.slice(0, 10), null, 2)}`;
-        return {
-            content: [{ type: 'text', text: resultText }],
-        };
-    }
-    catch (error) {
-        return { content: [{ type: 'text', text: `❌ CSS selector query failed: ${error.message}` }], isError: true };
-    }
-}