brave-real-browser-mcp-server 2.26.3 → 2.27.1

package/README.md

@@ -11,10 +11,14 @@
 
 ```json
 {
+  {
   "mcpServers": {
     "brave-real-browser": {
       "command": "npx",
-      "args": ["brave-real-browser-mcp-server@latest"]
+      "args": ["brave-real-browser-mcp-server@latest"],
+      "env": {
+        "headless": "false"
+      }
     }
   }
 }

package/dist/handlers/advanced-tools.js

@@ -2876,369 +2876,3 @@ export async function handleStreamExtractor(page, args) {
             : 'No direct URLs found',
     };
 }
-/**
- * Advanced web crawler with Crawlee + brave-real-launcher integration
- * Features: URL queue, proxy rotation, rate limiting, data extraction
- */
-export async function handleWebCrawler(page, args) {
-    // Import Crawlee dynamically to avoid load-time errors if not installed
-    let PuppeteerCrawler;
-    let RequestQueue;
-    let Configuration;
-    try {
-        const crawlee = await import('crawlee');
-        PuppeteerCrawler = crawlee.PuppeteerCrawler;
-        RequestQueue = crawlee.RequestQueue;
-        Configuration = crawlee.Configuration;
-    }
-    catch (e) {
-        return {
-            success: false,
-            crawledPages: 0,
-            results: [],
-            errors: ['Crawlee not installed. Run: npm install crawlee'],
-            message: '❌ Crawlee package not found',
-        };
-    }
-    // Import brave-real-launcher for browser launch
-    let getBravePath;
-    let braveRealPuppeteerCore;
-    try {
-        const launcher = await import('brave-real-launcher');
-        getBravePath = launcher.getBravePath;
-    }
-    catch (e) {
-        // Fallback - will use default Chromium
-    }
-    // Import brave-real-puppeteer-core for stealth features
-    try {
-        braveRealPuppeteerCore = await import('brave-real-puppeteer-core');
-    }
-    catch (e) {
-        // Will use default puppeteer
-    }
-    const results = [];
-    const errors = [];
-    const visited = new Set();
-    // Configuration
-    const maxDepth = args.maxDepth ?? 3;
-    const maxPages = args.maxPages ?? 50;
-    const concurrency = args.concurrency ?? 3;
-    const rateLimit = args.rateLimit ?? 2;
-    const retryCount = args.retryCount ?? 3;
-    const timeout = args.timeout ?? 30000;
-    // URL filtering patterns
-    const includePattern = args.includePattern ? new RegExp(args.includePattern, 'i') : null;
-    const excludePattern = args.excludePattern ? new RegExp(args.excludePattern, 'i') : null;
-    // Proxy rotation
-    let proxyIndex = 0;
-    const getNextProxy = () => {
-        if (!args.proxyList || args.proxyList.length === 0)
-            return undefined;
-        const proxy = args.proxyList[proxyIndex % args.proxyList.length];
-        proxyIndex++;
-        return proxy;
-    };
-    // Rate limiting
-    let lastRequestTime = 0;
-    const rateLimitDelay = 1000 / rateLimit;
-    const enforceRateLimit = async () => {
-        const now = Date.now();
-        const elapsed = now - lastRequestTime;
-        if (elapsed < rateLimitDelay) {
-            await new Promise(r => setTimeout(r, rateLimitDelay - elapsed));
-        }
-        lastRequestTime = Date.now();
-    };
-    try {
-        // Configure Crawlee to use memory storage (no disk)
-        Configuration.getGlobalConfig().set('persistStorage', false);
-        // Create request queue with start URLs
-        const requestQueue = await RequestQueue.open();
-        for (const url of args.startUrls) {
-            await requestQueue.addRequest({
-                url,
-                userData: { depth: 0 },
-            });
-        }
-        // Get Brave executable path if available
-        let executablePath;
-        try {
-            if (getBravePath) {
-                executablePath = getBravePath();
-            }
-        }
-        catch (e) {
-            // Use default
-        }
-        // Create crawler based on mode
-        const crawler = new PuppeteerCrawler({
-            requestQueue,
-            maxConcurrency: concurrency,
-            maxRequestRetries: retryCount,
-            requestHandlerTimeoutSecs: timeout / 1000,
-            // Use brave-real-puppeteer-core with all stealth features
-            launchContext: {
-                // Use brave-real-puppeteer-core as custom launcher for 50+ stealth features
-                launcher: braveRealPuppeteerCore || undefined,
-                launchOptions: {
-                    headless: true,
-                    executablePath,
-                    args: [
-                        '--no-sandbox',
-                        '--disable-setuid-sandbox',
-                        '--disable-blink-features=AutomationControlled',
-                        '--disable-dev-shm-usage',
-                        '--disable-accelerated-2d-canvas',
-                        '--disable-gpu',
-                    ],
-                },
-            },
-            // Browser pool configuration
-            browserPoolOptions: {
-                maxOpenPagesPerBrowser: 1,
-            },
-            // Pre-navigation hook for rate limiting, popup blocking, and movie streaming optimizations
-            preNavigationHooks: [
-                async (crawlingContext) => {
-                    await enforceRateLimit();
-                    const pg = crawlingContext.page;
-                    // Set custom user agent if provided
-                    if (args.userAgent) {
-                        await pg.setUserAgent(args.userAgent);
-                    }
-                    // Set custom headers if provided
-                    if (args.headers) {
-                        await pg.setExtraHTTPHeaders(args.headers);
-                    }
-                    // Block popups and overlay ads (default: true for movie streaming)
-                    if (args.blockPopups !== false) {
-                        await pg.evaluateOnNewDocument(() => {
-                            // Block window.open popups
-                            window.open = () => null;
-                            // Block alert, confirm, prompt
-                            window.alert = () => { };
-                            window.confirm = () => true;
-                            window.prompt = () => null;
-                            // Block popup via createElement
-                            const origCreate = document.createElement.bind(document);
-                            document.createElement = (tag) => {
-                                if (tag.toLowerCase() === 'a' && arguments[1]?.target === '_blank') {
-                                    return origCreate('span');
-                                }
-                                return origCreate(tag);
-                            };
-                        });
-                    }
-                    // Block overlay ads and floating elements
-                    if (args.blockOverlayAds !== false) {
-                        await pg.evaluateOnNewDocument(() => {
-                            // Remove overlay ads after DOM load
-                            const removeOverlays = () => {
-                                const selectors = [
-                                    '[class*="popup"]', '[class*="modal"]', '[class*="overlay"]',
-                                    '[id*="popup"]', '[id*="modal"]', '[id*="overlay"]',
-                                    '[class*="ad-"]', '[class*="-ad"]', '[class*="advert"]',
-                                    '[class*="banner"]', '[class*="sticky"]', '[class*="float"]',
-                                    'div[style*="position: fixed"]', 'div[style*="z-index: 9"]',
-                                ];
-                                selectors.forEach(sel => {
-                                    document.querySelectorAll(sel).forEach(el => {
-                                        const style = window.getComputedStyle(el);
-                                        if (style.position === 'fixed' || style.zIndex > '1000') {
-                                            el.style.display = 'none';
-                                        }
-                                    });
-                                });
-                            };
-                            document.addEventListener('DOMContentLoaded', removeOverlays);
-                            setInterval(removeOverlays, 2000);
-                        });
-                    }
-                },
-            ],
-            // Main request handler
-            requestHandler: async ({ request, page: crawlerPage, enqueueLinks }) => {
-                const depth = request.userData.depth || 0;
-                const url = request.url;
-                // Skip if already visited or max pages reached
-                if (visited.has(url) || results.length >= maxPages) {
-                    return;
-                }
-                visited.add(url);
-                // URL filtering
-                if (includePattern && !includePattern.test(url))
-                    return;
-                if (excludePattern && excludePattern.test(url))
-                    return;
-                const result = {
-                    url,
-                    depth,
-                };
-                try {
-                    // Get page title
-                    result.title = await crawlerPage.title();
-                    // Extract data using selectors
-                    if (args.extractSelectors) {
-                        result.extractedData = {};
-                        for (const [key, selector] of Object.entries(args.extractSelectors)) {
-                            try {
-                                const elements = await crawlerPage.$$(selector);
-                                if (elements.length === 1) {
-                                    result.extractedData[key] = await crawlerPage.$eval(selector, (el) => el.textContent?.trim() || el.getAttribute('href') || el.getAttribute('src'));
-                                }
-                                else if (elements.length > 1) {
-                                    result.extractedData[key] = await crawlerPage.$$eval(selector, (els) => els.map(el => el.textContent?.trim() || el.getAttribute('href') || el.getAttribute('src')).filter(Boolean));
-                                }
-                            }
-                            catch (e) {
-                                // Selector not found
-                            }
-                        }
-                    }
-                    // Extract video links (JWPlayer, DooPlayer, iframes, ajax sources)
-                    if (args.extractVideoLinks !== false) {
-                        result.videoLinks = await crawlerPage.evaluate(() => {
-                            const videoLinks = [];
-                            const videoPatterns = /\.(m3u8|mp4|mkv|webm|avi|mov|flv|wmv|ts)(\?|$)/i;
-                            // 1. JWPlayer detection
-                            if (window.jwplayer) {
-                                try {
-                                    const players = document.querySelectorAll('.jwplayer, [id*="jwplayer"]');
-                                    players.forEach((_, idx) => {
-                                        try {
-                                            const player = window.jwplayer(idx);
-                                            if (player && player.getPlaylistItem) {
-                                                const item = player.getPlaylistItem();
-                                                if (item?.file) {
-                                                    videoLinks.push({ url: item.file, type: item.file.includes('.m3u8') ? 'm3u8' : 'mp4', source: 'jwplayer' });
-                                                }
-                                                if (item?.sources) {
-                                                    item.sources.forEach((s) => {
-                                                        if (s.file)
-                                                            videoLinks.push({ url: s.file, type: s.type || 'mp4', source: 'jwplayer' });
-                                                    });
-                                                }
-                                            }
-                                        }
-                                        catch { }
-                                    });
-                                }
-                                catch { }
-                            }
-                            // 2. DooPlayer detection (common in movie sites)
-                            if (window.dooPlayer || document.querySelector('[id*="doo"]')) {
-                                try {
-                                    const dooConfig = window.dooPlayer?.config || window.player_config;
-                                    if (dooConfig?.source) {
-                                        videoLinks.push({ url: dooConfig.source, type: 'm3u8', source: 'dooplayer' });
-                                    }
-                                }
-                                catch { }
-                            }
-                            // 3. Iframe video sources
-                            document.querySelectorAll('iframe').forEach(iframe => {
-                                const src = iframe.src || iframe.getAttribute('data-src') || '';
-                                if (src && (src.includes('embed') || src.includes('player') || src.includes('stream'))) {
-                                    videoLinks.push({ url: src, type: 'iframe', source: 'iframe' });
-                                }
-                            });
-                            // 4. Video tags
-                            document.querySelectorAll('video source, video').forEach(el => {
-                                const src = el.getAttribute('src') || el.src;
-                                if (src && videoPatterns.test(src)) {
-                                    const ext = src.match(videoPatterns)?.[1] || 'mp4';
-                                    videoLinks.push({ url: src, type: ext, source: 'video-tag' });
-                                }
-                            });
-                            // 5. Hidden links in scripts (ajax pattern)
-                            document.querySelectorAll('script:not([src])').forEach(script => {
-                                const content = script.textContent || '';
-                                // m3u8/mp4 in script
-                                const matches = content.match(/https?:\/\/[^\s"'<>]+\.(m3u8|mp4|mkv)[^\s"'<>]*/gi);
-                                if (matches) {
-                                    matches.forEach(url => {
-                                        const ext = url.match(videoPatterns)?.[1] || 'mp4';
-                                        videoLinks.push({ url, type: ext, source: 'ajax-script' });
-                                    });
-                                }
-                            });
-                            // 6. Data attributes with video URLs
-                            document.querySelectorAll('[data-file], [data-source], [data-video], [data-stream]').forEach(el => {
-                                const url = el.getAttribute('data-file') || el.getAttribute('data-source') ||
-                                    el.getAttribute('data-video') || el.getAttribute('data-stream');
-                                if (url && (videoPatterns.test(url) || url.includes('m3u8'))) {
-                                    videoLinks.push({ url, type: url.includes('m3u8') ? 'm3u8' : 'mp4', source: 'data-attr' });
-                                }
-                            });
-                            // Deduplicate
-                            return [...new Map(videoLinks.map(v => [v.url, v])).values()];
-                        });
-                    }
-                    // Follow links if enabled and depth allows
-                    if (args.followLinks !== false && depth < maxDepth && results.length < maxPages) {
-                        // Get all links
-                        const pageLinks = await crawlerPage.$$eval('a[href]', (anchors) => anchors.map(a => a.href).filter(href => href.startsWith('http')));
-                        result.links = pageLinks.slice(0, 100); // Limit stored links
-                        // Filter and enqueue links
-                        const linksToEnqueue = pageLinks.filter((link) => {
-                            if (visited.has(link))
-                                return false;
-                            if (includePattern && !includePattern.test(link))
-                                return false;
-                            if (excludePattern && excludePattern.test(link))
-                                return false;
-                            return true;
-                        });
-                        // Add filtered links using Crawlee's enqueueLinks
-                        for (const link of linksToEnqueue.slice(0, 50)) {
-                            try {
-                                await requestQueue.addRequest({
-                                    url: link,
-                                    userData: { depth: depth + 1 },
-                                });
-                            }
-                            catch (e) {
-                                // Link already in queue
-                            }
-                        }
-                    }
-                    // Download media if enabled
-                    if (args.downloadMedia && args.savePath) {
-                        const mediaUrls = await crawlerPage.$$eval('img[src], video source[src], a[href$=".pdf"], a[href$=".jpg"], a[href$=".png"]', (els) => els.map(el => el.getAttribute('src') || el.getAttribute('href')).filter(Boolean));
-                        result.extractedData = result.extractedData || {};
-                        result.extractedData.mediaUrls = mediaUrls;
-                    }
-                    results.push(result);
-                }
-                catch (error) {
-                    result.error = error instanceof Error ? error.message : String(error);
-                    errors.push(`${url}: ${result.error}`);
-                    results.push(result);
-                }
-            },
-            // Failed request handler
-            failedRequestHandler: async ({ request }, error) => {
-                errors.push(`Failed: ${request.url} - ${error.message}`);
-            },
-        });
-        // Run the crawler
-        await crawler.run();
-        return {
-            success: results.length > 0,
-            crawledPages: results.length,
-            results,
-            errors,
-            message: `🕷️ Crawled ${results.length} pages (depth: ${maxDepth}, errors: ${errors.length})`,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            crawledPages: results.length,
-            results,
-            errors: [...errors, error instanceof Error ? error.message : String(error)],
-            message: `❌ Crawler error: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-}

