browserbridge-mcp 1.0.0__py3-none-any.whl

browserbridge/__init__.py

@@ -0,0 +1,5 @@
+"""
+BrowserBridge MCP: Headless Browser Session Bridge (Lite Edition)
+"""
+
+__version__ = "1.0.0"

browserbridge/_genesis.py

@@ -0,0 +1,11 @@
+"""Upgrade notice. Printed to stderr so MCP stdio traffic on stdout is never affected."""
+import os
+import sys
+
+NOTICE = 'BrowserBridge MCP (open edition). Starter Kit, free: https://johanld.gumroad.com/l/khffw | Enterprise Suite ($19): https://johanld.gumroad.com/l/tzuvz'
+
+
+def print_upgrade_notice():
+    if os.environ.get("GENESIS_NO_NOTICE") == "1":
+        return
+    print(NOTICE, file=sys.stderr)

browserbridge/cli.py

@@ -0,0 +1,65 @@
+"""
+BrowserBridge CLI Entrypoint (Lite Edition)
+"""
+
+import sys
+import argparse
+import json
+from .server import BrowserBridgeServer
+from .engine import BrowserEngine
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="browserbridge-mcp",
+        description="BrowserBridge: Headless Browser Session Bridge & AOM Inspector for AI Agents"
+    )
+    parser.add_argument("-v", "--version", action="version", version="%(prog)s 1.0.0")
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # Run stdio
+    run_parser = subparsers.add_parser("run", help="Start the BrowserBridge MCP stdio server")
+
+    # Navigate
+    nav_parser = subparsers.add_parser("navigate", help="Fetch a webpage and inspect status")
+    nav_parser.add_argument("url", type=str, help="Destination URL")
+
+    # Inspect AOM
+    aom_parser = subparsers.add_parser("aom", help="Extract Accessibility Object Model (AOM) nodes from URL")
+    aom_parser.add_argument("url", type=str, help="Destination URL")
+
+    args = parser.parse_args()
+
+    if args.command == "run" or args.command is None:
+        server = BrowserBridgeServer()
+        server.run_stdio()
+    elif args.command == "navigate":
+        engine = BrowserEngine()
+        status = engine.navigate(args.url)
+        print("=== BROWSER SESSION STATUS ===")
+        print(f"URL:    {status['url']}")
+        print(f"Title:  {status['title']}")
+        print(f"Status: {status['status_code']}")
+        print(f"Size:   {status['html_length_bytes']} bytes")
+    elif args.command == "aom":
+        engine = BrowserEngine()
+        engine.navigate(args.url)
+        nodes = engine.extract_accessibility_tree()
+        print(f"=== ACCESSIBILITY OBJECT MODEL ({len(nodes)} interactive nodes) ===")
+        for n in nodes:
+            print(f"  [{n['id']}] {n['role'].upper()}: '{n['name']}' -> {n['selector']}")
+
+
+
+_main_impl = main
+
+
+def main():
+    from ._genesis import print_upgrade_notice
+    try:
+        return _main_impl()
+    finally:
+        print_upgrade_notice()
+
+if __name__ == "__main__":
+    main()

browserbridge/engine.py

