brave-real-browser-mcp-server 2.15.5 → 2.15.7

package/dist/brave-installer.js

@@ -0,0 +1,182 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { exec, spawn } from 'child_process';
+import axios from 'axios';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+export class BraveInstaller {
+    static WINDOWS_INSTALLER_URL = 'https://laptop-updates.brave.com/latest/winx64';
+    static MAC_INSTALLER_URL = 'https://laptop-updates.brave.com/latest/osx';
+    /**
+     * Install Brave Browser based on the current platform with Silent/Auto options
+     */
+    static async install() {
+        const platform = process.platform;
+        console.error(`⬇️  Attempting to install Brave Browser for ${platform} (Silent Mode)...`);
+        try {
+            if (platform === 'win32') {
+                return await this.installOnWindows();
+            }
+            else if (platform === 'darwin') {
+                return await this.installOnMac();
+            }
+            else if (platform === 'linux') {
+                return await this.installOnLinux();
+            }
+            return false;
+        }
+        catch (error) {
+            console.error(`❌ Failed to install Brave: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Install Brave on Windows (Silent Install)
+     */
+    static async installOnWindows() {
+        const tempDir = os.tmpdir();
+        const installerPath = path.join(tempDir, 'BraveBrowserSetup.exe');
+        console.error('1️⃣  Downloading Brave Installer...');
+        try {
+            await this.downloadFile(this.WINDOWS_INSTALLER_URL, installerPath);
+        }
+        catch (e) {
+            console.error(`   Download failed: ${e.message}`);
+            return false;
+        }
+        console.error('2️⃣  Running Installer (Silent Mode)...');
+        try {
+            // /silent and /install are standard for Brave/Chrome
+            // Triggers UAC prompt if not already elevated, but handles the UI silently
+            const installCmd = `"${installerPath}" --silent --install`;
+            await execAsync(installCmd);
+            console.error('⏳ Waiting for installation to complete...');
+            // Wait multiple intervals to ensure filesystem sync
+            await new Promise(resolve => setTimeout(resolve, 30000));
+            return true;
+        }
+        catch (error) {
+            console.error('   Silent install failed, attempting interactive fallback...');
+            try {
+                // Fallback: Launch normally so user can interact
+                const child = spawn(installerPath, { detached: true, stdio: 'ignore' });
+                child.unref();
+                return true;
+            }
+            catch (e) {
+                console.error(`   Failed to launch installer: ${error.message}`);
+                return false;
+            }
+        }
+    }
+    /**
+     * Install Brave on Mac (Silent/Automated Install via DMG)
+     */
+    static async installOnMac() {
+        const tempDir = os.tmpdir();
+        const dmgPath = path.join(tempDir, 'Brave-Browser.dmg');
+        console.error('1️⃣  Downloading Brave DMG...');
+        try {
+            await this.downloadFile(this.MAC_INSTALLER_URL, dmgPath);
+        }
+        catch (e) {
+            console.error(`   Download failed: ${e.message}`);
+            return false;
+        }
+        console.error('2️⃣  Mounting DMG...');
+        try {
+            // Attach huge image quietly
+            await execAsync(`hdiutil attach "${dmgPath}" -nobrowse -quiet`);
+            console.error('3️⃣  Copying to Applications...');
+            // Copy the app bundle
+            try {
+                await execAsync(`cp -R "/Volumes/Brave Browser/Brave Browser.app" /Applications/`);
+                // Cleanup: Detach
+                try {
+                    await execAsync(`hdiutil detach "/Volumes/Brave Browser" -quiet`);
+                }
+                catch (e) { }
+                // Force attribute update to remove quarantine (avoids 'downloaded from internet' popup)
+                try {
+                    await execAsync(`xattr -r -d com.apple.quarantine "/Applications/Brave Browser.app"`);
+                }
+                catch (e) { }
+                return true;
+            }
+            catch (e) {
+                console.error('   Copy failed (Permission denied?). Opening DMG for user manually...');
+                await execAsync(`open "${dmgPath}"`);
+                return true;
+            }
+        }
+        catch (error) {
+            console.error(`   Install failed: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * Install Brave on Linux (Debian/Ubuntu/Fedora support)
+     */
+    static async installOnLinux() {
+        console.error('1️⃣  Detecting Linux distribution...');
+        try {
+            let dist = 'unknown';
+            if (fs.existsSync('/etc/debian_version'))
+                dist = 'debian';
+            else if (fs.existsSync('/etc/fedora-release'))
+                dist = 'fedora';
+            // Can extend for Arch/openSUSE if needed
+            console.error(`   Detected family: ${dist}`);
+            if (dist === 'debian') {
+                console.error('2️⃣  Installing for Debian/Ubuntu (Attempting sudo)...');
+                // Basic check if we are root or can sudo
+                const cmd = `
+                sudo apt install -y curl &&
+                sudo curl -fsSLo /usr/share/keyrings/brave-browser-archive-keyring.gpg https://brave-browser-apt-release.s3.brave.com/brave-browser-archive-keyring.gpg &&
+                echo "deb [signed-by=/usr/share/keyrings/brave-browser-archive-keyring.gpg] https://brave-browser-apt-release.s3.brave.com/ stable main" | sudo tee /etc/apt/sources.list.d/brave-browser-release.list &&
+                sudo apt update &&
+                sudo apt install -y brave-browser
+               `;
+                await execAsync(cmd);
+                return true;
+            }
+            else if (dist === 'fedora') {
+                console.error('2️⃣  Installing for Fedora/CentOS (Attempting sudo)...');
+                const cmd = `
+                sudo dnf install -y dnf-plugins-core &&
+                sudo dnf config-manager --add-repo https://brave-browser-rpm-release.s3.brave.com/brave-browser.repo &&
+                sudo rpm --import https://brave-browser-rpm-release.s3.brave.com/brave-core.asc &&
+                sudo dnf install -y brave-browser
+              `;
+                await execAsync(cmd);
+                return true;
+            }
+            else {
+                console.error('   Unsupported Linux distribution for auto-install.');
+                return false;
+            }
+        }
+        catch (error) {
+            console.error(`   Linux install failed: ${error.message}`);
+            console.error('   Note: This requires sudo/root access without password or interactive terminal.');
+            return false;
+        }
+    }
+    /**
+     * Download a file from URL to destination
+     */
+    static async downloadFile(url, dest) {
+        const writer = fs.createWriteStream(dest);
+        const response = await axios({
+            url,
+            method: 'GET',
+            responseType: 'stream'
+        });
+        response.data.pipe(writer);
+        return new Promise((resolve, reject) => {
+            writer.on('finish', resolve);
+            writer.on('error', reject);
+        });
+    }
+}

package/dist/browser-manager.js

@@ -4,6 +4,7 @@ import * as path from 'path';
 import * as net from 'net';
 import { execSync, spawn } from 'child_process';
 import { config as dotenvConfig } from 'dotenv';
+import { BraveInstaller } from './brave-installer.js';
 // Load environment variables from .env file
 // Silence dotenv output
 const originalWrite = process.stdout.write;
@@ -25,6 +26,12 @@ export var BrowserErrorType;
 // Store browser instance
 let browserInstance = null;
 let pageInstance = null;
+export function setBrowser(browser) {
+    browserInstance = browser;
+}
+export function setPage(page) {
+    pageInstance = page;
+}
 // Check environment variable for testing override
 const disableContentPriority = process.env.DISABLE_CONTENT_PRIORITY === 'true' || process.env.NODE_ENV === 'test';
 let contentPriorityConfig = {
@@ -431,7 +438,21 @@ export async function initializeBrowser(options) {
                 await closeBrowser();
             }
         }
-        const detectedBravePath = detectBravePath();
+        let detectedBravePath = detectBravePath();
+        const autoInstall = options?.autoInstall ?? true;
+        if (!detectedBravePath && autoInstall) {
+            console.error('⚠️  Brave Browser not found. autoInstall is enabled.');
+            const installed = await BraveInstaller.install();
+            if (installed) {
+                console.error('✅ Installation triggered. Retrying detection...');
+                // Wait a bit to ensure it's registered
+                await new Promise(r => setTimeout(r, 2000));
+                detectedBravePath = detectBravePath();
+            }
+        }
+        if (!detectedBravePath && !options?.customConfig?.chromePath) {
+            throw new Error('Brave Browser not found and auto-install failed or disabled. Please install Brave Browser manually: https://brave.com/download/');
+        }
         const customConfig = options?.customConfig ?? {};
         const platform = process.platform;
         const getOptimalBraveFlags = (isWindows, isRetry = false) => {

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

@@ -25,11 +25,11 @@ export async function handleExtractJSON(args) {
                 const defaultSelector = selector || 'script[type="application/json"], script[type="application/ld+json"], script';
                 const scripts = document.querySelectorAll(defaultSelector);
                 scripts.forEach((script, index) => {
+                    const content = script.textContent || '';
                     try {
-                        const content = script.textContent || '';
+                        // 1. Try direct parsing first
                         const data = JSON.parse(content);
                         if (filter) {
-                            // Simple filter check
                             const filterLower = filter.toLowerCase();
                             const dataStr = JSON.stringify(data).toLowerCase();
                             if (!dataStr.includes(filterLower))
@@ -42,7 +42,37 @@ export async function handleExtractJSON(args) {
                         });
                     }
                     catch (e) {
-                        // Invalid JSON, skip
+                        // 2. Fallback: Try to find JSON objects using regex
+                        // Matches { "key": ... } or [ ... ] structures
+                        const jsonRegex = /({[\s\S]*?}|\[[\s\S]*?\])/g;
+                        let match;
+                        while ((match = jsonRegex.exec(content)) !== null) {
+                            const potentialJson = match[0];
+                            // Basic heuristic to avoid trying to parse tiny fragments
+                            if (potentialJson.length < 20)
+                                continue;
+                            try {
+                                const data = JSON.parse(potentialJson);
+                                // Check filter
+                                if (filter) {
+                                    const filterLower = filter.toLowerCase();
+                                    const dataStr = JSON.stringify(data).toLowerCase();
+                                    if (!dataStr.includes(filterLower))
+                                        continue;
+                                }
+                                // Basic check to ensure it's a nontrivial object/array
+                                if ((Array.isArray(data) && data.length > 0) || (typeof data === 'object' && data !== null && Object.keys(data).length > 0)) {
+                                    results.push({
+                                        data,
+                                        source: 'script',
+                                        path: `script[${index}]_regex_match`,
+                                    });
+                                }
+                            }
+                            catch (e2) {
+                                // Not valid JSON
+                            }
+                        }
                     }
                 });
             }

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

@@ -67,73 +67,6 @@ export async function handleBatchElementScraper(args) {
         };
     }, 'Failed to batch scrape elements');
 }
-/**
- * Parent-child relationships maintain करते हुए data निकालता है
- */
-export async function handleNestedDataExtraction(args) {
-    return await withErrorHandling(async () => {
-        validateWorkflow('nested_data_extraction', {
-            requireBrowser: true,
-            requirePage: true,
-        });
-        const page = getCurrentPage();
-        const parentSelector = args.parentSelector;
-        const childSelector = args.childSelector;
-        const maxParents = args.maxParents || 50;
-        const nestedData = await page.evaluate(({ parentSelector, childSelector, maxParents }) => {
-            const parents = document.querySelectorAll(parentSelector);
-            const results = [];
-            let count = 0;
-            parents.forEach((parent) => {
-                if (count >= maxParents)
-                    return;
-                const parentData = {
-                    selector: parentSelector,
-                    text: Array.from(parent.childNodes)
-                        .filter((node) => node.nodeType === Node.TEXT_NODE)
-                        .map((node) => node.textContent?.trim())
-                        .filter((text) => text)
-                        .join(' '),
-                    attributes: {},
-                };
-                // Get parent attributes
-                Array.from(parent.attributes).forEach((attr) => {
-                    parentData.attributes[attr.name] = attr.value;
-                });
-                // Get children
-                const children = parent.querySelectorAll(childSelector);
-                const childrenData = [];
-                children.forEach((child) => {
-                    const childData = {
-                        selector: childSelector,
-                        text: child.textContent?.trim() || '',
-                        attributes: {},
-                    };
-                    Array.from(child.attributes).forEach((attr) => {
-                        childData.attributes[attr.name] = attr.value;
-                    });
-                    childrenData.push(childData);
-                });
-                if (childrenData.length > 0) {
-                    results.push({
-                        parent: parentData,
-                        children: childrenData,
-                    });
-                    count++;
-                }
-            });
-            return results;
-        }, { parentSelector, childSelector, maxParents });
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `✅ Extracted ${nestedData.length} parent-child relationships\n\n${JSON.stringify(nestedData, null, 2)}`,
-                },
-            ],
-        };
-    }, 'Failed to extract nested data');
-}
 /**
  * सभी elements के attributes (href, src, data-*) collect करता है
  */
