brave-real-browser-mcp-server 2.15.6 → 2.16.0

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

@@ -146,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;
@@ -177,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/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 {

package/dist/index.js

@@ -22,7 +22,7 @@ import { setupProcessCleanup, } from "./core-infrastructure.js";
 console.error("🔍 [DEBUG] Loading handlers...");
 import { handleBrowserInit, handleBrowserClose, } from "./handlers/browser-handlers.js";
 import { handleNavigate, handleWait } from "./handlers/navigation-handlers.js";
-import { handleClick, handleType, handleSolveCaptcha, handleRandomScroll, } from "./handlers/interaction-handlers.js";
+import { handleClick, handleType, handleSolveCaptcha, handleRandomScroll, handlePressKey, } from "./handlers/interaction-handlers.js";
 import { handleGetContent, handleFindSelector, } from "./handlers/content-handlers.js";
 import { handleSaveContentAsMarkdown } from "./handlers/file-handlers.js";
 // Import new data extraction handlers
@@ -42,13 +42,13 @@ import { handleOCREngine, handleAudioCaptchaSolver, handlePuzzleCaptchaHandler,
 // Import visual tools handlers
 import { handleElementScreenshot, handleVideoRecording, } from "./handlers/visual-tools-handlers.js";
 // Import smart data extractors
-import { handleHtmlElementsExtractor, handleTagsFinder, handleLinksFinder, handleXpathLinks, handleAjaxExtractor, handleFetchXHR, handleNetworkRecorder, handleRegexPatternFinder, handleIframeExtractor, handleEmbedPageExtractor, handleImageExtractorAdvanced, handleVideoSourceExtractor, handleUrlRedirectTracer, handleUserAgentExtractor, } from "./handlers/smart-data-extractors.js";
+import { handleFetchXHR, handleNetworkRecorder, handleImageExtractorAdvanced, handleVideoSourceExtractor, handleUrlRedirectTracer, handleApiFinder, } from "./handlers/smart-data-extractors.js";
 // Import dynamic session handlers
-import { handleShadowDOMExtractor, handleFormAutoFill, handleAjaxContentWaiter, } from "./handlers/dynamic-session-handlers.js";
+import { handleAjaxContentWaiter, } from "./handlers/dynamic-session-handlers.js";
 // Import monitoring & reporting handlers
 import { handleProgressTracker, } from "./handlers/monitoring-reporting-handlers.js";
 // Import advanced video & media handlers
-import { handleVideoLinkFinder, handleVideoDownloadButton, handleVideoPlayPushSource, handleVideoPlayButtonClick, } from "./handlers/advanced-video-media-handlers.js";
+import { handleVideoPlayerFinder, handleStreamDetector, handleVideoDownloadLinkFinder, } from "./handlers/advanced-video-media-handlers.js";
 // Import advanced extraction handlers (Ad-bypass & Obfuscation)
 import { handleAdvancedVideoExtraction, handleDeobfuscateJS, handleMultiLayerRedirectTrace, handleAdProtectionDetector, } from "./handlers/advanced-extraction-handlers.js";
 console.error("🔍 [DEBUG] All modules loaded successfully");
@@ -130,6 +130,9 @@ export async function executeToolByName(name, args) {
             case TOOL_NAMES.RANDOM_SCROLL:
                 result = await handleRandomScroll();
                 break;
+            case TOOL_NAMES.PRESS_KEY:
+                result = await handlePressKey(args);
+                break;
             case TOOL_NAMES.FIND_SELECTOR:
                 result = await handleFindSelector(args);
                 break;
@@ -210,35 +213,14 @@ export async function executeToolByName(name, args) {
                 result = await handleVideoRecording(args);
                 break;
             // Smart Data Extractors (Advanced)
-            case "html_elements_extractor":
-                result = await handleHtmlElementsExtractor(args || {});
-                break;
-            case "tags_finder":
-                result = await handleTagsFinder(args || {});
-                break;
-            case "links_finder":
-                result = await handleLinksFinder(args || {});
-                break;
-            case "xpath_links":
-                result = await handleXpathLinks(args || {});
-                break;
-            case "ajax_extractor":
-                result = await handleAjaxExtractor(args || {});
-                break;
             case "fetch_xhr":
                 result = await handleFetchXHR(args || {});
                 break;
             case "network_recorder":
                 result = await handleNetworkRecorder(args || {});
                 break;
-            case "regex_pattern_finder":
-                result = await handleRegexPatternFinder(args);
-                break;
-            case "iframe_extractor":
-                result = await handleIframeExtractor(args || {});
-                break;
-            case "embed_page_extractor":
-                result = await handleEmbedPageExtractor(args || {});
+            case "api_finder":
+                result = await handleApiFinder(args || {});
                 break;
             case "image_extractor_advanced":
                 result = await handleImageExtractorAdvanced(args || {});
@@ -249,16 +231,7 @@ export async function executeToolByName(name, args) {
             case "url_redirect_tracer":
                 result = await handleUrlRedirectTracer(args);
                 break;
-            case "user_agent_extractor":
-                result = await handleUserAgentExtractor(args || {});
-                break;
             // Dynamic Content & Session Handling
-            case "shadow_dom_extractor":
-                result = await handleShadowDOMExtractor(args || {});
-                break;
-            case "form_auto_fill":
-                result = await handleFormAutoFill(args);
-                break;
             case "ajax_content_waiter":
                 result = await handleAjaxContentWaiter(args);
                 break;
@@ -267,17 +240,14 @@ export async function executeToolByName(name, args) {
                 result = await handleProgressTracker(args || {});
                 break;
             // Advanced Video & Media Download Tools
-            case "video_link_finder":
-                result = await handleVideoLinkFinder(args || {});
-                break;
-            case "video_download_button":
-                result = await handleVideoDownloadButton(args);
+            case "video_player_finder":
+                result = await handleVideoPlayerFinder(args || {});
                 break;
-            case "video_play_push_source":
-                result = await handleVideoPlayPushSource(args || {});
+            case "stream_detector":
+                result = await handleStreamDetector(args || {});
                 break;
-            case "video_play_button_click":
-                result = await handleVideoPlayButtonClick(args || {});
+            case "video_download_link_finder":
+                result = await handleVideoDownloadLinkFinder(args || {});
                 break;
             // Advanced Extraction Tools (Ad-Bypass & Obfuscation)
             case "advanced_video_extraction":

package/dist/tool-definitions.js

@@ -32,7 +32,11 @@ export const TOOLS = [
                 headless: {
                     type: 'boolean',
                     description: 'Run browser in headless mode',
-                    default: false,
+                },
+                autoInstall: {
+                    type: 'boolean',
+                    description: 'Automatically install Brave Browser if not found (Default: true)',
+                    default: true,
                 },
                 disableXvfb: {
                     type: 'boolean',
@@ -599,60 +603,6 @@ export const TOOLS = [
         },
     },
     // Smart Data Extractors (Advanced)
-    {
-        name: 'html_elements_extractor',
-        description: 'Extract all HTML elements with complete details',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string', default: '*' },
-                maxElements: { type: 'number', default: 100 },
-                includeStyles: { type: 'boolean', default: false },
-            },
-        },
-    },
-    {
-        name: 'tags_finder',
-        description: 'Find specific HTML tags',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                tags: { type: 'array', items: { type: 'string' }, default: ['div', 'span', 'p', 'a', 'img'] },
-            },
-        },
-    },
-    {
-        name: 'links_finder',
-        description: 'Extract all links from page',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                includeExternal: { type: 'boolean', default: true },
-                maxLinks: { type: 'number', default: 200 },
-            },
-        },
-    },
-    {
-        name: 'xpath_links',
-        description: 'Use XPath to find links',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                xpath: { type: 'string', default: '//a[@href]' },
-            },
-        },
-    },
-    {
-        name: 'ajax_extractor',
-        description: 'Extract AJAX/XHR request data',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                duration: { type: 'number', default: 15000 },
-                url: { type: 'string' },
-            },
-        },
-    },
     {
         name: 'fetch_xhr',
         description: 'Capture fetch and XHR requests with responses',
@@ -684,34 +634,6 @@ export const TOOLS = [
             },
         },
     },