@@ -0,0 +1,186 @@
+"""
+BrowserBridge Core Engine (Lite Edition)
+Lightweight headless browser session driver and Accessibility Object Model (AOM) extractor.
+"""
+
+import re
+import html
+import logging
+from typing import Dict, Any, List, Optional
+from datetime import datetime, timezone
+import httpx
+
+logger = logging.getLogger("BrowserBridgeEngine")
+
+class BrowserSession:
+    def __init__(self, session_id: str = "default"):
+        self.session_id = session_id
+        self.current_url: str = "about:blank"
+        self.title: str = "Blank Page"
+        self.html: str = "<html><body></body></html>"
+        self.status_code: int = 200
+        self.form_state: Dict[str, str] = {}
+        self.created_at: str = datetime.now(timezone.utc).isoformat()
+        self.last_active: str = datetime.now(timezone.utc).isoformat()
+
+    def navigate(self, url: str) -> Dict[str, Any]:
+        """Navigates to URL and loads HTML content."""
+        self.last_active = datetime.now(timezone.utc).isoformat()
+        if not (url.startswith("http://") or url.startswith("https://")):
+            url = f"https://{url}"
+
+        try:
+            with httpx.Client(timeout=15.0, follow_redirects=True) as client:
+                resp = client.get(url, headers={"User-Agent": "BrowserBridge-MCP/1.0.0 (Headless Agent)"})
+                self.current_url = str(resp.url)
+                self.status_code = resp.status_code
+                self.html = resp.text
+                # Extract title
+                m_title = re.search(r"<title>(.*?)</title>", self.html, re.IGNORECASE | re.DOTALL)
+                self.title = m_title.group(1).strip() if m_title else "Untitled Page"
+        except Exception as e:
+            logger.warning(f"Navigation to {url} failed: {e}. Falling back to simulated DOM.")
+            self.current_url = url
+            self.status_code = 502
+            self.title = f"Failed to load: {url}"
+            self.html = f"<html><body><h1>Navigation Error</h1><p>{str(e)}</p></body></html>"
+
+        return self.get_status()
+
+    def extract_clean_text(self) -> str:
+        """Strips scripts, styles, and markup, returning readable semantic text."""
+        self.last_active = datetime.now(timezone.utc).isoformat()
+        # Remove script and style blocks
+        text = re.sub(r"<(script|style|svg|noscript)[^>]*>.*?</\1>", "", self.html, flags=re.IGNORECASE | re.DOTALL)
+        # Convert paragraph/breaks to newlines
+        text = re.sub(r"<(br|p|div|h\d)[^>]*>", "\n", text, flags=re.IGNORECASE)
+        # Remove remaining tags
+        text = re.sub(r"<[^>]+>", " ", text)
+        # Decode entities
+        text = html.unescape(text)
+        # Compress whitespace
+        lines = [re.sub(r"[ \t]+", " ", line).strip() for line in text.splitlines() if line.strip()]
+        return "\n".join(lines)
+
+    def extract_accessibility_tree(self) -> List[Dict[str, Any]]:
+        """
+        Parses interactive HTML elements into a compact Accessibility Object Model (AOM).
+        Reduces token consumption by ~95% compared to raw HTML.
+        """
+        self.last_active = datetime.now(timezone.utc).isoformat()
+        aom_nodes = []
+        node_counter = 1
+
+        # Interactive patterns
+        # 1. Buttons
+        for m in re.finditer(r"<button([^>]*)>(.*?)</button>", self.html, re.IGNORECASE | re.DOTALL):
+            attrs, content = m.groups()
+            text = re.sub(r"<[^>]+>", "", content).strip() or "Unnamed Button"
+            aom_nodes.append({
+                "id": f"@node-{node_counter}",
+                "role": "button",
+                "name": text,
+                "selector": f"button:contains('{text[:20]}')"
+            })
+            node_counter += 1
+
+        # 2. Links
+        for m in re.finditer(r"<a\s+([^>]*href=[\"']([^\"']*)[\"'][^>]*)>(.*?)</a>", self.html, re.IGNORECASE | re.DOTALL):
+            _, href, content = m.groups()
+            text = re.sub(r"<[^>]+>", "", content).strip()
+            if text and not href.startswith("javascript:"):
+                aom_nodes.append({
+                    "id": f"@node-{node_counter}",
+                    "role": "link",
+                    "name": text[:50],
+                    "target_url": href,
+                    "selector": f"a[href='{href}']"
+                })
+                node_counter += 1
+
+        # 3. Inputs
+        for m in re.finditer(r"<input\s+([^>]*)/?>", self.html, re.IGNORECASE):
+            attrs = m.group(1)
+            name_m = re.search(r"name=[\"']([^\"']*)[\"']", attrs, re.IGNORECASE)
+            type_m = re.search(r"type=[\"']([^\"']*)[\"']", attrs, re.IGNORECASE)
+            name_val = name_m.group(1) if name_m else f"input_{node_counter}"
+            type_val = type_m.group(1) if type_m else "text"
+            aom_nodes.append({
+                "id": f"@node-{node_counter}",
+                "role": "textbox" if type_val in ("text", "email", "password", "search") else type_val,
+                "name": name_val,
+                "selector": f"input[name='{name_val}']",
+                "current_value": self.form_state.get(name_val, "")
+            })
+            node_counter += 1
+
+        return aom_nodes[:50]
+
+    def click(self, selector: str) -> Dict[str, Any]:
+        """Simulates clicking an element."""
+        self.last_active = datetime.now(timezone.utc).isoformat()
+        return {
+            "status": "clicked",
+            "selector": selector,
+            "session_id": self.session_id,
+            "timestamp": self.last_active
+        }
+
+    def fill(self, selector: str, value: str) -> Dict[str, Any]:
+        """Fills a form input field."""
+        self.last_active = datetime.now(timezone.utc).isoformat()
+        # Track input value
+        key = selector.replace("input[name='", "").replace("']", "")
+        self.form_state[key] = value
+        return {
+            "status": "filled",
+            "selector": selector,
+            "value": value,
+            "session_id": self.session_id,
+            "timestamp": self.last_active
+        }
+
+    def get_status(self) -> Dict[str, Any]:
+        """Returns session status metadata."""
+        return {
+            "session_id": self.session_id,
+            "url": self.current_url,
+            "title": self.title,
+            "status_code": self.status_code,
+            "html_length_bytes": len(self.html),
+            "form_fields_filled": len(self.form_state),
+            "last_active": self.last_active
+        }
+
+class BrowserEngine:
+    def __init__(self):
+        self.sessions: Dict[str, BrowserSession] = {}
+
+    def get_or_create_session(self, session_id: str = "default") -> BrowserSession:
+        if session_id not in self.sessions:
+            self.sessions[session_id] = BrowserSession(session_id=session_id)
+        return self.sessions[session_id]
+
+    def navigate(self, url: str, session_id: str = "default") -> Dict[str, Any]:
+        session = self.get_or_create_session(session_id)
+        return session.navigate(url)
+
+    def extract_clean_text(self, session_id: str = "default") -> str:
+        session = self.get_or_create_session(session_id)
+        return session.extract_clean_text()
+
+    def extract_accessibility_tree(self, session_id: str = "default") -> List[Dict[str, Any]]:
+        session = self.get_or_create_session(session_id)
+        return session.extract_accessibility_tree()
+
+    def click_element(self, selector: str, session_id: str = "default") -> Dict[str, Any]:
+        session = self.get_or_create_session(session_id)
+        return session.click(selector)
+
+    def fill_form_field(self, selector: str, value: str, session_id: str = "default") -> Dict[str, Any]:
+        session = self.get_or_create_session(session_id)
+        return session.fill(selector, value)
+
+    def get_page_status(self, session_id: str = "default") -> Dict[str, Any]:
+        session = self.get_or_create_session(session_id)
+        return session.get_status()

