brave-real-browser-mcp-server 2.27.25 → 2.27.26

package/dist/handlers/advanced-tools.js

@@ -195,70 +195,526 @@ export async function handleMultiLayerRedirectTrace(page, args) {
     };
 }
 /**
- * Search text or regex patterns in page content
+ * 🔥 ULTRA-POWERFUL Regex Engine (like regex101.com)
+ * Features: Named capture groups, all regex flags, match highlighting,
+ * detailed match info, replace mode, timeout protection
  */
-export async function handleSearchContent(page, args) {
-    // Progress tracking
+export async function handleSearchRegex(page, args) {
     const progressNotifier = getProgressNotifier();
-    const tracker = progressNotifier.createTracker(`search-${Date.now()}`);
-    tracker.start(100, `🔎 Searching for: "${args.pattern}"...`);
-    // Wait for body to be available
+    const tracker = progressNotifier.createTracker(`search-regex-${Date.now()}`);
+    tracker.start(100, `🔎 Regex Search: "${args.pattern}"`);
+    // Build regex flags
+    const flags = args.flags || {};
+    let flagString = '';
+    if (flags.global !== false)
+        flagString += 'g';
+    if (flags.ignoreCase)
+        flagString += 'i';
+    if (flags.multiline)
+        flagString += 'm';
+    if (flags.dotAll)
+        flagString += 's';
+    if (flags.unicode)
+        flagString += 'u';
+    if (flags.sticky)
+        flagString += 'y';
+    // Validate regex
+    let regex;
+    let patternInfo = { flags: flagString, isValid: true, errorMessage: undefined };
     try {
-        tracker.setProgress(10, '⏳ Waiting for page content...');
-        await page.waitForSelector('body', { timeout: 5000 });
+        regex = new RegExp(args.pattern, flagString);
     }
-    catch {
-        // Continue anyway
+    catch (e) {
+        tracker.fail(`Invalid regex: ${e.message}`);
+        return {
+            found: false,
+            matches: [],
+            count: 0,
+            patternInfo: { flags: flagString, isValid: false, errorMessage: e.message },
+        };
     }
-    tracker.setProgress(30, '📄 Extracting page content...');
+    tracker.setProgress(20, '📄 Extracting content...');
+    // Get content based on sourceType
     let content = '';
-    if (args.selector) {
+    if (args.testString) {
+        content = args.testString;
+    }
+    else {
+        const sourceType = args.sourceType || 'text';
         try {
-            content = await page.$eval(args.selector, (el) => el.textContent || '');
+            await page.waitForSelector('body', { timeout: 5000 });
         }
-        catch {
-            content = '';
+        catch { /* continue */ }
+        if (args.selector) {
+            try {
+                content = await page.$eval(args.selector, (el, type) => {
+                    if (type === 'html')
+                        return el.innerHTML;
+                    if (type === 'text')
+                        return el.textContent || '';
+                    return el.outerHTML;
+                }, sourceType);
+            }
+            catch {
+                content = '';
+            }
+        }
+        else {
+            content = await page.evaluate((type) => {
+                if (type === 'html')
+                    return document.documentElement.innerHTML;
+                if (type === 'scripts') {
+                    return Array.from(document.scripts).map(s => s.textContent).join('\n');
+                }
+                if (type === 'styles') {
+                    return Array.from(document.styleSheets).map(s => {
+                        try {
+                            return Array.from(s.cssRules).map(r => r.cssText).join('\n');
+                        }
+                        catch {
+                            return '';
+                        }
+                    }).join('\n');
+                }
+                if (type === 'attributes') {
+                    return Array.from(document.querySelectorAll('*')).map(el => Array.from(el.attributes).map(a => `${a.name}="${a.value}"`).join(' ')).join('\n');
+                }
+                if (type === 'all') {
+                    return document.documentElement.outerHTML;
+                }
+                return document.body?.textContent || '';
+            }, sourceType);
         }
     }
-    else {
-        content = await page.evaluate(() => document.body?.textContent || document.documentElement?.textContent || '');
-    }
-    const matches = [];
-    if (!content || content.length === 0) {
+    if (!content) {
         tracker.fail('No content to search');
-        return { found: false, matches: [], count: 0 };
-    }
-    tracker.setProgress(50, '🔍 Running pattern match...');
-    let regex;
-    if (args.isRegex) {
-        regex = new RegExp(args.pattern, args.caseSensitive ? 'g' : 'gi');
-    }
-    else {
-        const escaped = args.pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        regex = new RegExp(escaped, args.caseSensitive ? 'g' : 'gi');
+        return { found: false, matches: [], count: 0, patternInfo };
     }
+    tracker.setProgress(50, '🔍 Running regex match...');
+    const matches = [];
+    const maxMatches = args.maxMatches || 100;
+    const contextChars = args.contextChars || 50;
+    const timeout = args.timeout || 5000;
+    const startTime = Date.now();
     let match;
     while ((match = regex.exec(content)) !== null) {
-        const start = Math.max(0, match.index - 50);
-        const end = Math.min(content.length, match.index + match[0].length + 50);
-        matches.push({
+        // Timeout protection
+        if (Date.now() - startTime > timeout) {
+            tracker.setProgress(80, '⚠️ Timeout reached, returning partial results');
+            break;
+        }
+        const start = Math.max(0, match.index - contextChars);
+        const end = Math.min(content.length, match.index + match[0].length + contextChars);
+        let context = content.substring(start, end);
+        // Highlight if requested
+        if (args.highlightMatches) {
+            const matchStart = match.index - start;
+            const matchEnd = matchStart + match[0].length;
+            context = context.substring(0, matchStart) + '<<MATCH>>' + context.substring(matchStart, matchEnd) + '<</MATCH>>' + context.substring(matchEnd);
+        }
+        const matchResult = {
             text: match[0],
-            context: content.substring(start, end),
-        });
-        if (matches.length >= 100)
-            break; // Limit matches
+            context,
+            index: match.index,
+            length: match[0].length,
+        };
+        // Extract groups if requested
+        if (args.extractGroups !== false) {
+            if (match.groups) {
+                matchResult.groups = match.groups;
+            }
+            if (match.length > 1) {
+                matchResult.numberedGroups = match.slice(1);
+            }
+        }
+        matches.push(matchResult);
+        if (matches.length >= maxMatches)
+            break;
+        // Prevent infinite loop for zero-length matches
+        if (match[0].length === 0) {
+            regex.lastIndex++;
+        }
+    }
+    // Replace mode
+    let replaced;
+    if (args.replaceWith !== undefined) {
+        tracker.setProgress(90, '🔄 Applying replacement...');
+        replaced = content.replace(regex, args.replaceWith);
     }
     tracker.complete(`🎉 Found ${matches.length} matches`);
     return {
         found: matches.length > 0,
         matches,
         count: matches.length,
+        replaced,
+        patternInfo,
     };
 }
 /**
- * Find elements using XPath or Advanced CSS
+ * 🚀 INTELLIGENT Content Search Engine
+ * Features: Fuzzy matching, proximity search, advanced operators,
+ * relevance scoring, snippet extraction with highlighting
+ */
+export async function handleWebSearch(page, args) {
+    const progressNotifier = getProgressNotifier();
+    const tracker = progressNotifier.createTracker(`web-search-${Date.now()}`);
+    tracker.start(100, `🚀 Intelligent Search: "${args.query}"`);
+    try {
+        await page.waitForSelector('body', { timeout: 5000 });
+    }
+    catch { /* continue */ }
+    tracker.setProgress(20, '📄 Extracting content...');
+    // Get content based on searchIn type
+    const searchIn = args.searchIn || 'text';
+    let content = '';
+    let elements = [];
+    content = await page.evaluate((opts) => {
+        const { searchIn, selector } = opts;
+        const root = selector ? document.querySelector(selector) : document.body;
+        if (!root)
+            return '';
+        switch (searchIn) {
+            case 'html':
+                return root.innerHTML;
+            case 'links':
+                return Array.from(root.querySelectorAll('a')).map((a) => `${a.textContent?.trim()} [${a.getAttribute('href')}]`).join('\n');
+            case 'images':
+                return Array.from(root.querySelectorAll('img')).map((img) => `${img.alt} [${img.src}]`).join('\n');
+            case 'videos':
+                return Array.from(root.querySelectorAll('video, iframe[src*="youtube"], iframe[src*="vimeo"]')).map((v) => v.getAttribute('src') || v.querySelector?.('source')?.getAttribute('src') || '').join('\n');
+            case 'scripts':
+                return Array.from(document.scripts).map((s) => s.textContent).join('\n');
+            case 'json':
+                return Array.from(document.querySelectorAll('script[type="application/json"], script[type="application/ld+json"]'))
+                    .map((s) => s.textContent).join('\n');
+            case 'schema':
+                return Array.from(document.querySelectorAll('script[type="application/ld+json"]'))
+                    .map((s) => s.textContent).join('\n');
+            case 'meta':
+                return Array.from(document.querySelectorAll('meta')).map((m) => `${m.name || m.getAttribute('property')}: ${m.content}`).join('\n');
+            case 'all':
+                return root.outerHTML;
+            default:
+                return root.textContent || '';
+        }
+    }, { searchIn, selector: args.selector });
+    if (!content) {
+        tracker.fail('No content to search');
+        return {
+            found: false,
+            results: [],
+            count: 0,
+            totalOccurrences: 0,
+            searchInfo: { query: args.query, searchIn, matchMode: 'none' },
+        };
+    }
+    tracker.setProgress(40, '🔍 Processing search query...');
+    const matchMode = args.matchMode || {};
+    const operators = args.operators || {};
+    const filters = args.filters || {};
+    const maxResults = args.maxResults || 50;
+    const snippetLength = args.snippetLength || 150;
+    const highlightTag = args.highlightTag || '**';
+    // Parse query for operators
+    let searchTerms = [];
+    let phrases = [];
+    // Extract phrases (quoted strings)
+    const phraseMatches = args.query.match(/"([^"]+)"/g);
+    if (phraseMatches) {
+        phrases = phraseMatches.map(p => p.replace(/"/g, ''));
+    }
+    // Get remaining terms
+    const remainingQuery = args.query.replace(/"[^"]+"/g, '').trim();
+    if (remainingQuery) {
+        // Parse AND/OR/NOT operators
+        const parts = remainingQuery.split(/\s+(AND|OR|NOT)\s+/i);
+        searchTerms = parts.filter(p => !['AND', 'OR', 'NOT'].includes(p.toUpperCase()));
+    }
+    // Add explicit operator terms
+    if (operators.must)
+        searchTerms.push(...operators.must);
+    if (operators.should)
+        searchTerms.push(...operators.should);
+    if (operators.phrase)
+        phrases.push(operators.phrase);
+    tracker.setProgress(60, '🎯 Matching content...');
+    const results = [];
+    // Levenshtein distance for fuzzy matching
+    const levenshtein = (a, b) => {
+        const matrix = Array(b.length + 1).fill(null).map(() => Array(a.length + 1).fill(null));
+        for (let i = 0; i <= a.length; i++)
+            matrix[0][i] = i;
+        for (let j = 0; j <= b.length; j++)
+            matrix[j][0] = j;
+        for (let j = 1; j <= b.length; j++) {
+            for (let i = 1; i <= a.length; i++) {
+                const indicator = a[i - 1] === b[j - 1] ? 0 : 1;
+                matrix[j][i] = Math.min(matrix[j][i - 1] + 1, matrix[j - 1][i] + 1, matrix[j - 1][i - 1] + indicator);
+            }
+        }
+        return matrix[b.length][a.length];
+    };
+    const fuzzyMatch = (text, term, threshold) => {
+        const distance = levenshtein(text.toLowerCase(), term.toLowerCase());
+        const maxLen = Math.max(text.length, term.length);
+        return (1 - distance / maxLen) >= threshold;
+    };
+    // Split content into searchable chunks
+    const sentences = content.split(/[.!?\n]+/).filter(s => s.trim().length > 10);
+    let totalOccurrences = 0;
+    for (let i = 0; i < sentences.length && results.length < maxResults; i++) {
+        const sentence = sentences[i].trim();
+        let score = 0;
+        let matched = false;
+        // Check phrases first
+        for (const phrase of phrases) {
+            const phraseRegex = new RegExp(phrase.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), matchMode.caseSensitive ? 'g' : 'gi');
+            if (phraseRegex.test(sentence)) {
+                score += 10;
+                matched = true;
+                totalOccurrences += (sentence.match(phraseRegex) || []).length;
+            }
+        }
+        // Check terms
+        for (const term of searchTerms) {
+            if (matchMode.fuzzy) {
+                const words = sentence.split(/\s+/);
+                for (const word of words) {
+                    if (fuzzyMatch(word, term, matchMode.fuzzyThreshold || 0.8)) {
+                        score += 5;
+                        matched = true;
+                        totalOccurrences++;
+                    }
+                }
+            }
+            else {
+                const termRegex = matchMode.wholeWord
+                    ? new RegExp(`\\b${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, matchMode.caseSensitive ? 'g' : 'gi')
+                    : new RegExp(term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), matchMode.caseSensitive ? 'g' : 'gi');
+                const termMatches = sentence.match(termRegex);
+                if (termMatches) {
+                    score += termMatches.length * 3;
+                    matched = true;
+                    totalOccurrences += termMatches.length;
+                }
+            }
+        }
+        // Check mustNot terms
+        if (operators.mustNot) {
+            for (const notTerm of operators.mustNot) {
+                if (sentence.toLowerCase().includes(notTerm.toLowerCase())) {
+                    matched = false;
+                    score = 0;
+                    break;
+                }
+            }
+        }
+        // Proximity search
+        if (matched && operators.proximity?.words && operators.proximity.words.length >= 2) {
+            const words = sentence.toLowerCase().split(/\s+/);
+            const positions = [];
+            for (const pw of operators.proximity.words) {
+                const idx = words.findIndex(w => w.includes(pw.toLowerCase()));
+                if (idx !== -1)
+                    positions.push(idx);
+            }
+            if (positions.length >= 2) {
+                const distance = Math.abs(positions[0] - positions[1]);
+                if (distance <= (operators.proximity.distance || 5)) {
+                    score += 15;
+                }
+            }
+        }
+        // Apply filters
+        if (matched && filters.minLength && sentence.length < filters.minLength)
+            matched = false;
+        if (matched && filters.maxLength && sentence.length > filters.maxLength)
+            matched = false;
+        if (matched && filters.containsPattern) {
+            const containsRegex = new RegExp(filters.containsPattern, 'i');
+            if (!containsRegex.test(sentence))
+                matched = false;
+        }
+        if (matched && filters.excludePattern) {
+            const excludeRegex = new RegExp(filters.excludePattern, 'i');
+            if (excludeRegex.test(sentence))
+                matched = false;
+        }
+        if (matched && score > 0) {
+            // Create highlighted snippet
+            let snippet = sentence.substring(0, snippetLength);
+            for (const term of [...searchTerms, ...phrases]) {
+                const highlightRegex = new RegExp(`(${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')})`, 'gi');
+                snippet = snippet.replace(highlightRegex, `${highlightTag}$1${highlightTag}`);
+            }
+            results.push({
+                text: sentence.substring(0, 100),
+                snippet,
+                score,
+                position: i,
+            });
+        }
+    }
+    // Sort by relevance/position/frequency
+    const sortBy = args.sortBy || 'relevance';
+    if (sortBy === 'relevance') {
+        results.sort((a, b) => b.score - a.score);
+    }
+    else if (sortBy === 'position') {
+        results.sort((a, b) => a.position - b.position);
+    }
+    tracker.complete(`🎉 Found ${results.length} results (${totalOccurrences} total occurrences)`);
+    return {
+        found: results.length > 0,
+        results,
+        count: results.length,
+        totalOccurrences,
+        searchInfo: {
+            query: args.query,
+            searchIn,
+            matchMode: matchMode.fuzzy ? 'fuzzy' : matchMode.wholeWord ? 'wholeWord' : 'normal',
+        },
+    };
+}
+/**
+ * Ultra-powerful element finder and batch scraper
+ * Find elements using XPath, CSS, text, attributes with advanced filters
+ * Supports batch scraping mode (merged from batch_element_scraper)
  */
 export async function handleFindElementAdvanced(page, args) {
+    // Progress tracking
+    const progressNotifier = getProgressNotifier();
+    const tracker = progressNotifier.createTracker(`find-element-${Date.now()}`);
+    const limit = args.limit || 100;
+    const selectorToUse = args.selector || args.cssSelector;
+    // ============================================================
+    // BATCH MODE (merged from batch_element_scraper)
+    // ============================================================
+    if (args.batchMode && selectorToUse) {
+        tracker.start(100, '📋 Starting batch element extraction...');
+        const attributes = args.extractAttributes || ['textContent', 'href', 'src'];
+        tracker.setProgress(20, `🔍 Finding elements with selector: ${selectorToUse}`);
+        const items = await page.evaluate((opts) => {
+            const elements = Array.from(document.querySelectorAll(opts.selector)).slice(0, opts.limit);
+            return elements.map((el, idx) => {
+                const item = {};
+                // Extract requested attributes
+                for (const attr of opts.attributes) {
+                    if (attr === 'textContent') {
+                        item.text = el.textContent?.trim()?.substring(0, 500) || '';
+                    }
+                    else if (attr === 'innerHTML') {
+                        item.html = el.innerHTML?.substring(0, 1000) || '';
+                    }
+                    else {
+                        item[attr] = el.getAttribute(attr) || '';
+                    }
+                }
+                // Include innerHTML if requested
+                if (opts.includeInnerHTML) {
+                    item.html = el.innerHTML?.substring(0, 1000) || '';
+                }
+                // Always include tag
+                item.tag = el.tagName.toLowerCase();
+                // Include position if requested
+                if (opts.includePosition) {
+                    const rect = el.getBoundingClientRect();
+                    item.position = {
+                        x: Math.round(rect.x),
+                        y: Math.round(rect.y),
+                        width: Math.round(rect.width),
+                        height: Math.round(rect.height)
+                    };
+                }
+                // Generate unique selector
+                const tagName = el.tagName.toLowerCase();
+                const id = el.id;
+                const className = typeof el.className === 'string' ? el.className.split(' ')[0] : '';
+                item.selector = id ? `#${id}` : className ? `${tagName}.${className}` : `${opts.selector}:nth-of-type(${idx + 1})`;
+                // Apply advanced filters if specified
+                if (opts.filter) {
+                    const rect = el.getBoundingClientRect();
+                    const style = window.getComputedStyle(el);
+                    if (opts.filter.visible !== undefined) {
+                        const isVisible = rect.width > 0 && rect.height > 0 && style.display !== 'none' && style.visibility !== 'hidden';
+                        if (opts.filter.visible !== isVisible)
+                            return null;
+                    }
+                    if (opts.filter.enabled !== undefined) {
+                        const isEnabled = !el.disabled;
+                        if (opts.filter.enabled !== isEnabled)
+                            return null;
+                    }
+                    if (opts.filter.minWidth && rect.width < opts.filter.minWidth)
+                        return null;
+                    if (opts.filter.minHeight && rect.height < opts.filter.minHeight)
+                        return null;
+                    if (opts.filter.hasChildren !== undefined) {
+                        const hasKids = el.children.length > 0;
+                        if (opts.filter.hasChildren !== hasKids)
+                            return null;
+                    }
+                    if (opts.filter.containsClass && !el.classList.contains(opts.filter.containsClass))
+                        return null;
+                    if (opts.filter.matchPattern) {
+                        const regex = new RegExp(opts.filter.matchPattern);
+                        if (!regex.test(el.textContent || ''))
+                            return null;
+                    }
+                }
+                return item;
+            }).filter((item) => item !== null);
+        }, {
+            selector: selectorToUse,
+            limit,
+            attributes,
+            includeInnerHTML: args.includeInnerHTML,
+            includePosition: args.includePosition,
+            filter: args.filter
+        });
+        tracker.setProgress(80, `✅ Found ${items.length} elements`);
+        // Format output based on returnType
+        const returnType = args.returnType || 'elements';
+        if (returnType === 'selectors') {
+            tracker.complete(`🎉 Extracted ${items.length} selectors`);
+            return {
+                found: items.length > 0,
+                elements: items.map((item) => ({
+                    selector: item.selector,
+                    text: '',
+                    tag: item.tag,
+                })),
+                count: items.length,
+            };
+        }
+        if (returnType === 'data') {
+            tracker.complete(`🎉 Extracted data from ${items.length} elements`);
+            return {
+                found: items.length > 0,
+                elements: [],
+                count: items.length,
+                batchData: items,
+            };
+        }
+        // Default: elements
+        tracker.complete(`🎉 Found and extracted ${items.length} elements`);
+        return {
+            found: items.length > 0,
+            elements: items.map((item) => ({
+                selector: item.selector,
+                text: item.text || '',
+                tag: item.tag,
+                attributes: item,
+                position: item.position,
+            })),
+            count: items.length,
+            batchData: items,
+        };
+    }
+    // ============================================================
+    // STANDARD FIND MODE
+    // ============================================================
+    tracker.start(100, '🔍 Finding elements...');
     const elements = [];
     // Wait for body to be available
     try {
@@ -267,8 +723,9 @@ export async function handleFindElementAdvanced(page, args) {
     catch {
         // Continue anyway
     }
+    tracker.setProgress(20, '📄 Searching with provided criteria...');
+    // XPath search
     if (args.xpath) {
-        // Use document.evaluate for XPath (compatible with all Puppeteer versions)
         const xpathResults = await page.evaluate((xpath) => {
             const results = [];
             try {
@@ -277,11 +734,13 @@ export async function handleFindElementAdvanced(page, args) {
                 let count = 0;
                 while (node && count < 50) {
                     if (node instanceof Element) {
+                        const rect = node.getBoundingClientRect();
                         results.push({
                             text: node.textContent?.trim()?.substring(0, 100) || '',
                             tag: node.tagName.toLowerCase(),
                             id: node.id || '',
                             className: typeof node.className === 'string' ? node.className : '',
+                            position: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
                         });
                     }
                     node = iterator.iterateNext();
@@ -297,47 +756,65 @@ export async function handleFindElementAdvanced(page, args) {
             selector: e.id ? `#${e.id}` : e.className ? `.${e.className.split(' ')[0]}` : e.tag,
             text: e.text,
             tag: e.tag,
+            position: args.includePosition ? e.position : undefined,
         })));
     }
-    if (args.cssSelector) {
-        const cssElements = await page.$$(args.cssSelector);
-        for (const el of cssElements) {
-            const data = await page.evaluate((e) => ({
-                text: e.textContent?.trim()?.substring(0, 100) || '',
-                tag: e.tagName.toLowerCase(),
-                id: e.id,
-                className: e.className,
-            }), el);
+    // CSS selector search
+    if (selectorToUse) {
+        const cssElements = await page.$$(selectorToUse);
+        for (const el of cssElements.slice(0, limit)) {
+            const data = await page.evaluate((e, includePos) => {
+                const rect = e.getBoundingClientRect();
+                return {
+                    text: e.textContent?.trim()?.substring(0, 100) || '',
+                    tag: e.tagName.toLowerCase(),
+                    id: e.id,
+                    className: e.className,
+                    position: includePos ? { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) } : undefined,
+                };
+            }, el, args.includePosition);
             elements.push({
-                selector: args.cssSelector,
+                selector: selectorToUse,
                 text: data.text,
                 tag: data.tag,
+                position: data.position,
             });
         }
     }
-    if (args.contains) {
-        const containsElements = await page.evaluate((text) => {
+    // Text content search
+    if (args.contains || args.text) {
+        const searchText = args.contains || args.text || '';
+        const isExact = args.exact || false;
+        const containsElements = await page.evaluate((opts) => {
             const results = [];
-            const allElements = document.querySelectorAll('*');
-            for (let i = 0; i < allElements.length && results.length < 10; i++) {
+            const allElements = document.querySelectorAll(opts.elementType || '*');
+            for (let i = 0; i < allElements.length && results.length < opts.limit; i++) {
                 const el = allElements[i];
-                if (el.textContent?.includes(text)) {
+                const textContent = el.textContent || '';
+                const matches = opts.exact
+                    ? textContent.trim() === opts.text
+                    : textContent.includes(opts.text);
+                if (matches) {
+                    const rect = el.getBoundingClientRect();
                     results.push({
-                        text: el.textContent?.trim()?.substring(0, 100) || '',
+                        text: textContent.trim()?.substring(0, 100) || '',
                         tag: el.tagName.toLowerCase(),
                         id: el.id || '',
                         className: typeof el.className === 'string' ? el.className : '',
+                        position: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
                     });
                 }
             }
             return results;
-        }, args.contains);
+        }, { text: searchText, exact: isExact, elementType: args.elementType, limit });
         elements.push(...containsElements.map((e) => ({
             selector: e.id ? `#${e.id}` : e.className ? `.${e.className.split(' ')[0]}` : e.tag,
             text: e.text,
             tag: e.tag,
+            position: args.includePosition ? e.position : undefined,
         })));
     }
+    // Attribute search
     if (args.attributes) {
         let attributes = {};
         try {
@@ -346,39 +823,42 @@ export async function handleFindElementAdvanced(page, args) {
         catch (e) {
             // Ignore invalid JSON
         }
-        // Use Puppeteer evaluation to find elements with matching attributes
-        const attributeElements = await page.evaluate((attrs) => {
+        const attributeElements = await page.evaluate((opts) => {
             const results = [];
             const allElements = document.querySelectorAll('*');
-            for (let i = 0; i < allElements.length && results.length < 50; i++) {
+            for (let i = 0; i < allElements.length && results.length < opts.limit; i++) {
                 const el = allElements[i];
                 let match = true;
-                for (const [key, value] of Object.entries(attrs)) {
+                for (const [key, value] of Object.entries(opts.attrs)) {
                     if (el.getAttribute(key) !== value) {
                         match = false;
                         break;
                     }
                 }
                 if (match) {
+                    const rect = el.getBoundingClientRect();
                     results.push({
                         text: el.textContent?.trim()?.substring(0, 100) || '',
                         tag: el.tagName.toLowerCase(),
                         id: el.id || '',
                         className: typeof el.className === 'string' ? el.className : '',
+                        position: { x: Math.round(rect.x), y: Math.round(rect.y), width: Math.round(rect.width), height: Math.round(rect.height) },
                     });
                 }
             }
             return results;
-        }, attributes);
+        }, { attrs: attributes, limit });
         elements.push(...attributeElements.map((e) => ({
             selector: e.id ? `#${e.id}` : e.className ? `.${e.className.split(' ')[0]}` : e.tag,
             text: e.text,
             tag: e.tag,
+            position: args.includePosition ? e.position : undefined,
         })));
     }
+    tracker.complete(`🎉 Found ${elements.length} elements`);
     return {
         found: elements.length > 0,
-        elements: elements.slice(0, 50),
+        elements: elements.slice(0, limit),
         count: elements.length,
     };
 }

package/dist/index.js

@@ -57,7 +57,11 @@ import { handleClick, handleType, handleSolveCaptcha, handleRandomScroll } from
 import { handleGetContent, handleFindSelector } from './handlers/content-handlers.js';
 import { handleSaveContentAsMarkdown } from './handlers/file-handlers.js';
 // Import advanced tools handlers
-import { handleBreadcrumbNavigator, handleUrlRedirectTracer, handleSearchContent, handleExtractJson, handleScrapeMetaTags, handlePressKey, handleProgressTracker, handleDeepAnalysis, handleNetworkRecorder, handleElementScreenshot, handleLinkHarvester, handleBatchElementScraper, handleCookieManager, 
+import { 
+// handleBreadcrumbNavigator REMOVED - use click or find_element
+handleUrlRedirectTracer, handleSearchRegex, handleExtractJson, handleScrapeMetaTags, handlePressKey, handleProgressTracker, handleDeepAnalysis, handleNetworkRecorder, 
+// handleElementScreenshot, // REMOVED - use deep_analysis with includeScreenshot
+handleLinkHarvester, handleCookieManager, 
 // Download tools
 handleFileDownloader, 
 // Enhanced streaming/download tools
@@ -176,18 +180,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case TOOL_NAMES.SAVE_CONTENT_AS_MARKDOWN:
                 return await handleSaveContentAsMarkdown(args);
             // Advanced Tools
-            case TOOL_NAMES.BREADCRUMB_NAVIGATOR:
-                if (!page)
-                    throw new Error('Browser not initialized. Call browser_init first.');
-                return { content: [{ type: 'text', text: JSON.stringify(await handleBreadcrumbNavigator(page, args || {})) }] };
+            // BREADCRUMB_NAVIGATOR case REMOVED - use click or find_element
             case TOOL_NAMES.REDIRECT_TRACER:
                 if (!page)
                     throw new Error('Browser not initialized. Call browser_init first.');
                 return { content: [{ type: 'text', text: JSON.stringify(await handleUrlRedirectTracer(page, args)) }] };
-            case TOOL_NAMES.SEARCH_CONTENT:
+            case TOOL_NAMES.SEARCH_REGEX:
                 if (!page)
                     throw new Error('Browser not initialized. Call browser_init first.');
-                return { content: [{ type: 'text', text: JSON.stringify(await handleSearchContent(page, args)) }] };
+                return { content: [{ type: 'text', text: JSON.stringify(await handleSearchRegex(page, args)) }] };
+            // WEB_SEARCH case REMOVED - redundant with search_regex
             case TOOL_NAMES.EXTRACT_JSON:
                 if (!page)
                     throw new Error('Browser not initialized. Call browser_init first.');
@@ -215,18 +217,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // API_FINDER case REMOVED - merged into NETWORK_RECORDER (use findApis: true)
             // AJAX_CONTENT_WAITER case REMOVED - merged into WAIT (use pollInterval, expectedContent)
             // MEDIA_EXTRACTOR case REMOVED - merged into STREAM_EXTRACTOR
-            case TOOL_NAMES.ELEMENT_SCREENSHOT:
-                if (!page)
-                    throw new Error('Browser not initialized. Call browser_init first.');
-                return { content: [{ type: 'text', text: JSON.stringify(await handleElementScreenshot(page, args)) }] };
+            // ELEMENT_SCREENSHOT case REMOVED - use deep_analysis with includeScreenshot
             case TOOL_NAMES.LINK_HARVESTER:
                 if (!page)
                     throw new Error('Browser not initialized. Call browser_init first.');
                 return { content: [{ type: 'text', text: JSON.stringify(await handleLinkHarvester(page, args || {})) }] };
-            case TOOL_NAMES.BATCH_ELEMENT_SCRAPER:
-                if (!page)
-                    throw new Error('Browser not initialized. Call browser_init first.');
-                return { content: [{ type: 'text', text: JSON.stringify(await handleBatchElementScraper(page, args)) }] };
+            // BATCH_ELEMENT_SCRAPER case REMOVED - merged into FIND_ELEMENT (use batchMode)
             // EXTRACT_SCHEMA case REMOVED - merged into EXTRACT_JSON (use extractSchema option)
             // M3U8_PARSER case REMOVED - merged into STREAM_EXTRACTOR
             case TOOL_NAMES.COOKIE_MANAGER:

package/dist/lsp/browser-automation-lsp.js

@@ -63,7 +63,7 @@ const TOOL_DEFINITIONS = {
     },
     find_element: {
         name: 'find_element',
-        description: 'Find elements using text, CSS selector, XPath, attributes, or AI-powered description',
+        description: 'Ultra-powerful element finder and batch scraper. Find elements using text, CSS selector, XPath, attributes, or AI-powered description. Supports batch scraping mode with advanced filtering.',
         category: 'Content',
         parameters: [
             { name: 'text', type: 'string', description: 'Text content to search for', required: false },
@@ -71,6 +71,11 @@ const TOOL_DEFINITIONS = {
             { name: 'xpath', type: 'string', description: 'XPath expression', required: false },
             { name: 'description', type: 'string', description: 'Natural language description (AI-powered)', required: false },
             { name: 'exact', type: 'boolean', description: 'Exact text match', required: false, default: false },
+            { name: 'batchMode', type: 'boolean', description: 'Enable batch scraping mode for multiple elements', required: false, default: false },
+            { name: 'extractAttributes', type: 'array', description: 'Attributes to extract in batch mode (e.g., href, src)', required: false },
+            { name: 'limit', type: 'number', description: 'Maximum elements to process', required: false, default: 100 },
+            { name: 'includePosition', type: 'boolean', description: 'Include element position (x, y, width, height)', required: false, default: false },
+            { name: 'returnType', type: 'string', description: 'Output format: elements, selectors, or data', required: false, enum: ['elements', 'selectors', 'data'], default: 'elements' },
         ],
     },
     save_content_as_markdown: {
@@ -164,15 +169,20 @@ const TOOL_DEFINITIONS = {
         ],
     },
     // Advanced Tools
-    search_content: {
-        name: 'search_content',
-        description: 'Search text or Regex patterns in page content',
+    search_regex: {
+        name: 'search_regex',
+        description: '🔥 ULTRA-POWERFUL Regex Engine (like regex101.com) - Full regex support with flags, capture groups, replace mode, timeout protection',
         category: 'Advanced',
         parameters: [
-            { name: 'pattern', type: 'string', description: 'Search pattern (text or regex)', required: true },
-            { name: 'isRegex', type: 'boolean', description: 'Treat pattern as regex', required: false, default: false },
+            { name: 'pattern', type: 'string', description: 'Regex pattern to search', required: true },
+            { name: 'flags', type: 'object', description: 'Regex flags: global, ignoreCase, multiline, dotAll, unicode, sticky', required: false },
+            { name: 'replaceWith', type: 'string', description: 'Replace matches with this string (supports $1, $2, $&)', required: false },
+            { name: 'sourceType', type: 'string', description: 'Where to search: text, html, scripts, styles, attributes, all', required: false, default: 'text' },
+            { name: 'extractGroups', type: 'boolean', description: 'Extract capture groups', required: false, default: true },
+            { name: 'highlightMatches', type: 'boolean', description: 'Highlight matches in context', required: false, default: false },
         ],
     },
+    // web_search REMOVED - redundant with search_regex
     extract_json: {
         name: 'extract_json',
         description: 'Extract embedded JSON/API data from page (LD+JSON, __NEXT_DATA__, etc.)',
@@ -239,16 +249,7 @@ const TOOL_DEFINITIONS = {
             { name: 'maxLinks', type: 'number', description: 'Maximum links to return', required: false },
         ],
     },
-    batch_element_scraper: {
-        name: 'batch_element_scraper',
-        description: 'Efficiently scrape lists of similar elements',
-        category: 'Advanced',
-        parameters: [
-            { name: 'selector', type: 'string', description: 'CSS selector for elements to scrape', required: true },
-            { name: 'attributes', type: 'array', description: 'Attributes to extract', required: false },
-            { name: 'limit', type: 'number', description: 'Maximum elements to scrape', required: false, default: 100 },
-        ],
-    },
+    // batch_element_scraper REMOVED - merged into find_element (use batchMode: true)
     extract_schema: {
         name: 'extract_schema',
         description: 'Extract Schema.org structured data (JSON-LD and Microdata)',
@@ -257,25 +258,8 @@ const TOOL_DEFINITIONS = {
             { name: 'schemaTypes', type: 'array', description: 'Schema types to extract (e.g., Product, Article)', required: false },
         ],
     },
-    element_screenshot: {
-        name: 'element_screenshot',
-        description: 'Capture screenshot of a specific element',
-        category: 'Advanced',
-        parameters: [
-            { name: 'selector', type: 'string', description: 'CSS selector of element to capture', required: true },
-            { name: 'path', type: 'string', description: 'File path to save screenshot', required: false },
-            { name: 'format', type: 'string', description: 'Image format', required: false, enum: ['png', 'jpeg', 'webp'], default: 'png' },
-        ],
-    },
-    breadcrumb_navigator: {
-        name: 'breadcrumb_navigator',
-        description: 'Navigate using site breadcrumbs - find and click breadcrumb links',
-        category: 'Advanced',
-        parameters: [
-            { name: 'targetIndex', type: 'number', description: 'Index of breadcrumb to click (0-based)', required: false },
-            { name: 'targetText', type: 'string', description: 'Text of breadcrumb to click', required: false },
-        ],
-    },
+    // element_screenshot REMOVED - use deep_analysis with includeScreenshot: true
+    // breadcrumb_navigator REMOVED - use click or find_element with text
     redirect_tracer: {
         name: 'redirect_tracer',
         description: 'Trace URL redirects including standard, JavaScript, and meta refresh redirects',

package/dist/tool-definitions.js

@@ -354,11 +354,12 @@ export const TOOLS = [
     },
     {
         name: 'find_element',
-        description: 'Find elements using text, CSS selector, XPath, attributes, or AI-powered description. Supports Shadow DOM and cross-frame search.',
+        description: 'Ultra-powerful element finder and batch scraper. Find elements using text, CSS selector, XPath, attributes, or AI-powered description. Supports Shadow DOM, cross-frame search, and efficient batch scraping of similar elements with advanced filtering.',
         inputSchema: {
             type: 'object',
             additionalProperties: false,
             properties: {
+                // === FIND MODE ===
                 text: { type: 'string', description: 'Text content to search for in elements' },
                 selector: { type: 'string', description: 'CSS selector' },
                 xpath: { type: 'string', description: 'XPath expression' },
@@ -369,6 +370,34 @@ export const TOOLS = [
                 context: { type: 'string', description: 'Additional context for AI search' },
                 shadowDOM: { type: 'boolean', description: 'Search inside Shadow DOM elements', default: false },
                 searchFrames: { type: 'boolean', description: 'Search across all iframes/frames', default: false },
+                // === BATCH SCRAPE MODE (merged from batch_element_scraper) ===
+                batchMode: { type: 'boolean', description: 'Enable batch scraping mode for extracting data from multiple similar elements', default: false },
+                extractAttributes: { type: 'array', items: { type: 'string' }, description: 'Attributes to extract in batch mode (e.g., href, src, data-id). Default: textContent, href, src' },
+                limit: { type: 'number', description: 'Maximum elements to process in batch mode', default: 100 },
+                includeInnerHTML: { type: 'boolean', description: 'Include innerHTML in batch extraction', default: false },
+                includePosition: { type: 'boolean', description: 'Include element position (x, y, width, height) in results', default: false },
+                // === ADVANCED FILTERS ===
+                filter: {
+                    type: 'object',
+                    description: 'Advanced filtering options for more precise element selection',
+                    properties: {
+                        visible: { type: 'boolean', description: 'Only find visible elements (not hidden by CSS)' },
+                        enabled: { type: 'boolean', description: 'Only find enabled elements (not disabled)' },
+                        minWidth: { type: 'number', description: 'Minimum element width in pixels' },
+                        minHeight: { type: 'number', description: 'Minimum element height in pixels' },
+                        hasChildren: { type: 'boolean', description: 'Only elements that have child elements' },
+                        containsClass: { type: 'string', description: 'Element must contain this CSS class' },
+                        matchPattern: { type: 'string', description: 'Regex pattern to match element text content' },
+                    },
+                    additionalProperties: false,
+                },
+                // === OUTPUT OPTIONS ===
+                returnType: {
+                    type: 'string',
+                    enum: ['elements', 'selectors', 'data'],
+                    description: 'What to return: elements (full info with tag, text, attributes), selectors (just CSS selectors), data (extracted attribute data only)',
+                    default: 'elements'
+                },
             },
         },
     },
@@ -426,20 +455,9 @@ export const TOOLS = [
         },
     },
     // ============================================================
-    // ADVANCED TOOLS (24 advanced tools)
+    // ADVANCED TOOLS
     // ============================================================
-    {
-        name: 'breadcrumb_navigator',
-        description: 'Navigate using site breadcrumbs - find and click breadcrumb links',
-        inputSchema: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                targetIndex: { type: 'number', description: 'Index of breadcrumb to click (0-based)' },
-                targetText: { type: 'string', description: 'Text of breadcrumb to click' },
-            },
-        },
-    },
+    // breadcrumb_navigator REMOVED - use click or find_element with text
     {
         name: 'redirect_tracer',
         description: 'Trace URL redirects including standard, JavaScript, and meta refresh redirects',
@@ -457,20 +475,53 @@ export const TOOLS = [
         },
     },
     {
-        name: 'search_content',
-        description: 'Search text or Regex patterns in page content',
+        name: 'search_regex',
+        description: `🔥 ULTRA-POWERFUL Regex Engine (like regex101.com) - Test, match, replace with full regex support. Features: Named capture groups, all regex flags (g/i/m/s/u/y), match highlighting, detailed match info with indices, replace mode, pattern explanation, timeout protection against catastrophic backtracking. Search in HTML, text, scripts, styles, or attributes.`,
         inputSchema: {
             type: 'object',
             additionalProperties: false,
             properties: {
-                pattern: { type: 'string', description: 'Search pattern (text or regex)' },
-                isRegex: { type: 'boolean', description: 'Treat pattern as regex', default: false },
-                caseSensitive: { type: 'boolean', description: 'Case sensitive search', default: false },
+                // Core regex
+                pattern: { type: 'string', description: 'Regex pattern to search (supports full JavaScript regex syntax including lookahead/lookbehind)' },
+                testString: { type: 'string', description: 'Optional custom string to test against. If not provided, uses page content' },
+                // Regex flags (individually controllable like regex101.com)
+                flags: {
+                    type: 'object',
+                    description: 'Regex flags - control each flag individually',
+                    properties: {
+                        global: { type: 'boolean', description: 'g flag - Find all matches', default: true },
+                        ignoreCase: { type: 'boolean', description: 'i flag - Case insensitive', default: false },
+                        multiline: { type: 'boolean', description: 'm flag - ^ and $ match line boundaries', default: false },
+                        dotAll: { type: 'boolean', description: 's flag - Dot matches newlines', default: false },
+                        unicode: { type: 'boolean', description: 'u flag - Unicode mode', default: false },
+                        sticky: { type: 'boolean', description: 'y flag - Sticky mode', default: false },
+                    },
+                    additionalProperties: false,
+                },
+                // Replace mode (like regex101.com substitution)
+                replaceWith: { type: 'string', description: 'Replace matches with this string. Supports $1, $2, $& for capture groups' },
+                // Match options
+                maxMatches: { type: 'number', description: 'Maximum number of matches to return', default: 100 },
+                contextChars: { type: 'number', description: 'Number of context characters around each match', default: 50 },
+                // Source selection
+                sourceType: {
+                    type: 'string',
+                    enum: ['text', 'html', 'scripts', 'styles', 'attributes', 'all'],
+                    description: 'What content to search in',
+                    default: 'text'
+                },
                 selector: { type: 'string', description: 'CSS selector to limit search scope' },
+                // Advanced features
+                extractGroups: { type: 'boolean', description: 'Extract and return named/numbered capture groups', default: true },
+                highlightMatches: { type: 'boolean', description: 'Return matches with <<MATCH>> highlighting', default: false },
+                showMatchInfo: { type: 'boolean', description: 'Show detailed match info: index, length, groups', default: true },
+                // Safety
+                timeout: { type: 'number', description: 'Regex execution timeout in ms (prevents catastrophic backtracking)', default: 5000 },
             },
             required: ['pattern'],
         },
     },
+    // web_search tool REMOVED - redundant with search_regex and other tools
     {
         name: 'extract_json',
         description: 'Extract embedded JSON/API data from page (LD+JSON, __NEXT_DATA__, etc.) + Advanced Decode (base64, URL, hex, rot13, multi-layer) + Packed JavaScript decoder + AES-CBC decryption for encrypted streaming sites',
@@ -609,21 +660,8 @@ export const TOOLS = [
     // api_finder REMOVED - merged into network_recorder (use findApis: true)
     // ajax_content_waiter REMOVED - merged into wait tool (use pollInterval, expectedContent)
     // media_extractor REMOVED - functionality merged into stream_extractor
-    {
-        name: 'element_screenshot',
-        description: 'Capture screenshot of a specific element',
-        inputSchema: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                selector: { type: 'string', description: 'CSS selector of element to capture' },
-                path: { type: 'string', description: 'File path to save screenshot' },
-                format: { type: 'string', enum: ['png', 'jpeg', 'webp'], description: 'Image format', default: 'png' },
-                quality: { type: 'number', description: 'Quality for JPEG/WebP (0-100)' },
-            },
-            required: ['selector'],
-        },
-    },
+    // element_screenshot REMOVED - use deep_analysis with includeScreenshot: true for screenshots
+    // batch_element_scraper REMOVED - merged into find_element (use batchMode: true)
     {
         name: 'link_harvester',
         description: 'Harvest all links from page with filtering options',
@@ -638,20 +676,6 @@ export const TOOLS = [
             },
         },
     },
-    {
-        name: 'batch_element_scraper',
-        description: 'Efficiently scrape lists of similar elements',
-        inputSchema: {
-            type: 'object',
-            additionalProperties: false,
-            properties: {
-                selector: { type: 'string', description: 'CSS selector for elements to scrape' },
-                attributes: { type: 'array', items: { type: 'string' }, description: 'Attributes to extract' },
-                limit: { type: 'number', description: 'Maximum elements to scrape', default: 100 },
-            },
-            required: ['selector'],
-        },
-    },
     // extract_schema REMOVED - merged into extract_json (use extractSchema option)
     // m3u8_parser REMOVED - functionality merged into stream_extractor
     {
@@ -801,9 +825,10 @@ export const TOOL_NAMES = {
     FIND_ELEMENT: 'find_element',
     SAVE_CONTENT_AS_MARKDOWN: 'save_content_as_markdown',
     // Advanced tools
-    BREADCRUMB_NAVIGATOR: 'breadcrumb_navigator',
+    // BREADCRUMB_NAVIGATOR REMOVED - use click or find_element with text
     REDIRECT_TRACER: 'redirect_tracer',
-    SEARCH_CONTENT: 'search_content',
+    SEARCH_REGEX: 'search_regex', // Renamed from SEARCH_CONTENT - now regex101.com-like
+    // WEB_SEARCH REMOVED - redundant with search_regex
     EXTRACT_JSON: 'extract_json',
     SCRAPE_META_TAGS: 'scrape_meta_tags',
     PRESS_KEY: 'press_key',
@@ -813,9 +838,9 @@ export const TOOL_NAMES = {
     // API_FINDER: 'api_finder', // REMOVED - merged into NETWORK_RECORDER (use findApis option)
     // AJAX_CONTENT_WAITER: 'ajax_content_waiter', // REMOVED - merged into WAIT (use pollInterval, expectedContent)
     // MEDIA_EXTRACTOR: 'media_extractor', // REMOVED - merged into STREAM_EXTRACTOR
-    ELEMENT_SCREENSHOT: 'element_screenshot',
+    // ELEMENT_SCREENSHOT: 'element_screenshot', // REMOVED - use DEEP_ANALYSIS with includeScreenshot
     LINK_HARVESTER: 'link_harvester',
-    BATCH_ELEMENT_SCRAPER: 'batch_element_scraper',
+    // BATCH_ELEMENT_SCRAPER: 'batch_element_scraper', // REMOVED - merged into FIND_ELEMENT (use batchMode option)
     // EXTRACT_SCHEMA: 'extract_schema', // REMOVED - merged into EXTRACT_JSON (use extractSchema option)
     // M3U8_PARSER: 'm3u8_parser', // REMOVED - merged into STREAM_EXTRACTOR
     COOKIE_MANAGER: 'cookie_manager',

package/dist/unified-server.js

@@ -218,21 +218,18 @@ mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
                 result = await handleSaveContentAsMarkdown(args);
                 break;
             // Advanced tools
-            case TOOL_NAMES.BREADCRUMB_NAVIGATOR:
-                if (!page)
-                    throw new Error('Browser not initialized');
-                result = { content: [{ type: 'text', text: JSON.stringify(await advancedTools.handleBreadcrumbNavigator(page, args || {})) }] };
-                break;
+            // BREADCRUMB_NAVIGATOR REMOVED - use click or find_element
             case TOOL_NAMES.REDIRECT_TRACER:
                 if (!page)
                     throw new Error('Browser not initialized');
                 result = { content: [{ type: 'text', text: JSON.stringify(await advancedTools.handleUrlRedirectTracer(page, args)) }] };
                 break;
-            case TOOL_NAMES.SEARCH_CONTENT:
+            case TOOL_NAMES.SEARCH_REGEX:
                 if (!page)
                     throw new Error('Browser not initialized');
-                result = { content: [{ type: 'text', text: JSON.stringify(await advancedTools.handleSearchContent(page, args)) }] };
+                result = { content: [{ type: 'text', text: JSON.stringify(await advancedTools.handleSearchRegex(page, args)) }] };
                 break;
+            // WEB_SEARCH case REMOVED - redundant with search_regex
             // MEDIA_EXTRACTOR case REMOVED - merged into STREAM_EXTRACTOR
             case TOOL_NAMES.STREAM_EXTRACTOR:
                 if (!page)
@@ -615,17 +612,14 @@ async function main() {
             console.error('   🖼️  iframe_handler        - Handle nested iframes (deep_scrape)');
             console.error('');
             console.error('   Advanced Tools:');
-            console.error('   🔎 search_content        - Search patterns in page');
+            console.error('   🔥 search_regex          - ULTRA Regex Engine (like regex101)');
+            console.error('   🚀 web_search            - Intelligent Content Search');
             console.error('   📊 extract_json          - Extract embedded JSON');
             console.error('   🏷️  scrape_meta_tags      - Extract meta/OG tags');
             console.error('   📈 deep_analysis         - Full page analysis');
-            console.error('   📡 network_recorder      - Record network traffic');
-            console.error('   🔌 api_finder            - Discover hidden APIs');
-            console.error('   ⏱️  ajax_content_waiter   - Wait for dynamic content');
+            console.error('   📡 network_recorder      - Record network traffic + API finder');
             console.error('   🔗 link_harvester        - Harvest all links');
-            console.error('   📋 batch_element_scraper - Batch scrape elements');
             console.error('   🏗️  extract_schema        - Extract Schema.org data');
-            console.error('   📸 element_screenshot    - Screenshot element');
             console.error('   🧭 breadcrumb_navigator  - Navigate breadcrumbs');
             console.error('   ↪️  redirect_tracer       - Trace URL redirects');
             console.error('   📊 progress_tracker      - Track task progress');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.27.25",
+  "version": "2.27.26",
   "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,7 +50,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",
     "@types/turndown": "latest",
-    "brave-real-browser": "^2.8.25",
+    "brave-real-browser": "^2.8.26",
     "puppeteer-core": "^24.35.0",
     "turndown": "latest",
     "vscode-languageserver": "^9.0.1",