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

package/dist/handlers/ai-powered-handlers.js

@@ -1,7 +1,6 @@
-// @ts-nocheck
 import { getPageInstance } from '../browser-manager.js';
 /**
- * Smart Selector Generator - AI-powered CSS selector generation
+ * Smart Selector Generator - AI-powered CSS selector generation (Heuristic)
  */
 export async function handleSmartSelectorGenerator(args) {
     const { url, description, context } = args;
@@ -27,7 +26,7 @@ export async function handleSmartSelectorGenerator(args) {
                 keywords.forEach(keyword => {
                     if (text.includes(keyword))
                         score += 10;
-                    if (className.includes(keyword))
+                    if (typeof className === 'string' && className.includes(keyword))
                         score += 5;
                     if (id.includes(keyword))
                         score += 5;
@@ -48,9 +47,9 @@ export async function handleSmartSelectorGenerator(args) {
                     // Generate selector
                     let selector = tag;
                     if (id)
-                        selector = `#${id}`;
-                    else if (className)
-                        selector = `${tag}.${className.split(' ')[0]}`;
+                        selector = `#${CSS.escape(id)}`;
+                    else if (typeof className === 'string' && className.trim())
+                        selector = `${tag}.${CSS.escape(className.trim().split(/\s+/)[0])}`;
                     scores.push({ selector, score, text: text.substring(0, 100), element: tag });
                 }
             });
@@ -62,11 +61,11 @@ export async function handleSmartSelectorGenerator(args) {
                 totalCandidates: scores.length
             };
         }, description, context || '');
-        const resultText = `? Smart Selector Generated\n\nBest Match: ${JSON.stringify(result.bestMatch, null, 2)}\nAlternatives: ${JSON.stringify(result.alternatives, null, 2)}\nTotal Candidates: ${result.totalCandidates}`;
+        const resultText = `🤖 Smart Selector Generated\n\nBest Match: ${JSON.stringify(result.bestMatch, null, 2)}\nAlternatives: ${JSON.stringify(result.alternatives, null, 2)}\nTotal Candidates: ${result.totalCandidates}`;
         return { content: [{ type: 'text', text: resultText }] };
     }
     catch (error) {
-        return { content: [{ type: 'text', text: `? Error: ${error.message}` }], isError: true };
+        return { content: [{ type: 'text', text: `❌ Error: ${error.message}` }], isError: true };
     }
 }
 /**
@@ -115,25 +114,122 @@ export async function handleContentClassification(args) {
             return { category: cat.name, score };
         });
         scores.sort((a, b) => b.score - a.score);
-        const confidence = scores[0].score / (scores.reduce((sum, s) => sum + s.score, 0) || 1);
-        const resultText = `✅ Content Classification\n\nPrimary Category: ${scores[0].category} (Score: ${scores[0].score})\nConfidence: ${(confidence * 100).toFixed(2)}%\n\nAll Categories:\n${JSON.stringify(scores.slice(0, 5), null, 2)}`;
+        const match = scores[0];
+        const totalScore = scores.reduce((sum, s) => sum + s.score, 0) || 1;
+        const confidence = match.score / totalScore;
+        const resultText = `✅ Content Classification\n\nPrimary Category: ${match.category} (Score: ${match.score})\nConfidence: ${(confidence * 100).toFixed(2)}%\n\nAll Categories:\n${JSON.stringify(scores.slice(0, 5), null, 2)}`;
+        return {
+            content: [{ type: 'text', text: resultText }]
+        };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `❌ Error: ${error.message}` }], isError: true };
+    }
+}
+/**
+ * Sentiment Analysis - Analyze sentiment of page content (Basic Heuristic)
+ */
+export async function handleSentimentAnalysis(args) {
+    try {
+        let textToAnalyze = args.text || '';
+        if (args.url || args.selector) {
+            const page = getPageInstance();
+            if (!page)
+                throw new Error('Browser not initialized');
+            if (args.url && page.url() !== args.url) {
+                await page.goto(args.url, { waitUntil: 'domcontentloaded' });
+            }
+            if (args.selector) {
+                textToAnalyze = await page.evaluate((sel) => document.querySelector(sel)?.textContent || '', args.selector);
+            }
+            else if (!textToAnalyze) {
+                textToAnalyze = await page.evaluate(() => document.body.innerText);
+            }
+        }
+        if (!textToAnalyze)
+            throw new Error('No text to analyze');
+        // Simple Bag of Words
+        const positiveWords = ['good', 'great', 'awesome', 'excellent', 'happy', 'love', 'best', 'wonderful', 'amazing'];
+        const negativeWords = ['bad', 'terrible', 'awful', 'worst', 'hate', 'sad', 'poor', 'disappointing', 'fail'];
+        const lowerText = textToAnalyze.toLowerCase();
+        let score = 0;
+        let matchCount = 0;
+        positiveWords.forEach(w => {
+            const regex = new RegExp(`\\b${w}\\b`, 'g');
+            const count = (lowerText.match(regex) || []).length;
+            score += count;
+            matchCount += count;
+        });
+        negativeWords.forEach(w => {
+            const regex = new RegExp(`\\b${w}\\b`, 'g');
+            const count = (lowerText.match(regex) || []).length;
+            score -= count;
+            matchCount += count;
+        });
+        let sentiment = 'Neutral';
+        if (score > 0)
+            sentiment = 'Positive';
+        if (score < 0)
+            sentiment = 'Negative';
         return {
             content: [{
                     type: 'text',
-                    text: resultText
+                    text: JSON.stringify({ sentiment, score, matchCount, analyzedLength: textToAnalyze.length }, null, 2)
                 }]
         };
     }
     catch (error) {
-        return { content: [{ type: 'text', text: `? Error: ${error.message}` }], isError: true };
+        return { content: [{ type: 'text', text: `❌ Error: ${error.message}` }], isError: true };
     }
 }
 /**
- * Sentiment Analysis - Analyze sentiment of page content
- */
-/**
- * Summary Generator - Generate summary of page content
+ * Summary Generator - Generate summary of page content (Basic Truncation/Extraction)
  */
