auto-browser-client 1.2.1__py3-none-any.whl

auto_browser_client/__init__.py

@@ -0,0 +1,5 @@
+"""auto-browser Python client SDK."""
+from .client import AutoBrowserClient
+
+__all__ = ["AutoBrowserClient"]
+__version__ = "1.2.1"

auto_browser_client/client.py

@@ -0,0 +1,373 @@
+"""
+auto_browser_client.client — Sync/async Python client for the auto-browser REST API.
+
+Usage (sync):
+    from auto_browser_client import AutoBrowserClient
+
+    client = AutoBrowserClient("http://localhost:8000", token="secret")
+    session = client.create_session(start_url="https://example.com")
+    obs = client.observe(session["id"], preset="fast")
+    client.navigate(session["id"], url="https://news.ycombinator.com")
+    client.close_session(session["id"])
+
+Usage (async):
+    async with AutoBrowserClient("http://localhost:8000") as client:
+        session = await client.async_create_session(start_url="https://example.com")
+        obs = await client.async_observe(session["id"])
+        await client.async_close_session(session["id"])
+"""
+from __future__ import annotations
+
+from typing import Any, Generator
+
+import httpx
+
+
+class AutoBrowserError(Exception):
+    def __init__(self, status_code: int, detail: Any):
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(f"HTTP {status_code}: {detail}")
+
+
+class AutoBrowserClient:
+    """Thin wrapper around the auto-browser REST API.
+
+    All methods have both a sync variant (e.g. ``create_session``) and an
+    async variant prefixed with ``async_`` (e.g. ``async_create_session``).
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost:8000",
+        token: str | None = None,
+        timeout: float = 60.0,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self._headers: dict[str, str] = {}
+        if token:
+            self._headers["Authorization"] = f"Bearer {token}"
+        self._sync_client: httpx.Client | None = None
+        self._async_client: httpx.AsyncClient | None = None
+        self._timeout = timeout
+
+    # ── Context managers ─────────────────────────────────────────────────────
+
+    def __enter__(self) -> "AutoBrowserClient":
+        self._sync_client = httpx.Client(base_url=self.base_url, headers=self._headers, timeout=self._timeout)
+        return self
+
+    def __exit__(self, *_) -> None:
+        if self._sync_client:
+            self._sync_client.close()
+            self._sync_client = None
+
+    async def __aenter__(self) -> "AutoBrowserClient":
+        self._async_client = httpx.AsyncClient(base_url=self.base_url, headers=self._headers, timeout=self._timeout)
+        return self
+
+    async def __aexit__(self, *_) -> None:
+        if self._async_client:
+            await self._async_client.aclose()
+            self._async_client = None
+
+    # ── Internal helpers ─────────────────────────────────────────────────────
+
+    def _client(self) -> httpx.Client:
+        if self._sync_client is None:
+            self._sync_client = httpx.Client(base_url=self.base_url, headers=self._headers, timeout=self._timeout)
+        return self._sync_client
+
+    def _aclient(self) -> httpx.AsyncClient:
+        if self._async_client is None:
+            self._async_client = httpx.AsyncClient(base_url=self.base_url, headers=self._headers, timeout=self._timeout)
+        return self._async_client
+
+    @staticmethod
+    def _raise(r: httpx.Response) -> None:
+        if r.status_code >= 400:
+            try:
+                detail = r.json()
+            except Exception:
+                detail = r.text
+            raise AutoBrowserError(r.status_code, detail)
+
+    def _get(self, path: str, **params) -> Any:
+        r = self._client().get(path, params=params)
+        self._raise(r)
+        return r.json()
+
+    def _post(self, path: str, body: dict | None = None) -> Any:
+        r = self._client().post(path, json=body or {})
+        self._raise(r)
+        return r.json()
+
+    def _delete(self, path: str) -> Any:
+        r = self._client().delete(path)
+        self._raise(r)
+        return r.json()
+
+    async def _aget(self, path: str, **params) -> Any:
+        r = await self._aclient().get(path, params=params)
+        self._raise(r)
+        return r.json()
+
+    async def _apost(self, path: str, body: dict | None = None) -> Any:
+        r = await self._aclient().post(path, json=body or {})
+        self._raise(r)
+        return r.json()
+
+    async def _adelete(self, path: str) -> Any:
+        r = await self._aclient().delete(path)
+        self._raise(r)
+        return r.json()
+
+    # ── Health ───────────────────────────────────────────────────────────────
+
+    def health(self) -> dict:
+        return self._get("/healthz")
+
+    async def async_health(self) -> dict:
+        return await self._aget("/healthz")
+
+    # ── Sessions ─────────────────────────────────────────────────────────────
+
+    def list_sessions(self) -> list[dict]:
+        return self._get("/sessions")
+
+    async def async_list_sessions(self) -> list[dict]:
+        return await self._aget("/sessions")
+
+    def create_session(
+        self,
+        *,
+        name: str | None = None,
+        start_url: str | None = None,
+        auth_profile: str | None = None,
+    ) -> dict:
+        body: dict[str, Any] = {}
+        if name:
+            body["name"] = name
+        if start_url:
+            body["start_url"] = start_url
+        if auth_profile:
+            body["auth_profile"] = auth_profile
+        return self._post("/sessions", body)
+
+    async def async_create_session(
+        self,
+        *,
+        name: str | None = None,
+        start_url: str | None = None,
+        auth_profile: str | None = None,
+    ) -> dict:
+        body: dict[str, Any] = {}
+        if name:
+            body["name"] = name
+        if start_url:
+            body["start_url"] = start_url
+        if auth_profile:
+            body["auth_profile"] = auth_profile
+        return await self._apost("/sessions", body)
+
+    def get_session(self, session_id: str) -> dict:
+        return self._get(f"/sessions/{session_id}")
+
+    async def async_get_session(self, session_id: str) -> dict:
+        return await self._aget(f"/sessions/{session_id}")
+
+    def close_session(self, session_id: str) -> dict:
+        return self._delete(f"/sessions/{session_id}")
+
+    async def async_close_session(self, session_id: str) -> dict:
+        return await self._adelete(f"/sessions/{session_id}")
+
+    # ── Observe ──────────────────────────────────────────────────────────────
+
+    def observe(
+        self,
+        session_id: str,
+        *,
+        preset: str = "normal",
+        limit: int = 40,
+    ) -> dict:
+        """Observe the current browser state.
+
+        preset: "fast" (screenshot only), "normal" (default), "rich" (extended)
+        """
+        return self._post(f"/sessions/{session_id}/observe", {"preset": preset, "limit": limit})
+
+    async def async_observe(
+        self,
+        session_id: str,
+        *,
+        preset: str = "normal",
+        limit: int = 40,
+    ) -> dict:
+        return await self._apost(f"/sessions/{session_id}/observe", {"preset": preset, "limit": limit})
+
+    # ── Navigation & actions ─────────────────────────────────────────────────
+
+    def navigate(self, session_id: str, url: str) -> dict:
+        return self._post(f"/sessions/{session_id}/actions/navigate", {"url": url})
+
+    async def async_navigate(self, session_id: str, url: str) -> dict:
+        return await self._apost(f"/sessions/{session_id}/actions/navigate", {"url": url})
+
+    def click(self, session_id: str, *, selector: str | None = None, element_id: str | None = None, x: float | None = None, y: float | None = None) -> dict:
+        body: dict[str, Any] = {}
+        if selector:
+            body["selector"] = selector
+        if element_id:
+            body["element_id"] = element_id
+        if x is not None:
+            body["x"] = x
+        if y is not None:
+            body["y"] = y
+        return self._post(f"/sessions/{session_id}/actions/click", body)
+
+    async def async_click(self, session_id: str, *, selector: str | None = None, element_id: str | None = None, x: float | None = None, y: float | None = None) -> dict:
+        body: dict[str, Any] = {}
+        if selector:
+            body["selector"] = selector
+        if element_id:
+            body["element_id"] = element_id
+        if x is not None:
+            body["x"] = x
+        if y is not None:
+            body["y"] = y
+        return await self._apost(f"/sessions/{session_id}/actions/click", body)
+
+    def type_text(self, session_id: str, text: str, *, selector: str | None = None, element_id: str | None = None, clear_first: bool = True) -> dict:
+        body: dict[str, Any] = {"text": text, "clear_first": clear_first}
+        if selector:
+            body["selector"] = selector
+        if element_id:
+            body["element_id"] = element_id
+        return self._post(f"/sessions/{session_id}/actions/type", body)
+
+    async def async_type_text(self, session_id: str, text: str, *, selector: str | None = None, element_id: str | None = None, clear_first: bool = True) -> dict:
+        body: dict[str, Any] = {"text": text, "clear_first": clear_first}
+        if selector:
+            body["selector"] = selector
+        if element_id:
+            body["element_id"] = element_id
+        return await self._apost(f"/sessions/{session_id}/actions/type", body)
+
+    def scroll(self, session_id: str, *, delta_x: float = 0, delta_y: float = 600) -> dict:
+        return self._post(f"/sessions/{session_id}/actions/scroll", {"delta_x": delta_x, "delta_y": delta_y})
+
+    async def async_scroll(self, session_id: str, *, delta_x: float = 0, delta_y: float = 600) -> dict:
+        return await self._apost(f"/sessions/{session_id}/actions/scroll", {"delta_x": delta_x, "delta_y": delta_y})
+
+    def screenshot(self, session_id: str, label: str = "manual") -> dict:
+        return self._post(f"/sessions/{session_id}/screenshot", {"label": label})
+
+    async def async_screenshot(self, session_id: str, label: str = "manual") -> dict:
+        return await self._apost(f"/sessions/{session_id}/screenshot", {"label": label})
+
+    def screenshot_diff(self, session_id: str) -> dict:
+        """Capture screenshot and diff against the most recent prior screenshot."""
+        return self._post(f"/sessions/{session_id}/screenshot/compare")
+
+    async def async_screenshot_diff(self, session_id: str) -> dict:
+        return await self._apost(f"/sessions/{session_id}/screenshot/compare")
+
+    # ── Agent ────────────────────────────────────────────────────────────────
+
+    def agent_step(self, session_id: str, *, provider: str, goal: str, **kwargs) -> dict:
+        return self._post(f"/sessions/{session_id}/agent/step", {"provider": provider, "goal": goal, **kwargs})
+
+    async def async_agent_step(self, session_id: str, *, provider: str, goal: str, **kwargs) -> dict:
+        return await self._apost(f"/sessions/{session_id}/agent/step", {"provider": provider, "goal": goal, **kwargs})
+
+    def agent_run(self, session_id: str, *, provider: str, goal: str, max_steps: int = 6, **kwargs) -> dict:
+        return self._post(f"/sessions/{session_id}/agent/run", {"provider": provider, "goal": goal, "max_steps": max_steps, **kwargs})
+
+    async def async_agent_run(self, session_id: str, *, provider: str, goal: str, max_steps: int = 6, **kwargs) -> dict:
+        return await self._apost(f"/sessions/{session_id}/agent/run", {"provider": provider, "goal": goal, "max_steps": max_steps, **kwargs})
+
+    # ── Approvals ────────────────────────────────────────────────────────────
+
+    def list_approvals(self, *, status: str | None = None, session_id: str | None = None) -> list[dict]:
+        params: dict[str, Any] = {}
+        if status:
+            params["status"] = status
+        if session_id:
+            params["session_id"] = session_id
+        return self._get("/approvals", **params)
+
+    async def async_list_approvals(self, *, status: str | None = None, session_id: str | None = None) -> list[dict]:
+        params: dict[str, Any] = {}
+        if status:
+            params["status"] = status
+        if session_id:
+            params["session_id"] = session_id
+        return await self._aget("/approvals", **params)
+
+    def approve(self, approval_id: str, comment: str | None = None) -> dict:
+        return self._post(f"/approvals/{approval_id}/approve", {"comment": comment})
+
+    async def async_approve(self, approval_id: str, comment: str | None = None) -> dict:
+        return await self._apost(f"/approvals/{approval_id}/approve", {"comment": comment})
+
+    def reject(self, approval_id: str, comment: str | None = None) -> dict:
+        return self._post(f"/approvals/{approval_id}/reject", {"comment": comment})
+
+    async def async_reject(self, approval_id: str, comment: str | None = None) -> dict:
+        return await self._apost(f"/approvals/{approval_id}/reject", {"comment": comment})
+
+    # ── Auth profiles ────────────────────────────────────────────────────────
+
+    def list_auth_profiles(self) -> list[dict]:
+        return self._get("/auth-profiles")
+
+    async def async_list_auth_profiles(self) -> list[dict]:
+        return await self._aget("/auth-profiles")
+
+    def save_auth_profile(self, session_id: str, profile_name: str) -> dict:
+        return self._post(f"/sessions/{session_id}/auth-profiles", {"profile_name": profile_name})
+
+    async def async_save_auth_profile(self, session_id: str, profile_name: str) -> dict:
+        return await self._apost(f"/sessions/{session_id}/auth-profiles", {"profile_name": profile_name})
+
+    def import_auth_profile(self, archive_path: str, *, overwrite: bool = False) -> dict:
+        return self._post("/auth-profiles/import", {"archive_path": archive_path, "overwrite": overwrite})
+
+    async def async_import_auth_profile(self, archive_path: str, *, overwrite: bool = False) -> dict:
+        return await self._apost("/auth-profiles/import", {"archive_path": archive_path, "overwrite": overwrite})
+
+    # ── SSE event stream (sync generator) ────────────────────────────────────
+
+    def stream_events(self, session_id: str) -> Generator[dict, None, None]:
+        """Yield parsed event dicts from the SSE stream. Blocks until disconnected."""
+        import json as _json
+
+        url = f"{self.base_url}/sessions/{session_id}/events"
+        with httpx.stream("GET", url, headers=self._headers, timeout=None) as r:
+            self._raise(r)
+            buffer = ""
+            for chunk in r.iter_text():
+                buffer += chunk
+                while "\n\n" in buffer:
+                    block, buffer = buffer.split("\n\n", 1)
+                    for line in block.splitlines():
+                        if line.startswith("data: "):
+                            try:
+                                yield _json.loads(line[6:])
+                            except Exception:
+                                pass
+
+    # ── Audit ────────────────────────────────────────────────────────────────
+
+    def list_audit_events(self, *, limit: int = 50, session_id: str | None = None) -> list[dict]:
+        params: dict[str, Any] = {"limit": limit}
+        if session_id:
+            params["session_id"] = session_id
+        return self._get("/audit/events", **params)
+
+    async def async_list_audit_events(self, *, limit: int = 50, session_id: str | None = None) -> list[dict]:
+        params: dict[str, Any] = {"limit": limit}
+        if session_id:
+            params["session_id"] = session_id
+        return await self._aget("/audit/events", **params)

auto_browser_client/mcp_bridge.py

@@ -0,0 +1,205 @@
+"""Stdio <-> HTTP bridge for Auto Browser's MCP endpoint.
+
+Single-file and stdlib-only by design. This module ships in two places:
+as ``auto_browser_client.mcp_bridge`` (the PyPI ``auto-browser-mcp`` console
+script) and as ``app.mcp_stdio`` inside the controller image (Glama/Docker
+entrypoint). A guard test asserts the two copies stay byte-identical, so any
+edit here must be mirrored to the other copy.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from dataclasses import dataclass
+from typing import Any, TextIO
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+# MCP spec header names, kept as local constants so the bridge has no
+# controller dependency. The controller test suite asserts these match
+# app.mcp_transport's values.
+MCP_SESSION_HEADER = "MCP-Session-Id"
+MCP_PROTOCOL_HEADER = "MCP-Protocol-Version"
+
+
+@dataclass
+class HttpMcpResponse:
+    status_code: int
+    headers: dict[str, str]
+    body: dict[str, Any] | None
+
+
+class HttpMcpClient:
+    def __init__(self, *, base_url: str, bearer_token: str | None = None, timeout_seconds: float = 60.0):
+        self.base_url = base_url
+        self.bearer_token = bearer_token
+        self.timeout_seconds = timeout_seconds
+
+    def post_json(
+        self,
+        payload: dict[str, Any],
+        *,
+        session_id: str | None = None,
+        protocol_version: str | None = None,
+    ) -> HttpMcpResponse:
+        headers = {"Content-Type": "application/json"}
+        if session_id:
+            headers[MCP_SESSION_HEADER] = session_id
+        if protocol_version:
+            headers[MCP_PROTOCOL_HEADER] = protocol_version
+        if self.bearer_token:
+            headers["Authorization"] = f"Bearer {self.bearer_token}"
+        return self._request("POST", headers=headers, body=payload)
+
+    def delete_session(self, *, session_id: str | None) -> None:
+        if not session_id:
+            return
+        headers = {MCP_SESSION_HEADER: session_id}
+        if self.bearer_token:
+            headers["Authorization"] = f"Bearer {self.bearer_token}"
+        try:
+            self._request("DELETE", headers=headers, body=None)
+        except Exception:
+            return
+
+    def _request(self, method: str, *, headers: dict[str, str], body: dict[str, Any] | None) -> HttpMcpResponse:
+        payload = None if body is None else json.dumps(body, ensure_ascii=False).encode("utf-8")
+        request = Request(self.base_url, data=payload, headers=headers, method=method)
+        try:
+            with urlopen(request, timeout=self.timeout_seconds) as response:
+                raw = response.read()
+                return HttpMcpResponse(
+                    status_code=response.status,
+                    headers={k.lower(): v for k, v in response.headers.items()},
+                    body=self._decode_json(raw),
+                )
+        except HTTPError as exc:
+            return HttpMcpResponse(
+                status_code=exc.code,
+                headers={k.lower(): v for k, v in exc.headers.items()},
+                body=self._decode_json(exc.read()),
+            )
+
+    @staticmethod
+    def _decode_json(raw: bytes) -> dict[str, Any] | None:
+        if not raw:
+            return None
+        return json.loads(raw.decode("utf-8"))
+
+
+class StdioMcpBridge:
+    def __init__(self, *, client: HttpMcpClient, stderr: TextIO | None = None):
+        self.client = client
+        self.stderr = stderr or sys.stderr
+        self.session_id: str | None = None
+        self.protocol_version: str | None = None
+
+    def run(self, *, stdin: TextIO | None = None, stdout: TextIO | None = None) -> int:
+        input_stream = stdin or sys.stdin
+        output_stream = stdout or sys.stdout
+        try:
+            for raw_line in input_stream:
+                line = raw_line.strip()
+                if not line:
+                    continue
+                response = self._handle_line(line)
+                if response is not None:
+                    output_stream.write(json.dumps(response, ensure_ascii=False) + "\n")
+                    output_stream.flush()
+        finally:
+            self.client.delete_session(session_id=self.session_id)
+        return 0
+
+    def _handle_line(self, line: str) -> dict[str, Any] | None:
+        try:
+            payload = json.loads(line)
+        except json.JSONDecodeError:
+            return self._jsonrpc_error(None, -32700, "Invalid JSON payload")
+
+        if isinstance(payload, list):
+            return self._jsonrpc_error(None, -32600, "JSON-RPC batches are not supported")
+        if not isinstance(payload, dict):
+            return self._jsonrpc_error(None, -32600, "JSON-RPC body must be an object")
+
+        request_id = payload.get("id")
+        try:
+            response = self.client.post_json(
+                payload,
+                session_id=None if payload.get("method") == "initialize" else self.session_id,
+                protocol_version=self.protocol_version,
+            )
+        except URLError as exc:
+            return self._jsonrpc_error(request_id, -32000, f"Unable to reach Auto Browser MCP HTTP endpoint: {exc.reason}")
+        except Exception as exc:  # pragma: no cover - defensive bridge guard
+            print(f"stdio bridge unexpected error: {exc}", file=self.stderr)
+            return self._jsonrpc_error(request_id, -32000, f"Unexpected stdio bridge failure: {exc}")
+
+        next_session_id = response.headers.get(MCP_SESSION_HEADER.lower())
+        if next_session_id:
+            self.session_id = next_session_id
+
+        next_protocol_version = response.headers.get(MCP_PROTOCOL_HEADER.lower())
+        if next_protocol_version:
+            self.protocol_version = next_protocol_version
+        elif payload.get("method") == "initialize":
+            result = (response.body or {}).get("result") if isinstance(response.body, dict) else None
+            if isinstance(result, dict):
+                version = result.get("protocolVersion")
+                if isinstance(version, str) and version.strip():
+                    self.protocol_version = version.strip()
+
+        if payload.get("id") is None:
+            return None
+        if response.body is None:
+            return self._jsonrpc_error(request_id, -32000, f"Empty response from Auto Browser MCP endpoint ({response.status_code})")
+        return response.body
+
+    @staticmethod
+    def _jsonrpc_error(request_id: Any, code: int, message: str) -> dict[str, Any]:
+        return {
+            "jsonrpc": "2.0",
+            "id": request_id,
+            "error": {
+                "code": code,
+                "message": message,
+            },
+        }
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Bridge stdio MCP clients to the Auto Browser HTTP MCP endpoint.")
+    parser.add_argument(
+        "--base-url",
+        default=os.environ.get("AUTO_BROWSER_BASE_URL", "http://127.0.0.1:8000/mcp"),
+        help="HTTP MCP endpoint to proxy to (default: %(default)s)",
+    )
+    parser.add_argument(
+        "--bearer-token",
+        default=os.environ.get("AUTO_BROWSER_BEARER_TOKEN"),
+        help="Optional API bearer token for the Auto Browser HTTP server.",
+    )
+    parser.add_argument(
+        "--timeout-seconds",
+        type=float,
+        default=float(os.environ.get("AUTO_BROWSER_HTTP_TIMEOUT_SECONDS", "60")),
+        help="Per-request timeout when talking to the HTTP MCP endpoint.",
+    )
+    return parser
+
+
+def main() -> int:
+    args = build_arg_parser().parse_args()
+    bridge = StdioMcpBridge(
+        client=HttpMcpClient(
+            base_url=args.base_url,
+            bearer_token=args.bearer_token,
+            timeout_seconds=args.timeout_seconds,
+        )
+    )
+    return bridge.run()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