-    {
-        name: 'regex_pattern_finder',
-        description: 'Find patterns using regex',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                pattern: { type: 'string' },
-                flags: { type: 'string', default: 'gi' },
-            },
-            required: ['pattern'],
-        },
-    },
-    {
-        name: 'iframe_extractor',
-        description: 'Extract all iframes and their content',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'embed_page_extractor',
-        description: 'Extract embedded content (iframes, objects, embeds)',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
     {
         name: 'image_extractor_advanced',
         description: 'Advanced image extraction with metadata',
@@ -733,37 +655,7 @@ export const TOOLS = [
             required: ['url'],
         },
     },
-    {
-        name: 'user_agent_extractor',
-        description: 'Extract user agent information',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
     // Dynamic Content & Session Handling
-    {
-        name: 'shadow_dom_extractor',
-        description: 'Extract content from Shadow DOM',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string', default: '*' },
-            },
-        },
-    },
-    {
-        name: 'form_auto_fill',
-        description: 'Automatically fill form fields',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                formData: { type: 'object' },
-                submitAfterFill: { type: 'boolean', default: false },
-                submitButtonSelector: { type: 'string' },
-            },
-        },
-    },
     {
         name: 'ajax_content_waiter',
         description: 'Wait for dynamic content to load',
@@ -793,45 +685,6 @@ export const TOOLS = [
         },
     },
     // Advanced Video & Media Download Tools