+export async function handleSummaryGenerator(args) {
+    try {
+        let textToSummary = args.text || '';
+        if (args.url || args.selector) {
+            const page = getPageInstance();
+            if (!page)
+                throw new Error('Browser not initialized');
+            if (args.url && page.url() !== args.url) {
+                await page.goto(args.url, { waitUntil: 'domcontentloaded' });
+            }
+            if (args.selector) {
+                textToSummary = await page.evaluate((sel) => document.querySelector(sel)?.textContent || '', args.selector);
+            }
+            else if (!textToSummary) {
+                // Heuristic: Get paragraphs
+                textToSummary = await page.evaluate(() => {
+                    return Array.from(document.querySelectorAll('p')).map(p => p.textContent).join('\n\n');
+                });
+            }
+        }
+        if (!textToSummary)
+            throw new Error('No text to summarize');
+        // Basic Summary: First 5 sentences or maxLength
+        const sentences = textToSummary.split(/[.!?]+/).filter(s => s.trim().length > 20);
+        const summary = sentences.slice(0, 5).join('. ') + '.';
+        const finalSummary = args.maxLength ? summary.slice(0, args.maxLength) : summary;
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ summary: finalSummary, originalLength: textToSummary.length }, null, 2)
+                }]
+        };
+    }
+    catch (error) {
+        return { content: [{ type: 'text', text: `❌ Error: ${error.message}` }], isError: true };
+    }
+}
 /**
- * Translation Support - Detect language and provide translation info
+ * Translation Support - Placeholder
  */
+export async function handleTranslationSupport(args) {
+    return {
+        content: [{
+                type: 'text',
+                text: `⚠️ Translation Support requires an external API (e.g., Google Translate, DeepL). This feature is defined but currently running in 'offline' mode. To implement, valid API keys would be required.\n\nInput extracted: ${args.text ? 'Yes' : 'No'}\nTarget Language: ${args.targetLanguage}`
+            }]
+    };
+}

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

