browser-control-and-automation-cli 0.1.1.dev3__py3-none-any.whl

browser_cli/daemon/transport.py

@@ -0,0 +1,77 @@
+"""Unix-socket transport helpers for the daemon."""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import os
+import socket
+import stat
+from pathlib import Path
+from typing import Any
+
+from browser_cli.constants import get_app_paths
+
+DAEMON_RUNTIME_VERSION = "2026-04-10-dual-driver-extension-v1"
+
+
+def ensure_run_dir() -> Path:
+    run_dir = get_app_paths().run_dir
+    run_dir.mkdir(parents=True, exist_ok=True)
+    with contextlib.suppress(OSError):
+        os.chmod(run_dir, 0o700)
+    return run_dir
+
+
+def write_run_info(info: dict[str, Any]) -> None:
+    ensure_run_dir()
+    run_info_path = get_app_paths().run_info_path
+    tmp_path = run_info_path.with_suffix(".tmp")
+    tmp_path.write_text(json.dumps(info), encoding="utf-8")
+    tmp_path.replace(run_info_path)
+    with contextlib.suppress(OSError):
+        os.chmod(run_info_path, 0o600)
+
+
+def read_run_info() -> dict[str, Any] | None:
+    run_info_path = get_app_paths().run_info_path
+    try:
+        return json.loads(run_info_path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return None
+
+
+def remove_run_info() -> None:
+    with contextlib.suppress(OSError):
+        get_app_paths().run_info_path.unlink()
+
+
+def safe_remove_socket(path: Path | None = None) -> None:
+    socket_path = path or get_app_paths().socket_path
+    try:
+        st = socket_path.stat()
+    except FileNotFoundError:
+        return
+    if not stat.S_ISSOCK(st.st_mode):
+        raise RuntimeError(f"Refusing to remove non-socket path: {socket_path}")
+    if hasattr(os, "getuid") and st.st_uid != os.getuid():
+        raise PermissionError(
+            f"Socket path {socket_path} is owned by uid={st.st_uid}, current uid={os.getuid()}"
+        )
+    try:
+        socket_path.unlink()
+    except FileNotFoundError:
+        return
+
+
+def probe_socket(path: Path | None = None) -> bool:
+    socket_path = str(path or get_app_paths().socket_path)
+    client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    try:
+        client.settimeout(1.0)
+        client.connect(socket_path)
+        return True
+    except OSError:
+        return False
+    finally:
+        client.close()

browser_cli/drivers/__init__.py

@@ -0,0 +1,6 @@
+"""Driver interfaces and implementations."""
+
+from .base import BrowserDriver
+from .models import DriverHealth, TabState
+
+__all__ = ["BrowserDriver", "DriverHealth", "TabState"]

browser_cli/drivers/_extension/__init__.py

@@ -0,0 +1 @@
+"""Internal helpers for the extension-backed browser driver."""

browser_cli/drivers/_extension/artifact_actions.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import base64
+from typing import Any
+
+
+class ExtensionDriverArtifactActionsMixin:
+    async def screenshot(
+        self, page_id: str, *, path: str, full_page: bool = False
+    ) -> dict[str, Any]:
+        payload = await self._page_command(
+            page_id,
+            "screenshot",
+            {"full_page": full_page},
+        )
+        output_path = await self._materialize_single_artifact(
+            payload,
+            page_id=page_id,
+            path=path,
+            suffix=".png",
+            artifact_kind="screenshot",
+            inline_key="data_base64",
+        )
+        return {"page_id": page_id, "path": output_path, "full_page": full_page}
+
+    async def save_pdf(self, page_id: str, *, path: str) -> dict[str, Any]:
+        payload = await self._page_command(page_id, "pdf", {})
+        output_path = await self._materialize_single_artifact(
+            payload,
+            page_id=page_id,
+            path=path,
+            suffix=".pdf",
+            artifact_kind="pdf",
+            inline_key="data_base64",
+        )
+        return {"page_id": page_id, "path": output_path}
+
+    async def start_tracing(
+        self,
+        page_id: str,
+        *,
+        screenshots: bool = True,
+        snapshots: bool = True,
+        sources: bool = False,
+    ) -> dict[str, Any]:
+        payload = await self._page_command(
+            page_id,
+            "trace-start",
+            {"screenshots": screenshots, "snapshots": snapshots, "sources": sources},
+        )
+        return {"page_id": page_id, **payload}
+
+    async def add_trace_chunk(self, page_id: str, *, title: str | None = None) -> dict[str, Any]:
+        payload = await self._page_command(page_id, "trace-chunk", {"title": title})
+        return {"page_id": page_id, **payload}
+
+    async def stop_tracing(self, page_id: str, *, path: str | None = None) -> dict[str, Any]:
+        payload = await self._page_command(page_id, "trace-stop", {"path": path})
+        output_path = await self._materialize_single_artifact(
+            payload,
+            page_id=page_id,
+            path=path,
+            suffix=".zip",
+            artifact_kind="trace",
+        )
+        return {"page_id": page_id, "path": output_path}
+
+    async def start_video(
+        self, page_id: str, *, width: int | None = None, height: int | None = None
+    ) -> dict[str, Any]:
+        payload = await self._page_command(
+            page_id, "video-start", {"width": width, "height": height}
+        )
+        return {"page_id": page_id, **payload}
+
+    async def stop_video(self, page_id: str, *, path: str | None = None) -> dict[str, Any]:
+        payload = await self._page_command(page_id, "video-stop", {"path": path})
+        return {"page_id": page_id, **payload}
+
+    async def _materialize_single_artifact(
+        self,
+        payload: dict[str, Any],
+        *,
+        page_id: str,
+        path: str | None,
+        suffix: str,
+        artifact_kind: str,
+        inline_key: str | None = None,
+    ) -> str:
+        artifacts = list(payload.get("_artifacts") or [])
+        if artifacts:
+            for artifact in artifacts:
+                if str(artifact.get("artifact_kind") or "") != artifact_kind:
+                    continue
+                resolved = self._resolve_artifact_output_path(
+                    artifact,
+                    page_id=page_id,
+                    path=path,
+                    suffix=suffix,
+                )
+                self._write_artifact_bytes(artifact, resolved)
+                return str(resolved)
+        if inline_key and payload.get(inline_key):
+            output_path = self._resolve_output_path(path, page_id=page_id, suffix=suffix)
+            output_path.write_bytes(
+                base64.b64decode(str(payload.get(inline_key) or "").encode("ascii"))
+            )
+            return str(output_path)
+        if path:
+            return str(self._resolve_output_path(path, page_id=page_id, suffix=suffix))
+        raise RuntimeError(f"Expected extension artifact kind {artifact_kind}.")
+
+    async def _materialize_video_artifacts(self, artifacts: list[dict[str, Any]]) -> list[str]:
+        paths: list[str] = []
+        for artifact in artifacts:
+            if str(artifact.get("artifact_kind") or "") != "video":
+                continue
+            page_id = str(artifact.get("page_id") or "page")
+            resolved = self._resolve_artifact_output_path(
+                artifact,
+                page_id=page_id,
+                path=str((artifact.get("metadata") or {}).get("requested_path") or "").strip()
+                or None,
+                suffix=".webm",
+            )
+            self._write_artifact_bytes(artifact, resolved)
+            paths.append(str(resolved))
+        return paths
+
+    def _resolve_artifact_output_path(
+        self,
+        artifact: dict[str, Any],
+        *,
+        page_id: str,
+        path: str | None,
+        suffix: str,
+    ):
+        if path:
+            return self._resolve_output_path(path, page_id=page_id, suffix=suffix)
+        metadata = dict(artifact.get("metadata") or {})
+        requested = str(metadata.get("requested_path") or "").strip()
+        if requested:
+            return self._resolve_output_path(requested, page_id=page_id, suffix=suffix)
+        filename = str(artifact.get("filename") or "").strip()
+        if filename:
+            return self._resolve_output_path(filename, page_id=page_id, suffix=suffix)
+        return self._resolve_output_path(None, page_id=page_id, suffix=suffix)
+
+    @staticmethod
+    def _write_artifact_bytes(artifact: dict[str, Any], output_path) -> None:
+        content = artifact.get("content")
+        if not isinstance(content, bytes | bytearray):
+            raise RuntimeError("Extension artifact payload is missing binary content.")
+        output_path.write_bytes(bytes(content))

browser_cli/drivers/_extension/dialog_actions.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+
+class ExtensionDriverDialogActionsMixin:
+    async def setup_dialog_handler(
+        self,
+        page_id: str,
+        *,
+        default_action: str = "accept",
+        default_prompt_text: str | None = None,
+    ) -> dict[str, object]:
+        payload = await self._page_command(
+            page_id,
+            "dialog-setup",
+            {"action": default_action, "text": default_prompt_text},
+        )
+        return {"page_id": page_id, **payload}
+
+    async def handle_dialog(
+        self,
+        page_id: str,
+        *,
+        accept: bool,
+        prompt_text: str | None = None,
+    ) -> dict[str, object]:
+        payload = await self._page_command(
+            page_id,
+            "dialog",
+            {"dismiss": not accept, "text": prompt_text},
+        )
+        return {"page_id": page_id, **payload}
+
+    async def remove_dialog_handler(self, page_id: str) -> dict[str, object]:
+        payload = await self._page_command(page_id, "dialog-remove", {})
+        return {"page_id": page_id, **payload}

browser_cli/drivers/_extension/input_actions.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+
+class ExtensionDriverInputActionsMixin:
+    async def type_text(
+        self, page_id: str, text: str, *, submit: bool = False
+    ) -> dict[str, object]:
+        payload = await self._page_command(page_id, "type", {"text": text, "submit": submit})
+        return {"page_id": page_id, **payload}
+
+    async def press_key(self, page_id: str, key: str) -> dict[str, object]:
+        payload = await self._page_command(page_id, "press", {"key": key})
+        return {"page_id": page_id, **payload}
+
+    async def key_down(self, page_id: str, key: str) -> dict[str, object]:
+        payload = await self._page_command(page_id, "key-down", {"key": key})
+        return {"page_id": page_id, **payload}
+
+    async def key_up(self, page_id: str, key: str) -> dict[str, object]:
+        payload = await self._page_command(page_id, "key-up", {"key": key})
+        return {"page_id": page_id, **payload}
+
+    async def wheel(self, page_id: str, *, dx: int = 0, dy: int = 700) -> dict[str, object]:
+        payload = await self._page_command(page_id, "scroll", {"dx": dx, "dy": dy})
+        return {"page_id": page_id, **payload}
+
+    async def mouse_move(self, page_id: str, *, x: int, y: int) -> dict[str, object]:
+        payload = await self._page_command(page_id, "mouse-move", {"x": x, "y": y})
+        return {"page_id": page_id, **payload}
+
+    async def mouse_click(
+        self,
+        page_id: str,
+        *,
+        x: int,
+        y: int,
+        button: str = "left",
+        count: int = 1,
+    ) -> dict[str, object]:
+        payload = await self._page_command(
+            page_id,
+            "mouse-click",
+            {"x": x, "y": y, "button": button, "count": count},
+        )
+        return {"page_id": page_id, **payload}
+
+    async def mouse_drag(
+        self, page_id: str, *, x1: int, y1: int, x2: int, y2: int
+    ) -> dict[str, object]:
+        payload = await self._page_command(
+            page_id,
+            "mouse-drag",
+            {"x1": x1, "y1": y1, "x2": x2, "y2": y2},
+        )
+        return {"page_id": page_id, **payload}
+
+    async def mouse_down(self, page_id: str, *, button: str = "left") -> dict[str, object]:
+        payload = await self._page_command(page_id, "mouse-down", {"button": button})
+        return {"page_id": page_id, **payload}
+
+    async def mouse_up(self, page_id: str, *, button: str = "left") -> dict[str, object]:
+        payload = await self._page_command(page_id, "mouse-up", {"button": button})
+        return {"page_id": page_id, **payload}

browser_cli/drivers/_extension/locator_actions.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from typing import Any
+
+from browser_cli.refs.models import LocatorSpec
+
+
+class ExtensionDriverLocatorActionsMixin:
+    async def click(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        await self._locator_command(page_id, "click", locator)
+        return {"page_id": page_id, "ref": locator.ref, "action": "click"}
+
+    async def double_click(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        await self._locator_command(page_id, "double-click", locator)
+        return {"page_id": page_id, "ref": locator.ref, "action": "double-click"}
+
+    async def hover(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        await self._locator_command(page_id, "hover", locator)
+        return {"page_id": page_id, "ref": locator.ref, "action": "hover"}
+
+    async def focus(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        await self._locator_command(page_id, "focus", locator)
+        return {"page_id": page_id, "ref": locator.ref, "action": "focus"}
+
+    async def fill(
+        self,
+        page_id: str,
+        locator: LocatorSpec,
+        text: str,
+        *,
+        submit: bool = False,
+    ) -> dict[str, Any]:
+        await self._locator_command(page_id, "fill", locator, {"text": text, "submit": submit})
+        return {"page_id": page_id, "ref": locator.ref, "filled": True, "submitted": submit}
+
+    async def select_option(self, page_id: str, locator: LocatorSpec, text: str) -> dict[str, Any]:
+        await self._locator_command(page_id, "select", locator, {"text": text})
+        return {"page_id": page_id, "ref": locator.ref, "selected": text}
+
+    async def list_options(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        payload = await self._locator_command(page_id, "options", locator)
+        return {"page_id": page_id, "ref": locator.ref, **payload}
+
+    async def check(self, page_id: str, locator: LocatorSpec, *, checked: bool) -> dict[str, Any]:
+        await self._locator_command(page_id, "check", locator, {"checked": checked})
+        return {"page_id": page_id, "ref": locator.ref, "checked": checked}
+
+    async def scroll_to(self, page_id: str, locator: LocatorSpec) -> dict[str, Any]:
+        await self._locator_command(page_id, "scroll-to", locator)
+        return {"page_id": page_id, "ref": locator.ref, "scrolled": True}
+
+    async def drag(
+        self, page_id: str, start_locator: LocatorSpec, end_locator: LocatorSpec
+    ) -> dict[str, Any]:
+        payload = await self._page_command(
+            page_id,
+            "drag",
+            {"start_locator": start_locator.to_dict(), "end_locator": end_locator.to_dict()},
+        )
+        return {
+            "page_id": page_id,
+            "start_ref": start_locator.ref,
+            "end_ref": end_locator.ref,
+            **payload,
+        }
+
+    async def upload(self, page_id: str, locator: LocatorSpec, file_path: str) -> dict[str, Any]:
+        payload = await self._locator_command(page_id, "upload", locator, {"path": file_path})
+        return {"page_id": page_id, "ref": locator.ref, **payload}
+
+    async def evaluate_on(self, page_id: str, locator: LocatorSpec, code: str) -> dict[str, Any]:
+        payload = await self._locator_command(page_id, "eval-on", locator, {"code": code})
+        return {"page_id": page_id, "ref": locator.ref, "result": payload.get("result")}
+
+    async def verify_state(
+        self, page_id: str, *, locator: LocatorSpec, state: str
+    ) -> dict[str, Any]:
+        payload = await self._locator_command(page_id, "verify-state", locator, {"state": state})
+        return {"page_id": page_id, "ref": locator.ref, **payload}
+
+    async def verify_value(
+        self, page_id: str, *, locator: LocatorSpec, expected: str
+    ) -> dict[str, Any]:
+        payload = await self._locator_command(
+            page_id, "verify-value", locator, {"expected": expected}
+        )
+        return {"page_id": page_id, "ref": locator.ref, **payload}
+
+    async def _locator_command(
+        self,
+        page_id: str,
+        action: str,
+        locator: LocatorSpec,
+        payload: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        return await self._page_command(
+            page_id,
+            action,
+            {"locator": locator.to_dict(), **(payload or {})},
+        )