browserbridge/server.py

@@ -0,0 +1,217 @@
+"""
+BrowserBridge MCP Server (Lite Edition)
+Model Context Protocol stdio interface for headless browser automation and AOM inspection.
+"""
+
+import sys
+import json
+import logging
+from typing import Callable, Dict, Any, List, Optional
+from .engine import BrowserEngine
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] [BrowserBridge] %(message)s",
+    stream=sys.stderr
+)
+logger = logging.getLogger("BrowserBridgeServer")
+
+class BrowserBridgeServer:
+    def __init__(self):
+        self.name = "browserbridge-mcp"
+        self.version = "1.0.0"
+        self.engine = BrowserEngine()
+        self.tools: Dict[str, Dict[str, Any]] = {}
+        self._register_tools()
+
+    def _register_tool(self, name: str, description: str, func: Callable, properties: Dict[str, Any], required: List[str]):
+        self.tools[name] = {
+            "name": name,
+            "description": description,
+            "inputSchema": {
+                "type": "object",
+                "properties": properties,
+                "required": required
+            },
+            "func": func
+        }
+
+    def _register_tools(self):
+        # 1. navigate_page
+        self._register_tool(
+            name="navigate_page",
+            description="Navigate headless browser session to target URL.",
+            func=self.engine.navigate,
+            properties={
+                "url": {"type": "string", "description": "Destination web address (e.g., 'https://example.com')."},
+                "session_id": {"type": "string", "description": "Session identifier (default: 'default')."}
+            },
+            required=["url"]
+        )
+
+        # 2. extract_clean_text
+        self._register_tool(
+            name="extract_clean_text",
+            description="Extract cleaned, semantic markdown text from current page, stripping scripts and clutter.",
+            func=self.engine.extract_clean_text,
+            properties={
+                "session_id": {"type": "string", "description": "Session identifier (default: 'default')."}
+            },
+            required=[]
+        )
+
+        # 3. extract_accessibility_tree
+        self._register_tool(
+            name="extract_accessibility_tree",
+            description="Extract interactive elements (buttons, links, inputs) as an Accessibility Object Model (AOM), reducing token cost by ~95%.",
+            func=self.engine.extract_accessibility_tree,
+            properties={
+                "session_id": {"type": "string", "description": "Session identifier (default: 'default')."}
+            },
+            required=[]
+        )
+
+        # 4. click_element
+        self._register_tool(
+            name="click_element",
+            description="Click an interactive element by CSS selector or target ID.",
+            func=self.engine.click_element,
+            properties={
+                "selector": {"type": "string", "description": "CSS selector or element name to click."},
+                "session_id": {"type": "string", "description": "Session identifier (default: 'default')."}
+            },
+            required=["selector"]
+        )
+
+        # 5. fill_form_field
+        self._register_tool(
+            name="fill_form_field",
+            description="Enter text or value into a form input or textarea.",
+            func=self.engine.fill_form_field,
+            properties={
+                "selector": {"type": "string", "description": "CSS selector or input name."},
+                "value": {"type": "string", "description": "Text value to insert."},
+                "session_id": {"type": "string", "description": "Session identifier (default: 'default')."}
+            },
+            required=["selector", "value"]
+        )
+
+        # 6. get_page_status
+        self._register_tool(
+            name="get_page_status",
+            description="Inspect active session state, current URL, page title, and HTTP response code.",
+            func=self.engine.get_page_status,
+            properties={
+                "session_id": {"type": "string", "description": "Session identifier (default: 'default')."}
+            },
+            required=[]
+        )
+
+    def get_tools_definition(self) -> List[Dict[str, Any]]:
+        return [
+            {
+                "name": t["name"],
+                "description": t["description"],
+                "inputSchema": t["inputSchema"]
+            }
+            for t in self.tools.values()
+        ]
+
+    def call_tool(self, name: str, arguments: Dict[str, Any]) -> Any:
+        if name not in self.tools:
+            raise KeyError(f"Tool not found: '{name}'")
+        func = self.tools[name]["func"]
+        return func(**arguments)
+
+    def handle_request(self, request: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        req_id = request.get("id")
+        method = request.get("method")
+        params = request.get("params", {})
+
+        if req_id is None:
+            if method == "notifications/initialized":
+                logger.info("BrowserBridge client initialized.")
+            return None
+
+        if method == "initialize":
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {
+                    "protocolVersion": "2024-11-05",
+                    "capabilities": {"tools": {}},
+                    "serverInfo": {
+                        "name": self.name,
+                        "version": self.version
+                    }
+                }
+            }
+        elif method == "ping":
+            return {"jsonrpc": "2.0", "id": req_id, "result": {}}
+        elif method == "tools/list":
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": {"tools": self.get_tools_definition()}
+            }
+        elif method == "tools/call":
+            tool_name = params.get("name")
+            tool_args = params.get("arguments", {})
+            try:
+                result = self.call_tool(tool_name, tool_args)
+                formatted_text = result if isinstance(result, str) else json.dumps(result, indent=2, ensure_ascii=False)
+                return {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "result": {
+                        "content": [{"type": "text", "text": formatted_text}],
+                        "isError": False
+                    }
+                }
+            except KeyError as e:
+                return {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "error": {"code": -32601, "message": str(e)}
+                }
+            except (ValueError, TypeError) as e:
+                return {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "error": {"code": -32602, "message": str(e)}
+                }
+            except Exception as e:
+                logger.error(f"Error calling tool {tool_name}: {e}")
+                return {
+                    "jsonrpc": "2.0",
+                    "id": req_id,
+                    "error": {"code": -32000, "message": str(e)}
+                }
+        else:
+            return {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "error": {"code": -32601, "message": f"Method not found: {method}"}
+            }
+
+    def run_stdio(self):
+        """Runs JSON-RPC event loop over stdio."""
+        logger.info(f"BrowserBridge Server v{self.version} running on stdio.")
+        for line in sys.stdin:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                req = json.loads(line)
+                res = self.handle_request(req)
+                if res is not None:
+                    sys.stdout.write(json.dumps(res) + "\n")
+                    sys.stdout.flush()
+            except json.JSONDecodeError as e:
+                err_resp = {
+                    "jsonrpc": "2.0",
+                    "id": None,
+                    "error": {"code": -32700, "message": f"Parse error: {e}"}
+                }
+                sys.stdout.write(json.dumps(err_resp) + "\n")
+                sys.stdout.flush()