@@ -255,3 +255,77 @@ 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)) {
+            if (!rules)
+                return { content: [{ type: "text", text: "No rules provided. Pass." }] };
+            throw new Error('Rules must be an array');
+        }
+        const report = {
+            totalItems: data.length,
+            passedItems: 0,
+            failedItems: 0,
+            failures: []
+        };
+        data.forEach((item, index) => {
+            let itemPassed = true;
+            const itemFailures = [];
+            rules.forEach((rule) => {
+                try {
+                    if (rule.type === 'dependency') {
+                        if (item[rule.field] && !item[rule.dependentField]) {
+                            itemPassed = false;
+                            itemFailures.push(`Field '${rule.field}' requires '${rule.dependentField}'`);
+                        }
+                    }
+                    else if (rule.type === 'value_match') {
+                        if (item[rule.field] === rule.value && item[rule.targetField] !== rule.targetValue) {
+                            itemPassed = false;
+                            itemFailures.push(`When '${rule.field}' is '${rule.value}', '${rule.targetField}' must be '${rule.targetValue}'`);
+                        }
+                    }
+                }
+                catch (e) {
+                    itemPassed = false;
+                    // @ts-ignore
+                    itemFailures.push(`Rule execution error: ${e.message}`);
+                }
+            });
+            if (itemPassed) {
+                report.passedItems++;
+            }
+            else {
+                report.failedItems++;
+                report.failures.push({
+                    index,
+                    item,
+                    errors: itemFailures
+                });
+            }
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Consistency Check Results:\nTotal: ${report.totalItems}\nPassed: ${report.passedItems}\nFailed: ${report.failedItems}\n\nFailures:\n${JSON.stringify(report.failures, null, 2)}`
+                }
+            ]
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Consistency Checker Error: ${error.message}`
+                }
+            ],
+            isError: true
+        };
+    }
+}

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