-    {
-        name: 'video_link_finder',
-        description: 'Find all video links on page',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                includeEmbedded: { type: 'boolean', default: true },
-            },
-        },
-    },
-    {
-        name: 'video_download_button',
-        description: 'Find and interact with video download buttons',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                action: { type: 'string', enum: ['find', 'click'], default: 'find' },
-                selector: { type: 'string' },
-            },
-        },
-    },
-    {
-        name: 'video_play_push_source',
-        description: 'Capture video sources when play button is clicked',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-    },
-    {
-        name: 'video_play_button_click',
-        description: 'Click video play button',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                selector: { type: 'string' },
-            },
-        },
-    },
     // Advanced Extraction Tools (Ad-Bypass & Obfuscation)
     {
         name: 'advanced_video_extraction',
@@ -953,15 +806,7 @@ export const TOOL_NAMES = {
     LINK_HARVESTER: 'link_harvester',
     MEDIA_EXTRACTOR: 'media_extractor',
     // DOM & HTML Extraction (Phase 1)
-    HTML_ELEMENTS_EXTRACTOR: 'html_elements_extractor',
-    TAGS_FINDER: 'tags_finder',
-    LINKS_FINDER: 'links_finder',
-    XPATH_LINKS: 'xpath_links',
-    SHADOW_DOM_EXTRACTOR: 'shadow_dom_extractor',
-    IFRAME_EXTRACTOR: 'iframe_extractor',
-    EMBED_PAGE_EXTRACTOR: 'embed_page_extractor',
     // Network Tools (Phase 1)
-    AJAX_EXTRACTOR: 'ajax_extractor',
     FETCH_XHR: 'fetch_xhr',
     NETWORK_RECORDER: 'network_recorder',
     API_FINDER: 'api_finder',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.15.6",
+  "version": "2.16.0",
   "description": "Universal AI IDE MCP Server - Auto-detects and supports all AI IDEs (Claude Desktop, Cursor, Windsurf, Cline, Zed, VSCode, Qoder AI, etc.) with Brave browser automation",
   "type": "module",
   "main": "dist/index.js",