@@ -213,6 +146,10 @@ export async function handleLinkHarvester(args) {
             const results = [];
             links.forEach((link, index) => {
                 const href = link.href;
+                // Skip if no href (e.g. button without href)
+                if (!href) {
+                    return;
+                }
                 // Skip anchors if not included
                 if (!includeAnchors && href.startsWith('#')) {
                     return;
@@ -244,6 +181,7 @@ export async function handleLinkHarvester(args) {
                     }
                     catch (e) {
                         linkInfo.type = 'invalid';
+                        linkInfo.domain = 'unknown'; // Ensure domain exists even if invalid
                     }
                 }
                 // Additional attributes

package/dist/handlers/navigation-handlers.js

@@ -143,3 +143,62 @@ async function withWorkflowValidation(toolName, args, operation) {
         throw error;
     }
 }
+/**
+ * Site structure follow करके pages scrape करता है
+ */
+export async function handleBreadcrumbNavigator(args) {
+    return await withWorkflowValidation('breadcrumb_navigator', args, async () => {
+        return await withErrorHandling(async () => {
+            const page = getPageInstance();
+            if (!page) {
+                throw new Error('Browser not initialized. Call browser_init first.');
+            }
+            const breadcrumbSelector = args.breadcrumbSelector || '.breadcrumb, nav[aria-label="breadcrumb"], .breadcrumbs';
+            const followLinks = args.followLinks || false;
+            const breadcrumbData = await page.evaluate((selector) => {
+                const breadcrumbs = document.querySelectorAll(selector);
+                const results = [];
+                breadcrumbs.forEach((breadcrumb) => {
+                    const links = breadcrumb.querySelectorAll('a');
+                    const items = [];
+                    links.forEach((link, index) => {
+                        items.push({
+                            text: link.textContent?.trim() || '',
+                            href: link.href,
+                            level: index,
+                        });
+                    });
+                    if (items.length > 0) {
+                        results.push({
+                            path: items.map((i) => i.text).join(' > '),
+                            links: items,
+                        });
+                    }
+                });
+                return results;
+            }, breadcrumbSelector);
+            if (breadcrumbData.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '❌ No breadcrumbs found on page',
+                        },
+                    ],
+                };
+            }
+            let additionalData = '';
+            if (followLinks && breadcrumbData[0]?.links) {
+                additionalData = `\n\n📌 To scrape breadcrumb pages, use multi_page_scraper with URLs: ${JSON.stringify(breadcrumbData[0].links.map((l) => l.href))}`;
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Found ${breadcrumbData.length} breadcrumb trail(s)\n\n${JSON.stringify(breadcrumbData, null, 2)}${additionalData}`,
+                    },
+                ],
+            };
+        }, 'Failed to navigate breadcrumbs');
+    });
+}

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

@@ -262,124 +262,3 @@ export async function handleAdvancedCSSSelectors(args) {
         return { content: [{ type: 'text', text: `❌ CSS selector query failed: ${error.message}` }], isError: true };
     }
 }
-/**
- * Visual Element Finder - Find elements by visual properties
- */
-export async function handleVisualElementFinder(args) {
-    const { url, criteria } = 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((crit) => {
-            const allElements = Array.from(document.querySelectorAll('*'));
-            const matches = [];
-            allElements.forEach(element => {
-                const computed = window.getComputedStyle(element);
-                const rect = element.getBoundingClientRect();
-                let matchScore = 0;
-                const reasons = [];
-                // Check visibility
-                if (crit.visible !== undefined) {
-                    const isVisible = computed.display !== 'none' &&
-                        computed.visibility !== 'hidden' &&
-                        rect.width > 0 &&
-                        rect.height > 0;
-                    if (isVisible === crit.visible) {
-                        matchScore += 10;
-                        reasons.push('visibility');
-                    }
-                }
-                // Check color
-                if (crit.color) {
-                    if (computed.color.includes(crit.color) || computed.backgroundColor.includes(crit.color)) {
-                        matchScore += 5;
-                        reasons.push('color');
-                    }
-                }
-                // Check size
-                if (crit.minWidth && rect.width >= crit.minWidth) {
-                    matchScore += 3;
-                    reasons.push('minWidth');
-                }
-                if (crit.maxWidth && rect.width <= crit.maxWidth) {
-                    matchScore += 3;
-                    reasons.push('maxWidth');
-                }
-                if (crit.minHeight && rect.height >= crit.minHeight) {
-                    matchScore += 3;
-                    reasons.push('minHeight');
-                }
-                if (crit.maxHeight && rect.height <= crit.maxHeight) {
-                    matchScore += 3;
-                    reasons.push('maxHeight');
-                }
-                // Check position
-                if (crit.position) {
-                    if (computed.position === crit.position) {
-                        matchScore += 5;
-                        reasons.push('position');
-                    }
-                }
-                // Check text content
-                if (crit.hasText !== undefined) {
-                    const hasText = (element.textContent?.trim().length || 0) > 0;
-                    if (hasText === crit.hasText) {
-                        matchScore += 5;
-                        reasons.push('hasText');
-                    }
-                }
-                // Check if element is in viewport
-                if (crit.inViewport !== undefined) {
-                    const inViewport = rect.top >= 0 &&
-                        rect.left >= 0 &&
-                        rect.bottom <= window.innerHeight &&
-                        rect.right <= window.innerWidth;
-                    if (inViewport === crit.inViewport) {
-                        matchScore += 5;
-                        reasons.push('inViewport');
-                    }
-                }
-                if (matchScore > 0) {
-                    matches.push({
-                        element: {
-                            tagName: element.tagName.toLowerCase(),
-                            id: element.id,
-                            className: element.className,
-                            text: element.textContent?.substring(0, 100)
-                        },
-                        score: matchScore,
-                        matchedCriteria: reasons,
-                        visualProperties: {
-                            display: computed.display,
-                            visibility: computed.visibility,
-                            position: computed.position,
-                            color: computed.color,
-                            backgroundColor: computed.backgroundColor,
-                            width: rect.width,
-                            height: rect.height,
-                            top: rect.top,
-                            left: rect.left
-                        }
-                    });
-                }
-            });
-            matches.sort((a, b) => b.score - a.score);
-            return {
-                totalMatches: matches.length,
-                topMatches: matches.slice(0, 20)
-            };
-        }, criteria);
-        const resultText = `✅ Visual Element Finder Results\n\nCriteria: ${JSON.stringify(criteria, null, 2)}\nTotal Matches: ${results.totalMatches}\n\nTop Matches:\n${JSON.stringify(results.topMatches, null, 2)}`;
-        return {
-            content: [{ type: 'text', text: resultText }],
-        };
-    }
-    catch (error) {
-        return { content: [{ type: 'text', text: `❌ Visual element finder failed: ${error.message}` }], isError: true };
-    }
-}

package/dist/handlers/smart-data-extractors.js

@@ -307,7 +307,18 @@ export async function handleFetchXHR(args) {
         });
         const page = getCurrentPage();
         const duration = args.duration || 15000;
+        const forceReload = args.forceReload !== false; // Default true to capture initial requests
         const xhrData = [];
+        // Capture requests too for completeness
+        const requestHandler = (request) => {
+            try {
+                const resourceType = request.resourceType();
+                if (resourceType === 'xhr' || resourceType === 'fetch') {
+                    // Optional: Log request if needed, but for now we focus on responses with bodies
+                }
+            }
+            catch (e) { }
+        };
         const responseHandler = async (response) => {
             const request = response.request();
             const resourceType = request.resourceType();
@@ -320,7 +331,8 @@ export async function handleFetchXHR(args) {
                         statusText: response.statusText(),
                         headers: response.headers(),
                         method: request.method(),
-                        body: body.substring(0, 1000), // First 1000 chars
+                        postData: request.postData(),
+                        body: body.substring(0, 5000), // Increased limit
                         timestamp: new Date().toISOString(),
                     });
                 }
@@ -330,6 +342,14 @@ export async function handleFetchXHR(args) {
             }
         };
         page.on('response', responseHandler);
+        if (forceReload) {
+            try {
+                await page.reload({ waitUntil: 'networkidle2', timeout: 30000 });
+            }
+            catch (e) {
+                // Continue even if reload times out
+            }
+        }
         await sleep(duration);
         page.off('response', responseHandler);
         return {