@@ -0,0 +1,66 @@
+import TurndownService from 'turndown';
+export async function handleHtmlToText(args) {
+    try {
+        const turndownService = new TurndownService({
+            headingStyle: 'atx',
+            codeBlockStyle: 'fenced'
+        });
+        // Config based on args
+        if (!args.preserveLinks) {
+            turndownService.addRule('no-links', {
+                filter: 'a',
+                replacement: function (content) { return content; }
+            });
+        }
+        const text = turndownService.turndown(args.html);
+        return {
+            content: [{
+                    type: 'text',
+                    text: text
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Error converting HTML to text: ${error}`
+                }],
+            isError: true
+        };
+    }
+}
+export async function handleDuplicateRemover(args) {
+    if (!Array.isArray(args.data)) {
+        throw new Error("Input 'data' must be an array.");
+    }
+    let uniqueData;
+    if (args.uniqueKey) {
+        const seen = new Set();
+        uniqueData = args.data.filter(item => {
+            const val = item[args.uniqueKey];
+            if (seen.has(val))
+                return false;
+            seen.add(val);
+            return true;
+        });
+    }
+    else {
+        // Deep equality check or simple JSON stringify check?
+        // Use JSON stringify for simplicity and speed on complex objects
+        const seen = new Set();
+        uniqueData = args.data.filter(item => {
+            const val = JSON.stringify(item);
+            if (seen.has(val))
+                return false;
+            seen.add(val);
+            return true;
+        });
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(uniqueData, null, 2)
+            }]
+    };
+}

package/dist/handlers/dom-handlers.js

@@ -0,0 +1,206 @@
+import { getPageInstance } from '../browser-manager.js';
+export async function handleHtmlElementsExtractor(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const selector = args.selector || '*';
+    const max = args.maxElements || 100;
+    const includeStyles = args.includeStyles || false;
+    const elements = await page.evaluate((sel, maxCount, incStyles) => {
+        const els = Array.from(document.querySelectorAll(sel)).slice(0, maxCount);
+        return els.map(el => {
+            const rect = el.getBoundingClientRect();
+            const info = {
+                tagName: el.tagName.toLowerCase(),
+                id: el.id,
+                className: el.className,
+                text: el.textContent?.slice(0, 100).trim(),
+                attributes: {},
+                rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height }
+            };
+            if (incStyles) {
+                const computed = window.getComputedStyle(el);
+                info.styles = {
+                    display: computed.display,
+                    position: computed.position,
+                    color: computed.color,
+                    backgroundColor: computed.backgroundColor,
+                    fontSize: computed.fontSize
+                };
+            }
+            Array.from(el.attributes).forEach((attr) => {
+                info.attributes[attr.name] = attr.value;
+            });
+            return info;
+        });
+    }, selector, max, includeStyles);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(elements, null, 2)
+            }]
+    };
+}
+export async function handleTagsFinder(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const results = await page.evaluate((tags) => {
+        const found = {};
+        tags.forEach(tag => {
+            const elements = document.querySelectorAll(tag);
+            found[tag] = Array.from(elements).map(el => ({
+                text: el.textContent?.slice(0, 50).trim(),
+                html: el.outerHTML.slice(0, 100)
+            }));
+        });
+        return found;
+    }, args.tags);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(results, null, 2)
+            }]
+    };
+}
+export async function handleLinksFinder(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const includeExt = args.includeExternal ?? true;
+    const max = args.maxLinks ?? 200;
+    const links = await page.evaluate((incExt, maxCount) => {
+        const allLinks = Array.from(document.querySelectorAll('a[href]'));
+        const filtered = incExt
+            ? allLinks
+            : allLinks.filter(a => a.href.startsWith(window.location.origin));
+        return filtered.slice(0, maxCount).map(a => ({
+            text: a.textContent?.trim(),
+            href: a.href,
+            isExternal: !a.href.startsWith(window.location.origin)
+        }));
+    }, includeExt, max);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(links, null, 2)
+            }]
+    };
+}
+export async function handleXpathLinks(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const links = await page.evaluate((xpathExpr) => {
+        const result = document.evaluate(xpathExpr, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
+        const items = [];
+        for (let i = 0; i < result.snapshotLength; i++) {
+            const node = result.snapshotItem(i);
+            if (node instanceof HTMLAnchorElement) {
+                items.push({ text: node.textContent?.trim(), href: node.href });
+            }
+            else if (node && node.textContent) {
+                items.push({ text: node.textContent.trim() });
+            }
+        }
+        return items;
+    }, args.xpath);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(links, null, 2)
+            }]
+    };
+}
+export async function handleShadowDomExtractor(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const sel = args.selector || '*';
+    const results = await page.evaluate((selector) => {
+        function findAllShadowRoots(root) {
+            const shadowRoots = [];
+            if (root instanceof Element && root.shadowRoot) {
+                shadowRoots.push(root.shadowRoot);
+                shadowRoots.push(...findAllShadowRoots(root.shadowRoot));
+            }
+            if (root.childNodes) {
+                root.childNodes.forEach(child => {
+                    shadowRoots.push(...findAllShadowRoots(child));
+                });
+            }
+            return shadowRoots;
+        }
+        const allShadows = findAllShadowRoots(document.body);
+        const data = [];
+        allShadows.forEach((shadow, index) => {
+            const elements = shadow.querySelectorAll(selector);
+            if (elements.length > 0) {
+                data.push({
+                    shadowRootIndex: index,
+                    elements: Array.from(elements).map(el => el.outerHTML)
+                });
+            }
+        });
+        return data;
+    }, sel);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({ message: `Found content in ${results.length} shadow roots`, data: results }, null, 2)
+            }]
+    };
+}
+export async function handleIframeExtractor() {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const frames = page.frames();
+    const frameData = await Promise.all(frames.map(async (frame, index) => {
+        try {
+            const title = await frame.title();
+            const url = frame.url();
+            const bodyText = await frame.evaluate(() => document.body.innerText.slice(0, 500));
+            return {
+                id: index,
+                url,
+                title,
+                preview: bodyText,
+                isMainFrame: frame === page.mainFrame()
+            };
+        }
+        catch (e) {
+            return { id: index, error: String(e) };
+        }
+    }));
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(frameData, null, 2)
+            }]
+    };
+}
+export async function handleEmbedPageExtractor() {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const embeds = await page.evaluate(() => {
+        const embedTags = Array.from(document.querySelectorAll('embed')).map(el => ({
+            type: 'embed',
+            src: el.src,
+            typeAttr: el.type
+        }));
+        const objectTags = Array.from(document.querySelectorAll('object')).map(el => ({
+            type: 'object',
+            data: el.data,
+            typeAttr: el.type // Type casting
+        }));
+        return [...embedTags, ...objectTags];
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(embeds, null, 2)
+            }]
+    };
+}

package/dist/handlers/network-handlers.js

@@ -0,0 +1,111 @@
+import { getPageInstance } from '../browser-manager.js';
+async function captureNetwork(page, duration, filter) {
+    const captured = [];
+    const responseHandler = async (response) => {
+        try {
+            const request = response.request();
+            if (filter(request, response)) {
+                let body = '[Binary or Too Large]';
+                try {
+                    const type = response.headers()['content-type'] || '';
+                    if (type.includes('text') || type.includes('json') || type.includes('xml')) {
+                        body = await response.text();
+                    }
+                }
+                catch (e) {
+                    // Ignore
+                }
+                captured.push({
+                    url: response.url(),
+                    method: request.method(),
+                    type: request.resourceType(),
+                    status: response.status(),
+                    headers: response.headers(),
+                    body: body.slice(0, 5000)
+                });
+            }
+        }
+        catch (e) {
+            // ignore
+        }
+    };
+    page.on('response', responseHandler);
+    await new Promise(resolve => setTimeout(resolve, duration));
+    page.off('response', responseHandler);
+    return captured;
+}
+export async function handleNetworkRecorder(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const duration = args.duration || 10000;
+    const results = await captureNetwork(page, duration, (req, res) => {
+        if (!args.filterTypes || args.filterTypes.length === 0)
+            return true;
+        const type = req.resourceType().toLowerCase();
+        return args.filterTypes.includes(type);
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(results, null, 2)
+            }]
+    };
+}
+export async function handleAjaxExtractor(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    const duration = args.duration || 15000;
+    const results = await captureNetwork(page, duration, (req, res) => {
+        const type = req.resourceType();
+        const isXhr = type === 'xhr' || type === 'fetch';
+        if (!isXhr)
+            return false;
+        if (args.url && !req.url().includes(args.url))
+            return false;
+        return true;
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify(results, null, 2)
+            }]
+    };
+}
+export async function handleFetchXhr(args) {
+    return handleAjaxExtractor({ duration: args.duration });
+}
+export async function handleApiFinder(args) {
+    const page = getPageInstance();
+    if (!page)
+        throw new Error('Browser not initialized');
+    // 1. Static Analysis
+    const staticApis = await page.evaluate(() => {
+        const patterns = [/\/api\//, /\/v\d+\//, /graphql/, /\.json$/];
+        const candidates = new Set();
+        document.querySelectorAll('script').forEach(s => {
+            if (s.src)
+                candidates.add(s.src);
+        });
+        document.querySelectorAll('a').forEach(a => {
+            candidates.add(a.href);
+        });
+        return Array.from(candidates).filter(url => patterns.some(p => p.test(url)));
+    });
+    // 2. Dynamic Analysis
+    const dynamicApis = await captureNetwork(page, 5000, (req, res) => {
+        const type = req.resourceType();
+        const contentType = res.headers()['content-type'] || '';
+        return (type === 'xhr' || type === 'fetch') && contentType.includes('json');
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    staticAnalysis: staticApis,
+                    dynamicCapture: dynamicApis.map(d => d.url)
+                }, null, 2)
+            }]
+    };
+}