auto_browser_client-1.2.1.dist-info/METADATA

@@ -0,0 +1,59 @@
+Metadata-Version: 2.4
+Name: auto-browser-client
+Version: 1.2.1
+Summary: Python client SDK and MCP stdio bridge for Auto Browser
+License: MIT
+Project-URL: Homepage, https://github.com/LvcidPsyche/auto-browser
+Project-URL: Repository, https://github.com/LvcidPsyche/auto-browser
+Project-URL: Changelog, https://github.com/LvcidPsyche/auto-browser/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/LvcidPsyche/auto-browser/issues
+Keywords: auto-browser,mcp,browser-automation,playwright
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP :: Browsers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: respx; extra == "dev"
+
+# auto-browser-client
+
+Python SDK and MCP stdio bridge for the [Auto Browser](https://github.com/LvcidPsyche/auto-browser) REST API.
+
+## SDK
+
+```python
+from auto_browser_client import AutoBrowserClient
+
+client = AutoBrowserClient("http://localhost:8000", token="secret")
+session = client.create_session(start_url="https://example.com")
+client.navigate(session["id"], "https://example.com/dashboard")
+client.close_session(session["id"])
+```
+
+## MCP stdio bridge
+
+This package also ships the `auto-browser-mcp` console script, which bridges
+stdio MCP clients (Claude Desktop, Cursor, ...) to a running Auto Browser
+controller:
+
+```bash
+auto-browser-mcp --base-url http://127.0.0.1:8000/mcp
+```
+
+Or zero-install via [uv](https://docs.astral.sh/uv/): `uvx auto-browser-mcp`
+(resolved through the [auto-browser-mcp](https://pypi.org/project/auto-browser-mcp/)
+metapackage).
+
+The server itself is Docker-first — see the
+[Auto Browser repository](https://github.com/LvcidPsyche/auto-browser) to run it.

auto_browser_client-1.2.1.dist-info/RECORD

@@ -0,0 +1,8 @@
+auto_browser_client/__init__.py,sha256=z3n69rLIF8QOAsrCzhynYoZKJY3Uf6OPVQDqVqIFxSY,131
+auto_browser_client/client.py,sha256=mU-Ji9Gwyh7ge-KoVwuBxHQr7ukvERw_JqRwQLQnkbc,16595
+auto_browser_client/mcp_bridge.py,sha256=E4vog71SgKS9Au2PHlsM42cC1j_IhXK1_tertr7w9NY,7853
+auto_browser_client-1.2.1.dist-info/METADATA,sha256=21SMvQtONGPC1pfCdgdKWcZC8uEsCwOIYG3AZrMiz1k,2223
+auto_browser_client-1.2.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+auto_browser_client-1.2.1.dist-info/entry_points.txt,sha256=FFMGj01khJB9wnindg1FRJKcG7A3ca0BYhSzu3Un758,73
+auto_browser_client-1.2.1.dist-info/top_level.txt,sha256=8etgv_rs25N5QzUhG_6Lqzcm9BeB9SjwpV3goH-NJrw,20
+auto_browser_client-1.2.1.dist-info/RECORD,,

auto_browser_client-1.2.1.dist-info/WHEEL

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

auto_browser_client-1.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+auto-browser-mcp = auto_browser_client.mcp_bridge:main

auto_browser_client-1.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+auto_browser_client