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

package/dist/handlers/advanced-tools.js

@@ -195,21 +195,137 @@ export async function handleMultiLayerRedirectTrace(page, args) {
     };
 }
 /**
- * 🔥 ULTRA-POWERFUL Regex Engine (like regex101.com)
+ * 🔥 ULTRA-POWERFUL Regex Engine (like regex101.com) + Simple Search Mode
  * Features: Named capture groups, all regex flags, match highlighting,
- * detailed match info, replace mode, timeout protection
+ * detailed match info, replace mode, timeout protection,
+ * NEW: Simple search mode, Pattern explanation, Hierarchical group tree
  */
+// Helper: Escape regex special characters for simple search mode
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// Helper: Generate pattern explanation
+function explainPattern(pattern) {
+    const explanations = [];
+    const regexTokens = [
+        { regex: /^\^/, meaning: () => 'Start of string/line' },
+        { regex: /^\$/, meaning: () => 'End of string/line' },
+        { regex: /^\\d/, meaning: () => 'Any digit (0-9)' },
+        { regex: /^\\D/, meaning: () => 'Any non-digit character' },
+        { regex: /^\\w/, meaning: () => 'Word character (a-z, A-Z, 0-9, _)' },
+        { regex: /^\\W/, meaning: () => 'Non-word character' },
+        { regex: /^\\s/, meaning: () => 'Whitespace character (space, tab, newline)' },
+        { regex: /^\\S/, meaning: () => 'Non-whitespace character' },
+        { regex: /^\\b/, meaning: () => 'Word boundary' },
+        { regex: /^\\B/, meaning: () => 'Non-word boundary' },
+        { regex: /^\\n/, meaning: () => 'Newline character' },
+        { regex: /^\\r/, meaning: () => 'Carriage return' },
+        { regex: /^\\t/, meaning: () => 'Tab character' },
+        { regex: /^\./, meaning: () => 'Any character (except newline unless s flag)' },
+        { regex: /^\*/, meaning: () => 'Zero or more of the preceding' },
+        { regex: /^\+/, meaning: () => 'One or more of the preceding' },
+        { regex: /^\?/, meaning: () => 'Zero or one of the preceding (optional)' },
+        { regex: /^\*\?/, meaning: () => 'Zero or more (lazy/non-greedy)' },
+        { regex: /^\+\?/, meaning: () => 'One or more (lazy/non-greedy)' },
+        { regex: /^\?\?/, meaning: () => 'Zero or one (lazy/non-greedy)' },
+        { regex: /^\|/, meaning: () => 'OR - matches either side' },
+        { regex: /^\(\?:([^)]*)\)/, meaning: (m) => `Non-capturing group: ${m}` },
+        { regex: /^\(\?=([^)]*)\)/, meaning: (m) => `Positive lookahead: must be followed by "${m}"` },
+        { regex: /^\(\?!([^)]*)\)/, meaning: (m) => `Negative lookahead: must NOT be followed by "${m}"` },
+        { regex: /^\(\?<=([^)]*)\)/, meaning: (m) => `Positive lookbehind: must be preceded by "${m}"` },
+        { regex: /^\(\?<!([^)]*)\)/, meaning: (m) => `Negative lookbehind: must NOT be preceded by "${m}"` },
+        { regex: /^\(\?<(\w+)>/, meaning: (m) => `Named capture group: "${m}"` },
+        { regex: /^\(/, meaning: () => 'Capture group start' },
+        { regex: /^\)/, meaning: () => 'Capture group end' },
+        { regex: /^\[(\^)?([^\]]+)\]/, meaning: (m) => m.startsWith('^') ? `Any character NOT in: ${m.slice(1)}` : `Any character in: ${m}` },
+        { regex: /^\{(\d+)\}/, meaning: (m) => `Exactly ${m} occurrences` },
+        { regex: /^\{(\d+),\}/, meaning: (m) => `${m} or more occurrences` },
+        { regex: /^\{(\d+),(\d+)\}/, meaning: (m) => `Between ${m.split(',')[0]} and ${m.split(',')[1]} occurrences` },
+        { regex: /^\\([0-9])/, meaning: (m) => `Backreference to group ${m}` },
+        { regex: /^\\k<(\w+)>/, meaning: (m) => `Backreference to named group "${m}"` },
+        { regex: /^https?:\/\//, meaning: () => 'HTTP or HTTPS protocol' },
+        { regex: /^[a-zA-Z0-9]+/, meaning: (m) => `Literal text: "${m}"` },
+        { regex: /^\\(.)/, meaning: (m) => `Escaped character: "${m}"` },
+    ];
+    let remaining = pattern;
+    let position = 0;
+    while (remaining.length > 0) {
+        let matched = false;
+        for (const token of regexTokens) {
+            const match = remaining.match(token.regex);
+            if (match) {
+                const part = match[0];
+                const captured = match[1] || match[0];
+                explanations.push({
+                    part,
+                    meaning: token.meaning(captured),
+                    position,
+                });
+                remaining = remaining.slice(part.length);
+                position += part.length;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            // Single character literal
+            const char = remaining[0];
+            explanations.push({
+                part: char,
+                meaning: `Literal character: "${char}"`,
+                position,
+            });
+            remaining = remaining.slice(1);
+            position += 1;
+        }
+    }
+    return explanations;
+}
+// Helper: Build hierarchical group tree
+function buildGroupTree(pattern, match) {
+    const groups = [];
+    // Extract named groups from pattern
+    const namedGroupPattern = /\(\?<(\w+)>/g;
+    const namedGroups = [];
+    let namedMatch;
+    while ((namedMatch = namedGroupPattern.exec(pattern)) !== null) {
+        namedGroups.push(namedMatch[1]);
+    }
+    // Build group entries
+    for (let i = 1; i < match.length; i++) {
+        if (match[i] !== undefined) {
+            const value = match[i];
+            const fullMatchText = match[0];
+            const valueIndex = fullMatchText.indexOf(value);
+            groups.push({
+                index: i,
+                name: match.groups && Object.keys(match.groups)[i - 1] ? Object.keys(match.groups).find(k => match.groups[k] === value) : undefined,
+                value,
+                start: valueIndex >= 0 ? match.index + valueIndex : match.index,
+                end: valueIndex >= 0 ? match.index + valueIndex + value.length : match.index + value.length,
+                nested: i > 1 && match[i - 1]?.includes(value),
+            });
+        }
+    }
+    return {
+        fullMatch: match[0],
+        groups,
+    };
+}
 export async function handleSearchRegex(page, args) {
     const progressNotifier = getProgressNotifier();
     const tracker = progressNotifier.createTracker(`search-regex-${Date.now()}`);
-    tracker.start(100, `🔎 Regex Search: "${args.pattern}"`);
+    // Determine search mode
+    const isSimpleSearch = args.simpleSearch === true;
+    const searchMode = isSimpleSearch ? '🔤 Simple Search' : '🔎 Regex Search';
+    tracker.start(100, `${searchMode}: "${args.pattern}"`);
     // Build regex flags
     const flags = args.flags || {};
     let flagString = '';
     if (flags.global !== false)
         flagString += 'g';
-    if (flags.ignoreCase)
-        flagString += 'i';
+    if (flags.ignoreCase || isSimpleSearch)
+        flagString += 'i'; // Simple search defaults to case-insensitive
     if (flags.multiline)
         flagString += 'm';
     if (flags.dotAll)
@@ -218,11 +334,24 @@ export async function handleSearchRegex(page, args) {
         flagString += 'u';
     if (flags.sticky)
         flagString += 'y';
+    // Process pattern based on mode
+    let processedPattern = args.pattern;
+    const originalPattern = args.pattern;
+    if (isSimpleSearch) {
+        // Escape all regex special characters for literal search
+        processedPattern = escapeRegex(args.pattern);
+        tracker.setProgress(10, '🔤 Simple search mode - treating as literal text');
+    }
     // Validate regex
     let regex;
-    let patternInfo = { flags: flagString, isValid: true, errorMessage: undefined };
+    let patternInfo = {
+        flags: flagString,
+        isValid: true,
+        isSimpleSearch,
+        originalPattern: isSimpleSearch ? originalPattern : undefined,
+    };
     try {
-        regex = new RegExp(args.pattern, flagString);
+        regex = new RegExp(processedPattern, flagString);
     }
     catch (e) {
         tracker.fail(`Invalid regex: ${e.message}`);
@@ -230,9 +359,15 @@ export async function handleSearchRegex(page, args) {
             found: false,
             matches: [],
             count: 0,
-            patternInfo: { flags: flagString, isValid: false, errorMessage: e.message },
+            patternInfo: { ...patternInfo, isValid: false, errorMessage: e.message },
         };
     }
+    // Generate pattern explanation if requested
+    let patternExplanation;
+    if (args.showExplanation && !isSimpleSearch) {
+        tracker.setProgress(15, '📖 Generating pattern explanation...');
+        patternExplanation = explainPattern(args.pattern);
+    }
     tracker.setProgress(20, '📄 Extracting content...');
     // Get content based on sourceType
     let content = '';
@@ -288,9 +423,9 @@ export async function handleSearchRegex(page, args) {
     }
     if (!content) {
         tracker.fail('No content to search');
-        return { found: false, matches: [], count: 0, patternInfo };
+        return { found: false, matches: [], count: 0, patternInfo, patternExplanation };
     }
-    tracker.setProgress(50, '🔍 Running regex match...');
+    tracker.setProgress(50, '🔍 Running match...');
     const matches = [];
     const maxMatches = args.maxMatches || 100;
     const contextChars = args.contextChars || 50;
@@ -319,7 +454,7 @@ export async function handleSearchRegex(page, args) {
             length: match[0].length,
         };
         // Extract groups if requested
-        if (args.extractGroups !== false) {
+        if (args.extractGroups !== false && !isSimpleSearch) {
             if (match.groups) {
                 matchResult.groups = match.groups;
             }
@@ -327,6 +462,10 @@ export async function handleSearchRegex(page, args) {
                 matchResult.numberedGroups = match.slice(1);
             }
         }
+        // Build hierarchical group tree if requested
+        if (args.showGroupTree && !isSimpleSearch && match.length > 1) {
+            matchResult.groupTree = buildGroupTree(args.pattern, match);
+        }
         matches.push(matchResult);
         if (matches.length >= maxMatches)
             break;
@@ -341,13 +480,15 @@ export async function handleSearchRegex(page, args) {
         tracker.setProgress(90, '🔄 Applying replacement...');
         replaced = content.replace(regex, args.replaceWith);
     }
-    tracker.complete(`🎉 Found ${matches.length} matches`);
+    const modeText = isSimpleSearch ? 'text matches' : 'regex matches';
+    tracker.complete(`🎉 Found ${matches.length} ${modeText}`);
     return {
         found: matches.length > 0,
         matches,
         count: matches.length,
         replaced,
         patternInfo,
+        patternExplanation,
     };
 }
 /**

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

@@ -171,15 +171,18 @@ const TOOL_DEFINITIONS = {
     // Advanced Tools
     search_regex: {
         name: 'search_regex',
-        description: '🔥 ULTRA-POWERFUL Regex Engine (like regex101.com) - Full regex support with flags, capture groups, replace mode, timeout protection',
+        description: '🔥 ULTRA-POWERFUL Regex Engine (like regex101.com) - Full regex support with flags, capture groups, replace mode, timeout protection. NEW: Simple search mode for non-regex text search, pattern explanation, and group tree.',
         category: 'Advanced',
         parameters: [
-            { name: 'pattern', type: 'string', description: 'Regex pattern to search', required: true },
+            { name: 'pattern', type: 'string', description: 'Regex pattern to search (or literal text in simpleSearch mode)', required: true },
+            { name: 'simpleSearch', type: 'boolean', description: 'Treat pattern as literal text, not regex. Perfect for Ctrl+F style searches.', required: false, default: false },
             { 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 },
+            { name: 'showExplanation', type: 'boolean', description: 'Generate explanation for each regex component', required: false, default: false },
+            { name: 'showGroupTree', type: 'boolean', description: 'Show hierarchical structure of capture groups', required: false, default: false },
         ],
     },
     // web_search REMOVED - redundant with search_regex

package/dist/tool-definitions.js

@@ -476,14 +476,16 @@ export const TOOLS = [
     },
     {
         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.`,
+        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. NEW: Simple search mode for non-regex text search.`,
         inputSchema: {
             type: 'object',
             additionalProperties: false,
             properties: {
                 // Core regex
-                pattern: { type: 'string', description: 'Regex pattern to search (supports full JavaScript regex syntax including lookahead/lookbehind)' },
+                pattern: { type: 'string', description: 'Regex pattern to search (supports full JavaScript regex syntax including lookahead/lookbehind). In simpleSearch mode, treated as literal text.' },
                 testString: { type: 'string', description: 'Optional custom string to test against. If not provided, uses page content' },
+                // NEW: Simple Search Mode
+                simpleSearch: { type: 'boolean', description: 'Treat pattern as literal text, not regex. Perfect for Ctrl+F style searches. Automatically case-insensitive.', default: false },
                 // Regex flags (individually controllable like regex101.com)
                 flags: {
                     type: 'object',
@@ -515,6 +517,10 @@ export const TOOLS = [
                 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 },
+                // NEW: Pattern Explanation
+                showExplanation: { type: 'boolean', description: 'Generate explanation for each regex component (like regex101.com explanation sidebar)', default: false },
+                // NEW: Hierarchical Group Tree
+                showGroupTree: { type: 'boolean', description: 'Show hierarchical structure of capture groups with positions and nesting info', default: false },
                 // Safety
                 timeout: { type: 'number', description: 'Regex execution timeout in ms (prevents catastrophic backtracking)', default: 5000 },
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.27.26",
+  "version": "2.27.28",
   "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.26",
+    "brave-real-browser": "^2.8.28",
     "puppeteer-core": "^24.35.0",
     "turndown": "latest",
     "vscode-languageserver": "^9.0.1",