seleniumboot-mcp 0.3.0__tar.gz → 0.3.2__tar.gz

{seleniumboot_mcp-0.3.0 → seleniumboot_mcp-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seleniumboot-mcp
-Version: 0.3.0
+Version: 0.3.2
 Summary: A Python MCP server for Selenium WebDriver — 74 tools for browser automation, alerts, frames, shadow DOM, cookies, mobile emulation, self-healing locators, and codegen for Java/C#/Python/Playwright
 Author-email: Raza Tech <razatechnologyservices@gmail.com>
 License: MIT
@@ -25,7 +25,7 @@ Requires-Dist: selenium>=4.6.0
 A Python **Model Context Protocol (MCP)** server for Selenium WebDriver automation.
 Let Claude or GitHub Copilot control a real browser — navigate pages, interact with elements,
 run assertions, and generate ready-to-run **Java TestNG / JUnit 5 / Cucumber / pytest** test code from recorded sessions.
-74 tools. No ChromeDriver setup. Browser auto-starts on first use.
+82 tools. No ChromeDriver setup. Browser auto-starts on first use.
 
 [![PyPI](https://img.shields.io/pypi/v/seleniumboot-mcp)](https://pypi.org/project/seleniumboot-mcp/)
 [![Python](https://img.shields.io/pypi/pyversions/seleniumboot-mcp)](https://pypi.org/project/seleniumboot-mcp/)
@@ -107,7 +107,7 @@ Claude controls the real browser, records every action, and on request generates
 
 ---
 
-## Tools (74 total)
+## Tools (82 total)
 
 ### Browser
 | Tool | Description |
@@ -135,6 +135,13 @@ Claude controls the real browser, records every action, and on request generates
 | `delete_cookie` / `delete_all_cookies` | Remove cookies |
 | `get_local_storage` / `set_local_storage` | Read or write localStorage |
 | `get_session_storage` / `set_session_storage` | Read or write sessionStorage |
+| `wait_for_network_idle` | Wait until XHR/fetch traffic is quiet — essential for SPAs |
+| `inspect_page` | Discover all inputs, buttons, selects, links with best-fit CSS selectors |
+| `get_network_logs` | Captured XHR/fetch requests — method, URL, status, timing |
+| `mock_response` | Stub fetch/XHR by URL pattern with a canned response |
+| `clear_mock_responses` | Remove all active mock rules |
+| `compare_screenshot` | Pixel diff against a saved baseline — visual regression |
+| `check_accessibility` | Built-in WCAG audit — alt text, labels, headings, keyboard access |
 
 ### Elements
 | Tool | Description |
@@ -164,6 +171,7 @@ Claude controls the real browser, records every action, and on request generates
 | `switch_to_default_content` | Return to the main page from a frame |
 | `find_shadow_element` | Find element inside a shadow DOM |
 | `get_table_data` | Extract an HTML table as a formatted text grid |
+| `fill_form` | Fill multiple fields at once — auto-detects input/select/checkbox/radio |
 | `get_healed_locators` | View all self-healed selector mappings for the session |
 | `clear_healed_locators` | Reset the self-healing cache |
 

{seleniumboot_mcp-0.3.0 → seleniumboot_mcp-0.3.2}/README.md

@@ -3,7 +3,7 @@
 A Python **Model Context Protocol (MCP)** server for Selenium WebDriver automation.
 Let Claude or GitHub Copilot control a real browser — navigate pages, interact with elements,
 run assertions, and generate ready-to-run **Java TestNG / JUnit 5 / Cucumber / pytest** test code from recorded sessions.
-74 tools. No ChromeDriver setup. Browser auto-starts on first use.
+82 tools. No ChromeDriver setup. Browser auto-starts on first use.
 
 [![PyPI](https://img.shields.io/pypi/v/seleniumboot-mcp)](https://pypi.org/project/seleniumboot-mcp/)
 [![Python](https://img.shields.io/pypi/pyversions/seleniumboot-mcp)](https://pypi.org/project/seleniumboot-mcp/)
@@ -85,7 +85,7 @@ Claude controls the real browser, records every action, and on request generates
 
 ---
 
-## Tools (74 total)
+## Tools (82 total)
 
 ### Browser
 | Tool | Description |
@@ -113,6 +113,13 @@ Claude controls the real browser, records every action, and on request generates
 | `delete_cookie` / `delete_all_cookies` | Remove cookies |
 | `get_local_storage` / `set_local_storage` | Read or write localStorage |
 | `get_session_storage` / `set_session_storage` | Read or write sessionStorage |
+| `wait_for_network_idle` | Wait until XHR/fetch traffic is quiet — essential for SPAs |
+| `inspect_page` | Discover all inputs, buttons, selects, links with best-fit CSS selectors |
+| `get_network_logs` | Captured XHR/fetch requests — method, URL, status, timing |
+| `mock_response` | Stub fetch/XHR by URL pattern with a canned response |
+| `clear_mock_responses` | Remove all active mock rules |
+| `compare_screenshot` | Pixel diff against a saved baseline — visual regression |
+| `check_accessibility` | Built-in WCAG audit — alt text, labels, headings, keyboard access |
 
 ### Elements
 | Tool | Description |
@@ -142,6 +149,7 @@ Claude controls the real browser, records every action, and on request generates
 | `switch_to_default_content` | Return to the main page from a frame |
 | `find_shadow_element` | Find element inside a shadow DOM |
 | `get_table_data` | Extract an HTML table as a formatted text grid |
+| `fill_form` | Fill multiple fields at once — auto-detects input/select/checkbox/radio |
 | `get_healed_locators` | View all self-healed selector mappings for the session |
 | `clear_healed_locators` | Reset the self-healing cache |
 

{seleniumboot_mcp-0.3.0 → seleniumboot_mcp-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "seleniumboot-mcp"
-version = "0.3.0"
+version = "0.3.2"
 description = "A Python MCP server for Selenium WebDriver — 74 tools for browser automation, alerts, frames, shadow DOM, cookies, mobile emulation, self-healing locators, and codegen for Java/C#/Python/Playwright"
 readme = "README.md"
 requires-python = ">=3.10"

{seleniumboot_mcp-0.3.0 → seleniumboot_mcp-0.3.2}/src/selenium_mcp/tools/browser_tools.py

@@ -3,8 +3,12 @@ Browser Tools — start, stop, navigate, screenshot, window management,
 cookies, localStorage/sessionStorage, console logs, mobile emulation, page scroll
 """
 
+import asyncio
 import base64
+import io
 import json
+import os
+import time
 from selenium import webdriver
 from selenium.webdriver.chrome.options import Options as ChromeOptions
 from selenium.webdriver.firefox.options import Options as FirefoxOptions
@@ -37,7 +41,7 @@ class BrowserTools:
             opts = ChromeOptions()
             opts.add_argument("--no-sandbox")
             opts.add_argument("--disable-dev-shm-usage")
-            opts.set_capability("goog:loggingPrefs", {"browser": "ALL"})
+            opts.set_capability("goog:loggingPrefs", {"browser": "ALL", "performance": "ALL"})
             self.driver = webdriver.Chrome(options=opts)
             self.record("start_browser", browser="chrome", headless=False)
         return self.driver
@@ -282,6 +286,116 @@ class BrowserTools:
                     "required": ["key", "value"],
                 },
             ),
+            # ── Page inspection ──────────────────────────────────────── #
+            Tool(
+                name="inspect_page",
+                description=(
+                    "Discover all interactive elements on the current page — inputs, buttons, "
+                    "selects, checkboxes, textareas, and links — with their best CSS selectors and labels. "
+                    "Use this before writing locators so the AI knows exactly what's on the page."
+                ),
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            # ── Network interception ─────────────────────────────────── #
+            Tool(
+                name="get_network_logs",
+                description="Return captured XHR/fetch network requests (method, URL, status, timing). Chrome only.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "url_filter": {"type": "string", "description": "Only show requests whose URL contains this string"},
+                        "method":     {"type": "string", "description": "Filter by HTTP method e.g. GET, POST"},
+                        "limit":      {"type": "integer", "default": 50, "description": "Max requests to return"},
+                    },
+                },
+            ),
+            Tool(
+                name="mock_response",
+                description=(
+                    "Intercept fetch/XHR requests matching a URL pattern and return a canned response. "
+                    "Useful for testing without a real backend. Injection survives until the page is reloaded."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "url_pattern":   {"type": "string", "description": "Substring or regex pattern to match the request URL"},
+                        "status":        {"type": "integer", "default": 200},
+                        "body":          {"type": "string", "default": "{}", "description": "Response body string"},
+                        "content_type":  {"type": "string", "default": "application/json"},
+                    },
+                    "required": ["url_pattern"],
+                },
+            ),
+            Tool(
+                name="clear_mock_responses",
+                description="Remove all active mock response rules injected by mock_response.",
+                inputSchema={"type": "object", "properties": {}},
+            ),
+            # ── Visual regression ─────────────────────────────────────── #
+            Tool(
+                name="compare_screenshot",
+                description=(
+                    "Compare the current page screenshot against a saved baseline. "
+                    "On first run (or with update_baseline=true) saves the baseline. "
+                    "Returns the pixel diff percentage. Install Pillow for accurate pixel comparison."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "name":            {"type": "string", "default": "default", "description": "Baseline name e.g. 'homepage'"},
+                        "update_baseline": {"type": "boolean", "default": False},
+                        "threshold":       {"type": "number", "default": 0.1, "description": "Max allowed diff % before failure"},
+                    },
+                },
+            ),
+            # ── Accessibility ─────────────────────────────────────────── #
+            Tool(
+                name="check_accessibility",
+                description=(
+                    "Run a built-in accessibility audit on the current page. "
+                    "Checks for missing alt text, unlabelled inputs, empty buttons/links, "
+                    "missing page title, HTML lang, heading structure, and keyboard accessibility."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "level": {
+                            "type": "string",
+                            "enum": ["all", "critical", "serious", "moderate", "minor"],
+                            "default": "all",
+                        }
+                    },
+                },
+            ),
+            # ── Network idle ─────────────────────────────────────────── #
+            Tool(
+                name="wait_for_network_idle",
+                description=(
+                    "Wait until there are no active XHR/fetch requests for a quiet period. "
+                    "Essential for SPAs and pages that load data asynchronously. "
+                    "Also waits for document.readyState to be 'complete'."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "idle_time_ms": {
+                            "type": "integer",
+                            "default": 500,
+                            "description": "Milliseconds of network silence required",
+                        },
+                        "timeout": {
+                            "type": "integer",
+                            "default": 15,
+                            "description": "Max seconds to wait before giving up",
+                        },
+                        "max_inflight": {
+                            "type": "integer",
+                            "default": 0,
+                            "description": "Tolerate up to N in-flight requests (0 = fully idle)",
+                        },
+                    },
+                },
+            ),
         ]
 
     # ------------------------------------------------------------------ #
@@ -315,8 +429,15 @@ class BrowserTools:
             "delete_all_cookies":  self._delete_all_cookies,
             "get_local_storage":   self._get_local_storage,
             "set_local_storage":   self._set_local_storage,
-            "get_session_storage": self._get_session_storage,
-            "set_session_storage": self._set_session_storage,
+            "get_session_storage":    self._get_session_storage,
+            "set_session_storage":    self._set_session_storage,
+            "wait_for_network_idle":  self._wait_for_network_idle,
+            "inspect_page":           self._inspect_page,
+            "get_network_logs":       self._get_network_logs,
+            "mock_response":          self._mock_response,
+            "clear_mock_responses":   self._clear_mock_responses,
+            "compare_screenshot":     self._compare_screenshot,
+            "check_accessibility":    self._check_accessibility,
         }
 
     # ── Browser lifecycle ────────────────────────────────────────────── #
@@ -344,7 +465,7 @@ class BrowserTools:
             opts.add_argument(f"--window-size={w},{h}")
             opts.add_argument("--no-sandbox")
             opts.add_argument("--disable-dev-shm-usage")
-            opts.set_capability("goog:loggingPrefs", {"browser": "ALL"})
+            opts.set_capability("goog:loggingPrefs", {"browser": "ALL", "performance": "ALL"})
             self.driver = webdriver.Chrome(options=opts)
         elif browser == "firefox":
             opts = FirefoxOptions()
@@ -563,3 +684,379 @@ class BrowserTools:
         )
         self.record("set_session_storage", key=args["key"], value=args["value"])
         return f"✅ sessionStorage['{args['key']}'] = '{args['value']}'"
+
+    # ── Network idle ─────────────────────────────────────────────────── #
+
+    _INJECT_TRACKER = """
+    if (!window.__smcpNet) {
+        window.__smcpNet = { active: 0, last: Date.now() };
+        const _track = (d) => {
+            window.__smcpNet.active = Math.max(0, window.__smcpNet.active + d);
+            window.__smcpNet.last = Date.now();
+        };
+        const _xhrOpen = XMLHttpRequest.prototype.open;
+        XMLHttpRequest.prototype.open = function() {
+            _track(1);
+            this.addEventListener('loadend', () => _track(-1));
+            _xhrOpen.apply(this, arguments);
+        };
+        if (window.fetch) {
+            const _fetch = window.fetch;
+            window.fetch = function() {
+                _track(1);
+                return _fetch.apply(this, arguments).finally(() => _track(-1));
+            };
+        }
+    }
+    """
+
+    _POLL_TRACKER = """
+    const t = window.__smcpNet || { active: 0, last: Date.now() };
+    return { active: t.active, quietMs: Date.now() - t.last, readyState: document.readyState };
+    """
+
+    async def _wait_for_network_idle(self, args: dict) -> str:
+        idle_ms      = args.get("idle_time_ms", 500)
+        timeout      = args.get("timeout", 15)
+        max_inflight = args.get("max_inflight", 0)
+        driver = self.get_driver()
+
+        driver.execute_script(self._INJECT_TRACKER)
+
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            state     = driver.execute_script(self._POLL_TRACKER)
+            active    = state.get("active", 0)
+            quiet_ms  = state.get("quietMs", 0)
+            ready     = state.get("readyState", "")
+
+            if ready == "complete" and active <= max_inflight and quiet_ms >= idle_ms:
+                elapsed = round(time.monotonic() - (deadline - timeout), 2)
+                return (
+                    f"✅ Network idle — active={active}, "
+                    f"quiet for {quiet_ms}ms, readyState={ready} ({elapsed}s)"
+                )
+            await asyncio.sleep(0.1)
+
+        state = driver.execute_script(self._POLL_TRACKER)
+        return (
+            f"⚠️ Timed out after {timeout}s — "
+            f"active={state.get('active', '?')}, readyState={state.get('readyState', '?')}"
+        )
+
+    # ── Page inspection ──────────────────────────────────────────────── #
+
+    _INSPECT_SCRIPT = """
+    function bestSel(el) {
+        if (el.id) return '#' + CSS.escape(el.id);
+        if (el.name) return '[name="' + el.name + '"]';
+        const cls = (el.className || '').trim().split(/\\s+/)[0];
+        if (cls) return el.tagName.toLowerCase() + '.' + CSS.escape(cls);
+        return el.tagName.toLowerCase();
+    }
+    function labelFor(el) {
+        if (el.id) {
+            const l = document.querySelector('label[for="' + el.id + '"]');
+            if (l) return l.textContent.trim();
+        }
+        const p = el.closest('label');
+        if (p) return p.textContent.replace(el.value||'','').trim();
+        return el.getAttribute('placeholder') || el.getAttribute('aria-label') || el.name || '';
+    }
+    const r = {url: location.href, inputs:[], checkboxes:[], radios:[], textareas:[], selects:[], buttons:[], links:[]};
+    const vis = el => !!(el.offsetWidth || el.offsetHeight || el.getClientRects().length);
+
+    document.querySelectorAll('input:not([type="hidden"]):not([type="checkbox"]):not([type="radio"]):not([type="submit"]):not([type="button"]):not([type="image"]):not([type="reset"])').forEach(el => {
+        if (!vis(el)) return;
+        r.inputs.push({selector: bestSel(el), type: el.type||'text', label: labelFor(el)});
+    });
+    document.querySelectorAll('input[type="checkbox"]').forEach(el => {
+        r.checkboxes.push({selector: bestSel(el), label: labelFor(el), checked: el.checked});
+    });
+    document.querySelectorAll('input[type="radio"]').forEach(el => {
+        r.radios.push({selector: bestSel(el), label: labelFor(el), checked: el.checked, value: el.value});
+    });
+    document.querySelectorAll('textarea').forEach(el => {
+        if (!vis(el)) return;
+        r.textareas.push({selector: bestSel(el), label: labelFor(el)});
+    });
+    document.querySelectorAll('select').forEach(el => {
+        if (!vis(el)) return;
+        const opts = Array.from(el.options).map(o => o.text.trim()).filter(Boolean);
+        r.selects.push({selector: bestSel(el), label: labelFor(el), options: opts});
+    });
+    document.querySelectorAll('button,input[type="submit"],input[type="button"],input[type="reset"]').forEach(el => {
+        if (!vis(el)) return;
+        r.buttons.push({selector: bestSel(el), text: (el.textContent||el.value||'').trim(), type: el.type||'button'});
+    });
+    document.querySelectorAll('a[href]').forEach(el => {
+        if (!vis(el)) return;
+        const text = el.textContent.trim();
+        if (!text) return;
+        r.links.push({selector: bestSel(el), text: text.substring(0,60), href: el.getAttribute('href')});
+    });
+    return r;
+    """
+
+    async def _inspect_page(self, args: dict) -> str:
+        result = self.get_driver().execute_script(self._INSPECT_SCRIPT)
+        lines = [f"Page: {result['url']}", ""]
+
+        def section(title, items, fmt):
+            if not items:
+                return
+            lines.append(f"{title} ({len(items)}):")
+            for el in items:
+                lines.append("  " + fmt(el))
+
+        section("INPUTS", result["inputs"],
+                lambda e: f"[{e['type']}] {e['selector']}" + (f" — {e['label']}" if e["label"] else ""))
+        section("CHECKBOXES", result["checkboxes"],
+                lambda e: f"{e['selector']} — {e['label'] or 'unlabeled'} (checked={e['checked']})")
+        section("RADIOS", result["radios"],
+                lambda e: f"{e['selector']} value='{e['value']}'" + (" ✓" if e["checked"] else ""))
+        section("TEXTAREAS", result["textareas"],
+                lambda e: f"{e['selector']}" + (f" — {e['label']}" if e["label"] else ""))
+        section("SELECTS", result["selects"],
+                lambda e: f"{e['selector']} — {e['label'] or 'unlabeled'} → [{', '.join(e['options'][:6])}"
+                          + (f" +{len(e['options'])-6} more" if len(e['options']) > 6 else "") + "]")
+
+        if result["buttons"]:
+            lines.append(f"\nBUTTONS ({len(result['buttons'])}):")
+            for e in result["buttons"]:
+                lines.append(f"  [{e['type']}] {e['selector']} — '{e['text']}'")
+
+        if result["links"]:
+            shown = result["links"][:15]
+            lines.append(f"\nLINKS ({len(result['links'])}):")
+            for e in shown:
+                lines.append(f"  {e['selector']} — '{e['text']}' → {e['href']}")
+            if len(result["links"]) > 15:
+                lines.append(f"  … +{len(result['links'])-15} more")
+
+        total = sum(len(result[k]) for k in result if k != "url")
+        if total == 0:
+            return f"No interactive elements found on {result['url']}"
+        return "\n".join(lines)
+
+    # ── Network interception ─────────────────────────────────────────── #
+
+    async def _get_network_logs(self, args: dict) -> str:
+        url_filter    = args.get("url_filter", "")
+        method_filter = args.get("method", "").upper()
+        limit         = args.get("limit", 50)
+
+        try:
+            perf_logs = self.get_driver().get_log("performance")
+        except Exception as e:
+            return f"Could not get performance logs: {e}"
+
+        requests: dict = {}
+        for entry in perf_logs:
+            try:
+                msg    = json.loads(entry["message"])["message"]
+                method = msg.get("method", "")
+                params = msg.get("params", {})
+                rid    = params.get("requestId", "")
+
+                if method == "Network.requestWillBeSent":
+                    req = params.get("request", {})
+                    requests[rid] = {
+                        "url":    req.get("url", ""),
+                        "method": req.get("method", "GET"),
+                        "status": None,
+                        "ms":     None,
+                        "ts":     params.get("timestamp", 0),
+                    }
+                elif method == "Network.responseReceived" and rid in requests:
+                    resp = params.get("response", {})
+                    requests[rid]["status"] = resp.get("status")
+                    elapsed = params.get("timestamp", requests[rid]["ts"]) - requests[rid]["ts"]
+                    requests[rid]["ms"] = round(elapsed * 1000)
+            except Exception:
+                continue
+
+        entries = list(requests.values())
+        if url_filter:
+            entries = [e for e in entries if url_filter.lower() in e["url"].lower()]
+        if method_filter:
+            entries = [e for e in entries if e["method"] == method_filter]
+        entries = entries[-limit:]
+
+        if not entries:
+            return "No network requests captured." + ("" if perf_logs else " Performance logging requires Chrome.")
+
+        lines = [f"Network requests ({len(entries)}):"]
+        for e in entries:
+            status = str(e["status"]) if e["status"] else "---"
+            ms     = f"{e['ms']}ms" if e["ms"] is not None else "?"
+            url    = e["url"][:80] + ("…" if len(e["url"]) > 80 else "")
+            lines.append(f"  {e['method']:<6} {status}  {url}  ({ms})")
+        return "\n".join(lines)
+
+    _MOCK_INJECT = """
+    window.__smcpMocks = window.__smcpMocks || [];
+    window.__smcpMocks.push({pattern: arguments[0], status: arguments[1], body: arguments[2], ct: arguments[3]});
+    if (!window.__smcpMockOn) {
+        window.__smcpMockOn = true;
+        const _f = window.fetch;
+        window.fetch = function(url, opts) {
+            const u = typeof url === 'string' ? url : (url && url.url) || '';
+            for (const m of (window.__smcpMocks || [])) {
+                try { if (u.includes(m.pattern) || new RegExp(m.pattern).test(u))
+                    return Promise.resolve(new Response(m.body, {status: m.status, headers: {'Content-Type': m.ct}}));
+                } catch(e) {}
+            }
+            return _f.apply(this, arguments);
+        };
+    }
+    return window.__smcpMocks.length;
+    """
+
+    async def _mock_response(self, args: dict) -> str:
+        pattern = args["url_pattern"]
+        status  = args.get("status", 200)
+        body    = args.get("body", "{}")
+        ct      = args.get("content_type", "application/json")
+        count   = self.get_driver().execute_script(self._MOCK_INJECT, pattern, status, body, ct)
+        self.record("mock_response", url_pattern=pattern, status=status)
+        return f"✅ Mock added ({count} active): '{pattern}' → {status} {ct}"
+
+    async def _clear_mock_responses(self, args: dict) -> str:
+        self.get_driver().execute_script(
+            "window.__smcpMocks = []; window.__smcpMockOn = false;"
+        )
+        return "✅ All mock responses cleared"
+
+    # ── Visual regression ─────────────────────────────────────────────── #
+
+    async def _compare_screenshot(self, args: dict) -> str:
+        name      = args.get("name", "default").replace("/", "_")
+        update    = args.get("update_baseline", False)
+        threshold = args.get("threshold", 0.1)
+
+        baseline_dir = os.path.join(os.getcwd(), ".smcp_baselines")
+        os.makedirs(baseline_dir, exist_ok=True)
+        baseline_path = os.path.join(baseline_dir, f"{name}.png")
+
+        current = self.get_driver().get_screenshot_as_png()
+
+        if update or not os.path.exists(baseline_path):
+            with open(baseline_path, "wb") as f:
+                f.write(current)
+            return f"✅ Baseline saved: '{name}' ({len(current):,} bytes → {baseline_path})"
+
+        with open(baseline_path, "rb") as f:
+            baseline = f.read()
+
+        try:
+            from PIL import Image, ImageChops
+            img1 = Image.open(io.BytesIO(baseline)).convert("RGB")
+            img2 = Image.open(io.BytesIO(current)).convert("RGB")
+
+            if img1.size != img2.size:
+                return (f"⚠️ Size mismatch — baseline {img1.size} vs current {img2.size}. "
+                        f"Use update_baseline=true to reset.")
+
+            diff    = ImageChops.difference(img1, img2)
+            pixels  = list(diff.getdata())
+            changed = sum(1 for p in pixels if any(c > 10 for c in p))
+            pct     = round(100.0 * changed / len(pixels), 3)
+
+            if pct <= threshold:
+                return f"✅ Match ({pct:.3f}% diff ≤ {threshold}% threshold) — '{name}'"
+            return f"❌ Diff detected ({pct:.3f}% > {threshold}% threshold) — '{name}'"
+
+        except ImportError:
+            if current == baseline:
+                return f"✅ Identical (byte match) — '{name}' (install Pillow for pixel diff)"
+            diff  = sum(a != b for a, b in zip(current, baseline))
+            pct   = round(100.0 * diff / max(len(current), len(baseline)), 2)
+            verdict = "✅" if pct <= threshold else "⚠️"
+            return (f"{verdict} {pct:.2f}% byte diff — '{name}' "
+                    f"(install Pillow for accurate pixel comparison: pip install Pillow)")
+
+    # ── Accessibility audit ───────────────────────────────────────────── #
+
+    _A11Y_SCRIPT = """
+    const issues = [];
+    const $ = s => Array.from(document.querySelectorAll(s));
+    const el2str = el => el.outerHTML.substring(0, 100).replace(/\\n/g, ' ');
+
+    if (!document.title || !document.title.trim())
+        issues.push({impact:'serious', id:'document-title', desc:'Page must have a title', el:'<title>'});
+
+    if (!document.documentElement.lang)
+        issues.push({impact:'serious', id:'html-has-lang', desc:'<html> must have a lang attribute', el:'<html>'});
+
+    $('img').forEach(el => {
+        if (!el.hasAttribute('alt'))
+            issues.push({impact:'critical', id:'image-alt', desc:'Images must have alt text', el:el2str(el)});
+    });
+
+    $('input:not([type=hidden]):not([type=submit]):not([type=button]):not([type=image]):not([type=reset])').forEach(el => {
+        const hasLabel = el.id && document.querySelector('label[for="'+el.id+'"]');
+        if (!hasLabel && !el.getAttribute('aria-label') && !el.getAttribute('aria-labelledby') && !el.getAttribute('title'))
+            issues.push({impact:'serious', id:'label', desc:'Form inputs must have a label', el:el2str(el)});
+    });
+
+    $('button').forEach(el => {
+        if (!el.textContent.trim() && !el.getAttribute('aria-label') && !el.getAttribute('title'))
+            issues.push({impact:'serious', id:'button-name', desc:'Buttons must have accessible names', el:el2str(el)});
+    });
+
+    $('a').forEach(el => {
+        if (!el.textContent.trim() && !el.getAttribute('aria-label') && !el.querySelector('img[alt]'))
+            issues.push({impact:'serious', id:'link-name', desc:'Links must have accessible names', el:el2str(el)});
+    });
+
+    const h1s = $('h1');
+    if (!h1s.length)
+        issues.push({impact:'moderate', id:'page-has-h1', desc:'Page should have an <h1>', el:'<body>'});
+    else if (h1s.length > 1)
+        issues.push({impact:'moderate', id:'multiple-h1', desc:'Page should not have more than one <h1>', el:'<body>'});
+
+    $('[onclick]:not(a):not(button):not(input):not(select):not(textarea)').forEach(el => {
+        if (!el.getAttribute('tabindex') && !el.getAttribute('role'))
+            issues.push({impact:'serious', id:'keyboard', desc:'onClick elements need tabindex and role for keyboard access', el:el2str(el)});
+    });
+
+    $('input[type=password]').forEach(el => {
+        if (!el.getAttribute('autocomplete'))
+            issues.push({impact:'minor', id:'autocomplete', desc:'Password inputs should have autocomplete attribute', el:el2str(el)});
+    });
+
+    return {url: location.href, issues};
+    """
+
+    _IMPACT_ORDER = {"critical": 0, "serious": 1, "moderate": 2, "minor": 3}
+
+    async def _check_accessibility(self, args: dict) -> str:
+        level  = args.get("level", "all")
+        result = self.get_driver().execute_script(self._A11Y_SCRIPT)
+        issues = result.get("issues", [])
+
+        if level != "all":
+            issues = [i for i in issues if i["impact"] == level]
+
+        issues.sort(key=lambda i: self._IMPACT_ORDER.get(i["impact"], 4))
+
+        if not issues:
+            return f"✅ No accessibility issues found on {result['url']}"
+
+        counts: dict = {}
+        for i in issues:
+            counts[i["impact"]] = counts.get(i["impact"], 0) + 1
+        summary = ", ".join(
+            f"{v} {k}" for k, v in sorted(counts.items(), key=lambda x: self._IMPACT_ORDER.get(x[0], 4))
+        )
+
+        lines = [
+            f"Accessibility audit: {len(issues)} issue(s) — {summary}",
+            f"Page: {result['url']}",
+            "",
+        ]
+        for i in issues:
+            lines.append(f"[{i['impact']}] {i['id']}: {i['desc']}")
+            lines.append(f"  {i['el']}")
+        return "\n".join(lines)

{seleniumboot_mcp-0.3.0 → seleniumboot_mcp-0.3.2}/src/selenium_mcp/tools/element_tools.py

@@ -358,6 +358,28 @@ class ElementTools:
                     "required": ["selector"],
                 },
             ),
+            Tool(
+                name="fill_form",
+                description=(
+                    "Fill multiple form fields in a single call. Pass a map of CSS selector → value. "
+                    "Automatically handles text inputs, textareas, checkboxes (true/false), "
+                    "radio buttons, and <select> dropdowns. Optionally clicks a submit button at the end."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "fields": {
+                            "type": "object",
+                            "description": "Map of selector → value. Checkboxes: 'true'/'false'. Selects: visible text or value.",
+                            "additionalProperties": {"type": "string"},
+                        },
+                        "by":      {"type": "string", "default": "css"},
+                        "timeout": {"type": "integer", "default": 10},
+                        "submit":  {"type": "string", "description": "Selector of submit button to click after filling (optional)"},
+                    },
+                    "required": ["fields"],
+                },
+            ),
             Tool(
                 name="get_healed_locators",
                 description="Return all self-healed locator mappings from this session. Shows which selectors were automatically repaired and what they were replaced with.",
@@ -501,6 +523,7 @@ class ElementTools:
             "wait_for_element":     self._wait_for_element,
             "scroll_to_element":    self._scroll_to_element,
             "clear_field":          self._clear_field,
+            "fill_form":                self._fill_form,
             "get_healed_locators":      self._get_healed_locators,
             "clear_healed_locators":    self._clear_healed_locators,
             "accept_alert":             self._accept_alert,
@@ -636,6 +659,84 @@ class ElementTools:
         el.clear()
         return f"✅ Cleared '{args['selector']}'{self._heal_note()}"
 
+    # ------------------------------------------------------------------ #
+    #  fill_form handler                                                   #
+    # ------------------------------------------------------------------ #
+
+    def _fill_one(self, el, selector: str, value: str, by: str) -> str:
+        """Fill a single element; return a short summary line."""
+        tag = el.tag_name.lower()
+        input_type = (el.get_attribute("type") or "text").lower()
+
+        if tag == "select":
+            sel_obj = Select(el)
+            try:
+                sel_obj.select_by_visible_text(value)
+                self.browser.record("select_option", selector=selector, by=by, by_text=value)
+            except Exception:
+                sel_obj.select_by_value(value)
+                self.browser.record("select_option", selector=selector, by=by, by_value=value)
+            return f"  select  {selector!r} → '{value}'"
+
+        elif input_type == "checkbox":
+            want = value.strip().lower() in ("true", "1", "yes", "on", "checked")
+            if el.is_selected() != want:
+                el.click()
+                self.browser.record("click", selector=selector, by=by)
+            state = "checked" if want else "unchecked"
+            return f"  checkbox {selector!r} → {state}"
+
+        elif input_type == "radio":
+            if not el.is_selected():
+                el.click()
+                self.browser.record("click", selector=selector, by=by)
+            return f"  radio   {selector!r} → selected"
+
+        elif input_type == "file":
+            el.send_keys(value)
+            self.browser.record("upload_file", selector=selector, by=by, file_path=value)
+            return f"  file    {selector!r} → '{value}'"
+
+        else:
+            el.clear()
+            el.send_keys(value)
+            sel_lower = selector.lower()
+            logged = "***" if any(k in sel_lower for k in ("password", "passwd", "pwd")) else value
+            self.browser.record("type_text", selector=selector, by=by, text=logged)
+            return f"  input   {selector!r} → '{logged}'"
+
+    async def _fill_form(self, args: dict) -> str:
+        fields: dict = args.get("fields", {})
+        by = args.get("by", "css")
+        timeout = args.get("timeout", 10)
+        submit_sel = args.get("submit", "")
+
+        if not fields:
+            return "❌ No fields provided."
+
+        results = []
+        errors  = []
+        for selector, value in fields.items():
+            try:
+                el = self._find(selector, by, timeout)
+                results.append(self._fill_one(el, selector, value, by))
+            except Exception as e:
+                errors.append(f"  ❌ {selector!r}: {e}")
+
+        if submit_sel:
+            try:
+                self._find_clickable(submit_sel, by, timeout).click()
+                self.browser.record("click", selector=submit_sel, by=by)
+                results.append(f"  submit  {submit_sel!r} → clicked")
+            except Exception as e:
+                errors.append(f"  ❌ submit {submit_sel!r}: {e}")
+
+        summary = f"✅ Filled {len(results)} field(s)"
+        if errors:
+            summary += f", {len(errors)} error(s)"
+        lines = [summary] + results + errors
+        return "\n".join(lines)
+
     async def _get_healed_locators(self, args: dict) -> str:
         cache = self.browser._healer_cache
         if not cache:

{seleniumboot_mcp-0.3.0 → seleniumboot_mcp-0.3.2}/src/seleniumboot_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: seleniumboot-mcp
-Version: 0.3.0
+Version: 0.3.2
 Summary: A Python MCP server for Selenium WebDriver — 74 tools for browser automation, alerts, frames, shadow DOM, cookies, mobile emulation, self-healing locators, and codegen for Java/C#/Python/Playwright
 Author-email: Raza Tech <razatechnologyservices@gmail.com>
 License: MIT
@@ -25,7 +25,7 @@ Requires-Dist: selenium>=4.6.0
 A Python **Model Context Protocol (MCP)** server for Selenium WebDriver automation.
 Let Claude or GitHub Copilot control a real browser — navigate pages, interact with elements,
 run assertions, and generate ready-to-run **Java TestNG / JUnit 5 / Cucumber / pytest** test code from recorded sessions.
-74 tools. No ChromeDriver setup. Browser auto-starts on first use.
+82 tools. No ChromeDriver setup. Browser auto-starts on first use.
 
 [![PyPI](https://img.shields.io/pypi/v/seleniumboot-mcp)](https://pypi.org/project/seleniumboot-mcp/)
 [![Python](https://img.shields.io/pypi/pyversions/seleniumboot-mcp)](https://pypi.org/project/seleniumboot-mcp/)
@@ -107,7 +107,7 @@ Claude controls the real browser, records every action, and on request generates
 
 ---
 
-## Tools (74 total)
+## Tools (82 total)
 
 ### Browser
 | Tool | Description |
@@ -135,6 +135,13 @@ Claude controls the real browser, records every action, and on request generates
 | `delete_cookie` / `delete_all_cookies` | Remove cookies |
 | `get_local_storage` / `set_local_storage` | Read or write localStorage |
 | `get_session_storage` / `set_session_storage` | Read or write sessionStorage |
+| `wait_for_network_idle` | Wait until XHR/fetch traffic is quiet — essential for SPAs |
+| `inspect_page` | Discover all inputs, buttons, selects, links with best-fit CSS selectors |
+| `get_network_logs` | Captured XHR/fetch requests — method, URL, status, timing |
+| `mock_response` | Stub fetch/XHR by URL pattern with a canned response |
+| `clear_mock_responses` | Remove all active mock rules |
+| `compare_screenshot` | Pixel diff against a saved baseline — visual regression |
+| `check_accessibility` | Built-in WCAG audit — alt text, labels, headings, keyboard access |
 
 ### Elements
 | Tool | Description |
@@ -164,6 +171,7 @@ Claude controls the real browser, records every action, and on request generates
 | `switch_to_default_content` | Return to the main page from a frame |
 | `find_shadow_element` | Find element inside a shadow DOM |
 | `get_table_data` | Extract an HTML table as a formatted text grid |
+| `fill_form` | Fill multiple fields at once — auto-detects input/select/checkbox/radio |
 | `get_healed_locators` | View all self-healed selector mappings for the session |
 | `clear_healed_locators` | Reset the self-healing cache |