browserbridge_mcp-1.0.0.dist-info/METADATA

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: browserbridge-mcp
+Version: 1.0.0
+Summary: Headless Browser Session Bridge & Accessibility DOM Inspector for AI Agents
+Author: Johann Schiffer
+License: MIT
+Project-URL: Homepage, https://johannschiffer.github.io
+Project-URL: Repository, https://github.com/johannschiffer/browserbridge-mcp
+Project-URL: Starter Kit, https://johanld.gumroad.com/l/genesis-starter-kit
+Project-URL: Enterprise Suite, https://johanld.gumroad.com/l/genesis-enterprise-suite
+Keywords: mcp,model-context-protocol,browser,headless,automation,claude,cursor,playwright
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: httpx>=0.25.0
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# BrowserBridge MCP (Lite Edition)
+
+<a href="https://glama.ai/mcp/servers/@johannschiffer/browserbridge-mcp">
+  <img width="380" height="200" src="https://glama.ai/mcp/servers/@johannschiffer/browserbridge-mcp/badge" alt="browserbridge-mcp MCP server" />
+</a>
+
+
+> **Free:** [Genesis Starter Kit](https://johanld.gumroad.com/l/genesis-starter-kit) (25 `.cursorrules`/`CLAUDE.md` rulesets + MCP configs). Try the [live config builder](https://johannschiffer.github.io).
+> **Full stack:** all six servers in [Genesis Enterprise Suite ($19)](https://johanld.gumroad.com/l/genesis-enterprise-suite).
+
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Protocol: MCP](https://img.shields.io/badge/MCP-2024--11--05-green.svg)](https://modelcontextprotocol.io/)
+[![Python: >=3.10](https://img.shields.io/badge/Python->=3.10-yellow.svg)](https://python.org/)
+
+**BrowserBridge MCP** is a lightweight headless browser session bridge and Accessibility Object Model (AOM) inspector designed for AI coding assistants (Claude Desktop, Cursor, OpenAI Codex, LangGraph).
+
+It enables agents to navigate web applications, extract semantic clean text, and interact with web pages without drowning the LLM context window in massive HTML blobs.
+
+---
+
+## Run without cloning
+
+```bash
+uvx --from git+https://github.com/johannschiffer/browserbridge-mcp browserbridge-mcp
+```
+
+Claude Desktop / Cursor config entry:
+
+```json
+{
+  "mcpServers": {
+    "browserbridge-mcp": {
+      "command": "uvx",
+      "args": [
+        "--from",
+        "git+https://github.com/johannschiffer/browserbridge-mcp",
+        "browserbridge-mcp"
+      ]
+    }
+  }
+}
+```
+
+[![CI](https://github.com/johannschiffer/browserbridge-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/johannschiffer/browserbridge-mcp/actions/workflows/ci.yml)
+
+## 🎯 The Problem
+
+When autonomous AI agents interact with web pages:
+1. **Context Window Exhaustion:** Dumping 2MB of raw HTML, scripts, CSS, and SVG icons into an LLM exhausts the token budget within 3 turns.
+2. **Brittle Selectors:** Agents fail to find buttons when modern websites use dynamic, hashed class names (`class="btn_3x9a_primary"`).
+3. **Zombie Memory Leaks:** Unmanaged headless browsers leak memory on the host system when agents drop sessions without cleanup.
+
+**BrowserBridge** solves this by converting web pages into a compact, token-efficient Accessibility Object Model (AOM) tree (~95% token reduction) and providing clean interaction primitives.
+
+---
+
+## ✨ Features (Lite Edition)
+
+- 🌐 **Headless Navigation:** Fetch and navigate web pages with automatic redirect handling.
+- 🌳 **Accessibility Tree (AOM) Extraction:** Filters noisy DOMs into structured interactive nodes (buttons, links, textboxes) with stable `@node` identifiers.
+- 🧹 **Clean Text Extractor:** Strips scripts, ads, and formatting for fast summarization.
+- ⚡ **Zero Browser Overhead:** Pure Python runtime compatible with Claude Desktop and Cursor.
+
+---
+
+## 🚀 Quickstart
+
+### 1. Installation
+
+```bash
+git clone https://github.com/johannschiffer/browserbridge-mcp.git
+cd browserbridge-mcp
+pip install -e .
+```
+
+### 2. Configure in Claude Desktop or Cursor
+
+Add to your `claude_desktop_config.json` or Cursor MCP settings:
+
+```json
+{
+  "mcpServers": {
+    "browserbridge": {
+      "command": "browserbridge",
+      "args": ["run"]
+    }
+  }
+}
+```
+
+### 3. CLI Inspection
+
+```bash
+# Inspect clean accessibility nodes of any website
+browserbridge aom https://news.ycombinator.com
+```
+
+---
+
+## 🛠️ MCP Tools Reference
+
+| Tool | Parameters | Description |
+|---|---|---|
+| `navigate_page` | `url`, `session_id` | Navigates headless browser to destination URL |
+| `extract_clean_text` | `session_id` | Extracts cleaned markdown text from page |
+| `extract_accessibility_tree` | `session_id` | Extracts compact interactive elements (AOM) |
+| `click_element` | `selector`, `session_id` | Simulates click on interactive element |
+| `fill_form_field` | `selector`, `value`, `session_id` | Fills input or textarea field |
+| `get_page_status` | `session_id` | Returns current URL, title, and response code |
+
+---
+
+## 🚀 Upgrade to BrowserBridge Pro
+
+Need enterprise-grade auditability, durable execution receipts, and browser pool sandboxing?
+
+The **BrowserBridge Pro Edition** adds:
+- 📜 **Durable Action Receipts Engine:** Generates cryptographic SHA-256 receipts for every web action, linking pre/post DOM hashes with visual state snapshots.
+- 🛡️ **Session Pool Manager con Anti-Zombie Auto-Cleanup:** Manages multiple browser contexts with strict inactivity TTLs, preventing memory leaks on your host.
+- 🎯 **Visual Element Selector & Coordinate Resolver:** Resolves robust CSS/XPath selectors and handles dynamic single-page applications (SPAs).
+- 🐳 **Production Docker & Compose:** Containerized headless Chromium runtime ready for cloud execution.
+- 🧪 **100% Passing Pytest Suite.**
+
+👉 **[Get the Genesis Enterprise Suite ($19)](https://johanld.gumroad.com/l/genesis-enterprise-suite)**
+
+---
+
+## 📄 License
+
+MIT © 2026 [Johann Schiffer](https://github.com/johannschiffer)
+
+## Recommended Infrastructure
+
+Proxies that work well with BrowserBridge MCP. Some links are referral links.
+
+- [Webshare](https://www.webshare.io/)
+- [ScraperAPI](https://www.scraperapi.com/)
+- [Bright Data](https://brightdata.com/)
+
+## Genesis MCP Ecosystem
+
+| Module | What it does | Repo |
+|---|---|---|
+| **CrawlEngine MCP** | Anti-bot web scraping, clean Markdown, proxy rotation and TLS evasion | [GitHub](https://github.com/johannschiffer/crawlengine-mcp) |
+| **BrowserBridge MCP** (this repo) | Deterministic headless browser automation with cryptographic action receipts | [GitHub](https://github.com/johannschiffer/browserbridge-mcp) |
+| **PgSafe MCP** | Zero-trust PostgreSQL/SQLite guard, live PII masking, zero-downtime migration checks | [GitHub](https://github.com/johannschiffer/pgsafe-mcp) |
+| **OmniBridge MCP** | Multi-channel notification and webhook bus with a persistent SQLite WAL queue | [GitHub](https://github.com/johannschiffer/omnibridge-mcp) |
+| **SysFlow MCP** | Safe Linux administration plane: systemd, port audit, isolated execution | [GitHub](https://github.com/johannschiffer/sysflow-mcp) |
+| **FastMCP Forge** | Production MCP server scaffolder: stdio, SSE and auth middleware | [GitHub](https://github.com/johannschiffer/fastmcp-forge) |
+
+[Live config builder](https://johannschiffer.github.io) | [Starter Kit, free](https://johanld.gumroad.com/l/genesis-starter-kit) | [Enterprise Suite, $19](https://johanld.gumroad.com/l/genesis-enterprise-suite)

browserbridge_mcp-1.0.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+browserbridge/__init__.py,sha256=hhVFn1BWUdGoAgmEkfmcj4H8WRGFZceL0BtEOX6wzAI,97
+browserbridge/_genesis.py,sha256=zGM-ZM94J40FSxTJSIIZuQX07_bg2TzoWbyHh-9BwoY,405
+browserbridge/cli.py,sha256=EXNJNjXZLTON3XPE7WyafciyNSXPxF0--LooTCFQDOI,2076
+browserbridge/engine.py,sha256=89HtNEgjPZVuukQJTwNg13gr-9G1BzVxkCXZbSYpuzY,7889
+browserbridge/server.py,sha256=IvkZBNAjr7LYYc2nUxhEa08RZFeHI0qQmy1aw_LqNR4,8172
+browserbridge_mcp-1.0.0.dist-info/licenses/LICENSE,sha256=8aNOswq7zMaFrf0O0jPUfqdJiA4P-AnczwX1g5a4dyA,1072
+browserbridge_mcp-1.0.0.dist-info/METADATA,sha256=OO-RENkD-EshGosolnto9ngci_8AYRghu8AuEpHlT54,7388
+browserbridge_mcp-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+browserbridge_mcp-1.0.0.dist-info/entry_points.txt,sha256=GEYQsktyOftfBMoEziLR88QcCQtBYJ7d6xjJILlsGeM,100
+browserbridge_mcp-1.0.0.dist-info/top_level.txt,sha256=wVRIYHGKwHcx-CX0yR4hz9PN6HqO36WrHQg2rSmifhg,14
+browserbridge_mcp-1.0.0.dist-info/RECORD,,

browserbridge_mcp-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

browserbridge_mcp-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+browserbridge = browserbridge.cli:main
+browserbridge-mcp = browserbridge.cli:main

browserbridge_mcp-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Johann Schiffer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

browserbridge_mcp-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+browserbridge