package/dist/handlers/interaction-handlers.js

@@ -126,6 +126,167 @@ export async function handleClick(args) {
         }, 'Failed to click element');
     });
 }
+export async function handleSelect(args) {
+    const progressNotifier = getProgressNotifier();
+    const progressToken = `select-${Date.now()}`;
+    const tracker = progressNotifier.createTracker(progressToken);
+    return await withWorkflowValidation('select', args, async () => {
+        return await withErrorHandling(async () => {
+            tracker.start(100, '📋 Starting select operation...');
+            const pageInstance = getPageInstance();
+            if (!pageInstance) {
+                tracker.fail('Browser not initialized');
+                throw new Error('Browser not initialized. Call browser_init first.');
+            }
+            const { selector, value, text, index, searchText, waitForOptions = true, clickToOpen = false, optionSelector } = args;
+            tracker.setProgress(10, `🔍 Finding select element: ${selector}`);
+            // Find the select/dropdown element
+            const elementResult = await selfHealingLocators.findElementWithFallbacks(pageInstance, selector);
+            if (!elementResult) {
+                tracker.fail('Select element not found');
+                throw new Error(`Select element not found: ${selector}`);
+            }
+            const { element, usedSelector } = elementResult;
+            tracker.setProgress(25, '✅ Select element found, detecting type...');
+            // Detect select type: native <select> or custom dropdown
+            const selectType = await pageInstance.evaluate((sel) => {
+                const el = document.querySelector(sel);
+                if (!el)
+                    return 'not-found';
+                if (el.tagName.toLowerCase() === 'select')
+                    return 'native';
+                if (el.getAttribute('role') === 'listbox' || el.getAttribute('role') === 'combobox')
+                    return 'aria';
+                if (el.classList.toString().match(/select|dropdown|combo/i))
+                    return 'custom';
+                return 'custom';
+            }, usedSelector);
+            tracker.setProgress(35, `🎯 Detected type: ${selectType}`);
+            // Handle native <select> elements
+            if (selectType === 'native') {
+                tracker.setProgress(50, '📋 Handling native <select> element...');
+                let selectResult = [];
+                if (value !== undefined) {
+                    selectResult = await pageInstance.select(usedSelector, value);
+                }
+                else if (text !== undefined) {
+                    // Select by visible text
+                    const optionValue = await pageInstance.evaluate((sel, targetText) => {
+                        const select = document.querySelector(sel);
+                        if (!select)
+                            return null;
+                        const option = Array.from(select.options).find(o => o.text.trim() === targetText.trim() ||
+                            o.text.toLowerCase().includes(targetText.toLowerCase()));
+                        return option?.value || null;
+                    }, usedSelector, text);
+                    if (optionValue) {
+                        selectResult = await pageInstance.select(usedSelector, optionValue);
+                    }
+                    else {
+                        throw new Error(`Option with text "${text}" not found`);
+                    }
+                }
+                else if (index !== undefined) {
+                    // Select by index
+                    const optionValue = await pageInstance.evaluate((sel, idx) => {
+                        const select = document.querySelector(sel);
+                        return select?.options[idx]?.value || null;
+                    }, usedSelector, index);
+                    if (optionValue) {
+                        selectResult = await pageInstance.select(usedSelector, optionValue);
+                    }
+                    else {
+                        throw new Error(`Option at index ${index} not found`);
+                    }
+                }
+                tracker.complete('🎉 Native select completed successfully');
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `✅ Selected value in native dropdown: ${selector}\nSelected: ${selectResult.join(', ') || 'success'}`,
+                        }],
+                };
+            }
+            // Handle custom dropdowns (React, Vue, etc.)
+            tracker.setProgress(50, '📋 Handling custom dropdown...');
+            // Click to open if needed
+            if (clickToOpen) {
+                tracker.setProgress(55, '🖱️ Opening dropdown...');
+                await element.click();
+                await sleep(300); // Wait for animation
+            }
+            // Wait for options to load (AJAX dropdowns)
+            if (waitForOptions) {
+                tracker.setProgress(60, '⏳ Waiting for options to load...');
+                await sleep(500);
+            }
+            // Handle searchable dropdowns
+            if (searchText) {
+                tracker.setProgress(65, `🔍 Searching: ${searchText}...`);
+                // Type search text into the input
+                await element.type(searchText, { delay: 50 });
+                await sleep(500); // Wait for search results
+            }
+            // Find and click the option
+            tracker.setProgress(75, '🎯 Selecting option...');
+            const finalOptionSelector = optionSelector ||
+                '[role="option"],' +
+                    ' [class*="option"]:not([class*="disabled"]),' +
+                    ' li[data-value],' +
+                    ' li:not(.disabled),' +
+                    ' .dropdown-item';
+            const targetValue = value || text;
+            const optionClicked = await pageInstance.evaluate((optSel, targetVal, targetIndex) => {
+                const options = Array.from(document.querySelectorAll(optSel));
+                if (targetVal !== undefined) {
+                    // Find by value or text
+                    const option = options.find(opt => opt.getAttribute('value') === targetVal ||
+                        opt.textContent?.trim() === targetVal ||
+                        opt.textContent?.toLowerCase().includes(targetVal.toLowerCase()));
+                    if (option) {
+                        option.click();
+                        return true;
+                    }
+                }
+                else if (targetIndex !== undefined && options[targetIndex]) {
+                    options[targetIndex].click();
+                    return true;
+                }
+                return false;
+            }, finalOptionSelector, targetValue, index);
+            if (!optionClicked) {
+                // Fallback: try clicking by text content
+                const textToFind = text || value || searchText;
+                if (textToFind) {
+                    const clicked = await pageInstance.evaluate((searchText) => {
+                        const allElements = Array.from(document.querySelectorAll('*'));
+                        for (const el of allElements) {
+                            if (el.textContent?.trim() === searchText ||
+                                el.textContent?.toLowerCase().includes(searchText.toLowerCase())) {
+                                const style = window.getComputedStyle(el);
+                                if (style.display !== 'none' && style.visibility !== 'hidden') {
+                                    el.click();
+                                    return true;
+                                }
+                            }
+                        }
+                        return false;
+                    }, textToFind);
+                    if (!clicked) {
+                        throw new Error(`Could not find or click option: ${textToFind}`);
+                    }
+                }
+            }
+            tracker.complete('🎉 Custom dropdown selection completed');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Selected option in custom dropdown: ${selector}\nType: ${selectType}\nTarget: ${value || text || `index:${index}`}`,
+                    }],
+            };
+        }, 'Failed to select option');
+    });
+}
 // Type handler with real-time progress
 export async function handleType(args) {
     const progressNotifier = getProgressNotifier();

package/dist/index.js

@@ -53,7 +53,7 @@ import { setupProcessCleanup } from './core-infrastructure.js';
 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, handleSelect, handleType, handleSolveCaptcha, handleRandomScroll } from './handlers/interaction-handlers.js';
 import { handleGetContent, handleFindSelector } from './handlers/content-handlers.js';
 import { handleSaveContentAsMarkdown } from './handlers/file-handlers.js';
 // Import advanced tools handlers
@@ -61,9 +61,7 @@ import { handleBreadcrumbNavigator, handleUrlRedirectTracer, handleSearchContent
 // Download tools
 handleFileDownloader, 
 // Enhanced streaming/download tools
-handleIframeHandler, handleStreamExtractor, 
-// Web crawler
-handleWebCrawler, } from './handlers/advanced-tools.js';
+handleIframeHandler, handleStreamExtractor, } from './handlers/advanced-tools.js';
 // State for video recording
 const recorderState = new Map();
 debug('All modules loaded successfully');
@@ -161,6 +159,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return await handleGetContent(args || {});
             case TOOL_NAMES.CLICK:
                 return await handleClick(args);
+            case TOOL_NAMES.DROPDOWN_SELECT:
+                return await handleSelect(args);
             case TOOL_NAMES.TYPE:
                 return await handleType(args);
             case TOOL_NAMES.WAIT:
@@ -256,11 +256,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (!page)
                     throw new Error('Browser not initialized. Call browser_init first.');
                 return { content: [{ type: 'text', text: JSON.stringify(await handleStreamExtractor(page, args)) }] };
-            // Web Crawler (Crawlee + brave-real-launcher)
-            case TOOL_NAMES.WEB_CRAWLER:
-                if (!page)
-                    throw new Error('Browser not initialized. Call browser_init first.');
-                return { content: [{ type: 'text', text: JSON.stringify(await handleWebCrawler(page, args)) }] };
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }

package/dist/tool-definitions.js

@@ -7,9 +7,103 @@ export const SERVER_INFO = {
 // MCP capabilities with LSP-compatible streaming support
 export const CAPABILITIES = {
     tools: {},
-    resources: {},
-    prompts: {},
+    resources: { subscribe: true, listChanged: true },
+    prompts: { listChanged: true },
 };
+// MCP Resources - Dynamic browser state resources
+export const RESOURCES = [
+    {
+        uri: 'browser://state',
+        name: 'Browser State',
+        description: 'Current browser instance state including page URL, title, and session info',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'browser://page/content',
+        name: 'Page Content',
+        description: 'Current page HTML content',
+        mimeType: 'text/html',
+    },
+    {
+        uri: 'browser://page/text',
+        name: 'Page Text',
+        description: 'Current page text content (no HTML)',
+        mimeType: 'text/plain',
+    },
+    {
+        uri: 'browser://cookies',
+        name: 'Browser Cookies',
+        description: 'All cookies in current browser session',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'browser://network/requests',
+        name: 'Network Requests',
+        description: 'Recent network requests captured during browsing',
+        mimeType: 'application/json',
+    },
+    {
+        uri: 'browser://console/logs',
+        name: 'Console Logs',
+        description: 'Browser console log messages',
+        mimeType: 'application/json',
+    },
+];
+// MCP Prompts - Reusable automation workflows
+export const PROMPTS = [
+    {
+        name: 'scrape_website',
+        description: 'Scrape content from a website with automatic navigation and extraction',
+        arguments: [
+            { name: 'url', description: 'URL to scrape', required: true },
+            { name: 'selector', description: 'CSS selector for target content', required: false },
+            { name: 'outputFormat', description: 'Output format (json, markdown, text)', required: false },
+        ],
+    },
+    {
+        name: 'extract_download_links',
+        description: 'Extract all download links from a page with quality and size info',
+        arguments: [
+            { name: 'url', description: 'Page URL to extract from', required: true },
+            { name: 'fileTypes', description: 'File types to extract (mp4, mkv, pdf, etc.)', required: false },
+        ],
+    },
+    {
+        name: 'monitor_page_changes',
+        description: 'Monitor a page for changes and notify when content updates',
+        arguments: [
+            { name: 'url', description: 'URL to monitor', required: true },
+            { name: 'selector', description: 'Element to watch for changes', required: true },
+            { name: 'interval', description: 'Check interval in seconds', required: false },
+        ],
+    },
+    {
+        name: 'automate_login',
+        description: 'Automate login to a website with credentials',
+        arguments: [
+            { name: 'url', description: 'Login page URL', required: true },
+            { name: 'usernameSelector', description: 'Username field selector', required: true },
+            { name: 'passwordSelector', description: 'Password field selector', required: true },
+            { name: 'submitSelector', description: 'Submit button selector', required: true },
+        ],
+    },
+    {
+        name: 'batch_screenshot',
+        description: 'Take screenshots of multiple URLs',
+        arguments: [
+            { name: 'urls', description: 'Comma-separated list of URLs', required: true },
+            { name: 'outputDir', description: 'Directory to save screenshots', required: true },
+        ],
+    },
+    {
+        name: 'extract_video_stream',
+        description: 'Extract video streaming URL from a page (m3u8, mp4)',
+        arguments: [
+            { name: 'url', description: 'Video page URL', required: true },
+            { name: 'quality', description: 'Preferred quality (highest, 1080p, 720p)', required: false },
+        ],
+    },
+];
 // Extended capabilities for streaming and auto-sync (for documentation/client info)
 export const EXTENDED_CAPABILITIES = {
     streaming: true,
@@ -140,6 +234,76 @@ export const TOOLS = [
             },
         },
     },
+    {
+        name: 'wait',
+        description: 'Wait for various conditions',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: {
+                    type: 'string',
+                    enum: ['selector', 'navigation', 'timeout'],
+                    description: 'Type of wait condition',
+                },
+                value: {
+                    type: 'string',
+                    description: 'Selector to wait for or timeout in ms',
+                },
+                timeout: {
+                    type: 'number',
+                    description: 'Maximum wait time in ms',
+                    default: 30000,
+                },
+            },
+            required: ['type', 'value'],
+        },
+    },
+    {
+        name: 'dropdown_select',
+        description: 'Intelligent dropdown/select element handler. Supports native HTML select, custom dropdowns, autocomplete, and searchable selects with smart fallback strategies.',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                selector: {
+                    type: 'string',
+                    description: 'CSS selector for the select/dropdown element',
+                },
+                value: {
+                    type: 'string',
+                    description: 'Value to select (option value attribute)',
+                },
+                text: {
+                    type: 'string',
+                    description: 'Visible text of option to select (alternative to value)',
+                },
+                index: {
+                    type: 'number',
+                    description: 'Index of option to select (0-based, alternative to value/text)',
+                },
+                searchText: {
+                    type: 'string',
+                    description: 'For searchable dropdowns: text to type before selecting',
+                },
+                waitForOptions: {
+                    type: 'boolean',
+                    description: 'Wait for dropdown options to load (useful for AJAX dropdowns)',
+                    default: true,
+                },
+                clickToOpen: {
+                    type: 'boolean',
+                    description: 'Click to open dropdown before selecting (for custom dropdowns)',
+                    default: false,
+                },
+                optionSelector: {
+                    type: 'string',
+                    description: 'CSS selector for dropdown options (for custom dropdowns)',
+                },
+            },
+            required: ['selector'],
+        },
+    },
     {
         name: 'click',
         description: 'Click on an element',
@@ -184,31 +348,6 @@ export const TOOLS = [
             required: ['selector', 'text'],
         },
     },
-    {
-        name: 'wait',
-        description: 'Wait for various conditions',
-        inputSchema: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                type: {
-                    type: 'string',
-                    enum: ['selector', 'navigation', 'timeout'],
-                    description: 'Type of wait condition',
-                },
-                value: {
-                    type: 'string',
-                    description: 'Selector to wait for or timeout in ms',
-                },
-                timeout: {
-                    type: 'number',
-                    description: 'Maximum wait time in ms',
-                    default: 30000,
-                },
-            },
-            required: ['type', 'value'],
-        },
-    },
     {
         name: 'browser_close',
         description: 'Close the browser instance',
@@ -622,127 +761,6 @@ export const TOOLS = [
             },
         },
     },
-    // ============================================================
-    // WEB CRAWLER TOOL (Movie Streaming Optimized)
-    // ============================================================
-    {
-        name: 'web_crawler',
-        description: 'Advanced web crawler optimized for movie downloading and streaming websites. Features: URL queue (breadth/depth-first), proxy rotation, auto-retry, rate limiting, JavaScript popup blocking, overlay ads blocking, and video link extraction. Uses brave-real-puppeteer-core with 50+ stealth features.',
-        inputSchema: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                startUrls: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Initial URLs to start crawling from (movie/streaming pages)'
-                },
-                maxDepth: {
-                    type: 'number',
-                    description: 'Maximum crawl depth (1 = only start URLs)',
-                    default: 3
-                },
-                maxPages: {
-                    type: 'number',
-                    description: 'Maximum pages to crawl',
-                    default: 50
-                },
-                concurrency: {
-                    type: 'number',
-                    description: 'Number of concurrent requests',
-                    default: 3
-                },
-                rateLimit: {
-                    type: 'number',
-                    description: 'Maximum requests per second',
-                    default: 2
-                },
-                crawlStrategy: {
-                    type: 'string',
-                    enum: ['breadth-first', 'depth-first'],
-                    description: 'URL queue strategy',
-                    default: 'breadth-first'
-                },
-                includePattern: {
-                    type: 'string',
-                    description: 'Regex pattern for URLs to include'
-                },
-                excludePattern: {
-                    type: 'string',
-                    description: 'Regex pattern for URLs to exclude'
-                },
-                extractSelectors: {
-                    type: 'object',
-                    description: 'CSS selectors for data extraction (e.g., {"title": "h1", "links": "a[href]"})'
-                },
-                followLinks: {
-                    type: 'boolean',
-                    description: 'Follow discovered links',
-                    default: true
-                },
-                // Movie streaming specific options
-                blockPopups: {
-                    type: 'boolean',
-                    description: 'Block JavaScript popup ads and window.open calls',
-                    default: true
-                },
-                blockOverlayAds: {
-                    type: 'boolean',
-                    description: 'Block overlay ads, modal popups, and floating elements',
-                    default: true
-                },
-                extractVideoLinks: {
-                    type: 'boolean',
-                    description: 'Auto-extract m3u8, mp4, mkv video links from pages',
-                    default: true
-                },
-                downloadMedia: {
-                    type: 'boolean',
-                    description: 'Download video/audio files',
-                    default: false
-                },
-                savePath: {
-                    type: 'string',
-                    description: 'Path to save downloaded files'
-                },
-                proxyList: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Proxy URLs for rotation (format: protocol://host:port)'
-                },
-                retryCount: {
-                    type: 'number',
-                    description: 'Number of retries for failed requests',
-                    default: 3
-                },
-                retryDelayMs: {
-                    type: 'number',
-                    description: 'Delay between retries in ms (exponential backoff)',
-                    default: 1000
-                },
-                timeout: {
-                    type: 'number',
-                    description: 'Request timeout in ms',
-                    default: 30000
-                },
-                mode: {
-                    type: 'string',
-                    enum: ['browser', 'http'],
-                    description: 'Crawl mode (browser = Puppeteer, http = fast HTTP)',
-                    default: 'browser'
-                },
-                userAgent: {
-                    type: 'string',
-                    description: 'Custom User-Agent string'
-                },
-                headers: {
-                    type: 'object',
-                    description: 'Custom headers for all requests'
-                },
-            },
-            required: ['startUrls'],
-        },
-    },
 ];
 // Tool name constants for type safety
 export const TOOL_NAMES = {
@@ -750,6 +768,7 @@ export const TOOL_NAMES = {
     NAVIGATE: 'navigate',
     GET_CONTENT: 'get_content',
     CLICK: 'click',
+    DROPDOWN_SELECT: 'dropdown_select',
     TYPE: 'type',
     WAIT: 'wait',
     BROWSER_CLOSE: 'browser_close',
@@ -780,8 +799,6 @@ export const TOOL_NAMES = {
     // Enhanced tools
     IFRAME_HANDLER: 'iframe_handler',
     STREAM_EXTRACTOR: 'stream_extractor',
-    // Crawler tool
-    WEB_CRAWLER: 'web_crawler',
 };
 // Tool categories for organization
 export const TOOL_CATEGORIES = {

package/dist/unified-server.js

@@ -17,10 +17,10 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ListPromptsRequestSchema, InitializeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, InitializeRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { randomUUID } from 'crypto';
 // Import core modules
-import { TOOLS, SERVER_INFO, CAPABILITIES, TOOL_NAMES } from './tool-definitions.js';
+import { TOOLS, SERVER_INFO, CAPABILITIES, TOOL_NAMES, RESOURCES, PROMPTS } from './tool-definitions.js';
 import { getSharedEventBus } from './shared/event-bus.js';
 import { getProgressNotifier } from './transport/progress-notifier.js';
 import { getSessionManager } from './transport/session-manager.js';
@@ -69,8 +69,109 @@ mcpServer.setRequestHandler(InitializeRequestSchema, async (request) => {
     };
 });
 mcpServer.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
-mcpServer.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: [] }));
-mcpServer.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: [] }));
+mcpServer.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: RESOURCES }));
+mcpServer.setRequestHandler(ListPromptsRequestSchema, async () => ({ prompts: PROMPTS }));
+// Read Resource Handler
+mcpServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    const page = getPageInstance();
+    debug(`ReadResource: ${uri}`);
+    try {
+        switch (uri) {
+            case 'browser://state': {
+                const state = page ? {
+                    url: page.url(),
+                    title: await page.title(),
+                    isConnected: page.browser()?.connected ?? false,
+                    viewport: page.viewport(),
+                } : { status: 'Browser not initialized' };
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(state, null, 2) }] };
+            }
+            case 'browser://page/content': {
+                if (!page)
+                    throw new Error('Browser not initialized');
+                const html = await page.content();
+                return { contents: [{ uri, mimeType: 'text/html', text: html }] };
+            }
+            case 'browser://page/text': {
+                if (!page)
+                    throw new Error('Browser not initialized');
+                const text = await page.evaluate(() => document.body.innerText);
+                return { contents: [{ uri, mimeType: 'text/plain', text }] };
+            }
+            case 'browser://cookies': {
+                if (!page)
+                    throw new Error('Browser not initialized');
+                const cookies = await page.cookies();
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(cookies, null, 2) }] };
+            }
+            case 'browser://network/requests': {
+                // Return cached network requests from event bus
+                const history = eventBus.getHistory().filter(e => e.type.includes('network'));
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(history.slice(-50), null, 2) }] };
+            }
+            case 'browser://console/logs': {
+                const logs = eventBus.getHistory().filter(e => e.type.includes('console'));
+                return { contents: [{ uri, mimeType: 'application/json', text: JSON.stringify(logs.slice(-100), null, 2) }] };
+            }
+            default:
+                throw new Error(`Unknown resource: ${uri}`);
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { contents: [{ uri, mimeType: 'text/plain', text: `Error: ${errorMessage}` }] };
+    }
+});
+// Get Prompt Handler
+mcpServer.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    debug(`GetPrompt: ${name}`);
+    const prompt = PROMPTS.find(p => p.name === name);
+    if (!prompt) {
+        throw new Error(`Unknown prompt: ${name}`);
+    }
+    // Generate prompt messages based on template
+    let messages = [];
+    switch (name) {
+        case 'scrape_website':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Scrape the website at ${args?.url || '[URL]'}. ${args?.selector ? `Focus on elements matching: ${args.selector}` : 'Extract main content.'}` } },
+            ];
+            break;
+        case 'extract_download_links':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Extract all download links from ${args?.url || '[URL]'}. ${args?.fileTypes ? `Filter for: ${args.fileTypes}` : 'Include all file types.'}` } },
+            ];
+            break;
+        case 'monitor_page_changes':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Monitor ${args?.url || '[URL]'} for changes in element: ${args?.selector || '[SELECTOR]'}. Check every ${args?.interval || 60} seconds.` } },
+            ];
+            break;
+        case 'automate_login':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Automate login to ${args?.url || '[URL]'}. Use ${args?.usernameSelector || '#username'} for username, ${args?.passwordSelector || '#password'} for password, and ${args?.submitSelector || 'button[type=submit]'} to submit.` } },
+            ];
+            break;
+        case 'batch_screenshot':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Take screenshots of: ${args?.urls || '[URLs]'}. Save to: ${args?.outputDir || './screenshots'}` } },
+            ];
+            break;
+        case 'extract_video_stream':
+            messages = [
+                { role: 'user', content: { type: 'text', text: `Extract video streaming URL from ${args?.url || '[URL]'}. Prefer quality: ${args?.quality || 'highest'}` } },
+            ];
+            break;
+        default:
+            messages = [{ role: 'user', content: { type: 'text', text: `Execute prompt: ${name}` } }];
+    }
+    return {
+        description: prompt.description,
+        messages,
+    };
+});
 mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     debug(`Tool call: ${name}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.26.3",
+  "version": "2.27.1",
   "description": "🦁 MCP server for Brave Real Browser - NPM Workspaces Monorepo with anti-detection features, SSE streaming, and LSP compatibility",
   "type": "module",
   "main": "dist/index.js",
@@ -50,8 +50,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",
     "@types/turndown": "latest",
-    "brave-real-browser": "^2.7.2",
-    "crawlee": "^3.15.3",
+    "brave-real-browser": "^2.8.1",
     "puppeteer-core": "^24.35.0",
     "turndown": "latest",
     "vscode-languageserver": "^9.0.1",