brave-real-browser-mcp-server 2.23.0 → 2.23.2

package/dist/self-healing-locators.js

@@ -24,6 +24,85 @@ export class SelfHealingLocators {
         'class', 'aria-role', 'title', 'placeholder', 'alt',
         'href', 'src', 'type', 'value', 'data-*'
     ];
+    /**
+     * Parse Playwright-style :has-text() selector
+     * Example: "button:has-text('HubCloud')" -> { tagName: 'button', text: 'HubCloud' }
+     * Also supports: "button:contains('text')" and ":text('value')"
+     */
+    parseTextSelector(selector) {
+        // Match :has-text("text") or :has-text('text')
+        const hasTextMatch = selector.match(/^([a-zA-Z]*)(?:\.[^\s:]+)*:has-text\(["']([^"']+)["']\)/i);
+        if (hasTextMatch) {
+            return {
+                tagName: hasTextMatch[1] || undefined,
+                text: hasTextMatch[2]
+            };
+        }
+        // Match :contains("text") jQuery-style
+        const containsMatch = selector.match(/^([a-zA-Z]*)(?:\.[^\s:]+)*:contains\(["']([^"']+)["']\)/i);
+        if (containsMatch) {
+            return {
+                tagName: containsMatch[1] || undefined,
+                text: containsMatch[2]
+            };
+        }
+        // Match :text("value") Playwright-style
+        const textMatch = selector.match(/:text\(["']([^"']+)["']\)/i);
+        if (textMatch) {
+            return {
+                tagName: undefined,
+                text: textMatch[1]
+            };
+        }
+        return null;
+    }
+    /**
+     * Find element by text content (for :has-text() support)
+     */
+    async findByText(pageInstance, text, tagName) {
+        try {
+            const element = await pageInstance.evaluateHandle((searchText, tag) => {
+                const selector = tag || '*';
+                const elements = Array.from(document.querySelectorAll(selector));
+                // Find element that contains or exactly matches the text
+                const found = elements.find(el => {
+                    // Skip script and style elements
+                    if (el.tagName === 'SCRIPT' || el.tagName === 'STYLE')
+                        return false;
+                    const textContent = el.textContent?.trim() || '';
+                    const directText = Array.from(el.childNodes)
+                        .filter(n => n.nodeType === Node.TEXT_NODE)
+                        .map(n => n.textContent?.trim())
+                        .join('');
+                    // Check direct text first (more accurate)
+                    if (directText.includes(searchText) || directText === searchText)
+                        return true;
+                    // Check if element's own text contains the search text
+                    // but avoid matching parent elements that contain the text in children
+                    if (el.children.length === 0 && textContent.includes(searchText))
+                        return true;
+                    // For buttons/links with nested elements (icons, spans), check full text
+                    if (['BUTTON', 'A', 'DIV'].includes(el.tagName) && textContent.includes(searchText)) {
+                        return true;
+                    }
+                    return false;
+                });
+                return found || null;
+            }, text, tagName);
+            const asElement = element.asElement();
+            if (asElement) {
+                // Verify element is visible
+                const box = await asElement.boundingBox();
+                if (box && box.width > 0 && box.height > 0) {
+                    return asElement;
+                }
+            }
+            return null;
+        }
+        catch (e) {
+            return null;
+        }
+    }
     /**
      * Generate fallback selectors for a failed primary selector
      */
@@ -59,6 +138,18 @@ export class SelfHealingLocators {
      * Try to find an element using fallback selectors
      */
     async findElementWithFallbacks(pageInstance, primarySelector, expectedText) {
+        // Check if selector uses :has-text(), :contains(), or :text() syntax
+        const textSelector = this.parseTextSelector(primarySelector);
+        if (textSelector) {
+            const element = await this.findByText(pageInstance, textSelector.text, textSelector.tagName);
+            if (element) {
+                return {
+                    element,
+                    usedSelector: `${textSelector.tagName || '*'}[text*="${textSelector.text}"]`,
+                    strategy: 'text-content'
+                };
+            }
+        }
         // First try the primary selector
         try {
             const primaryElement = await pageInstance.$(primarySelector);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brave-real-browser-mcp-server",
-  "version": "2.23.0",
+  "version": "2.23.2",
   "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",
@@ -49,7 +49,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "latest",
     "@types/turndown": "latest",
-    "brave-real-browser": "^2.4.0",
+    "brave-real-browser": "^2.4.2",
     "turndown": "latest",
     "vscode-languageserver": "^9.0.1",
     "vscode-languageserver-textdocument": "^1.0.12"