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

browser_cli/automation/service/client.py

@@ -0,0 +1,232 @@
+"""Client helpers for the automation service."""
+
+from __future__ import annotations
+
+import contextlib
+import http.client
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+from browser_cli import __version__
+from browser_cli.constants import get_app_paths
+from browser_cli.errors import AutomationServiceError, AutomationServiceNotAvailableError
+
+AUTOMATION_STARTUP_TIMEOUT_SECONDS = 15.0
+AUTOMATION_STARTUP_PROBE_INTERVAL_SECONDS = 0.1
+
+
+def request_automation_service(
+    method: str,
+    path: str,
+    *,
+    body: dict[str, Any] | None = None,
+    start_if_needed: bool = True,
+) -> dict[str, Any]:
+    if start_if_needed:
+        ensure_automation_service_running()
+    run_info = read_automation_service_run_info()
+    if not run_info:
+        raise AutomationServiceNotAvailableError()
+    host = str(run_info["host"])
+    port = int(run_info["port"])
+    connection = http.client.HTTPConnection(host, port, timeout=5.0)
+    try:
+        raw = json.dumps(body).encode("utf-8") if body is not None else None
+        headers = {"Content-Type": "application/json"} if raw is not None else {}
+        connection.request(method, path, body=raw, headers=headers)
+        response = connection.getresponse()
+        payload = json.loads(response.read().decode("utf-8"))
+    except OSError as exc:
+        raise AutomationServiceNotAvailableError(str(exc)) from exc
+    finally:
+        connection.close()
+    if payload.get("ok"):
+        return payload
+    raise AutomationServiceError(payload)
+
+
+def ensure_automation_service_running() -> None:
+    run_info = read_automation_service_run_info()
+    if _run_info_is_compatible(run_info) and _probe_automation_service(run_info):
+        return
+    _cleanup_stale_automation_service()
+    _spawn_automation_service()
+
+
+def stop_automation_service() -> dict[str, Any]:
+    run_info = read_automation_service_run_info()
+    if not run_info or not _probe_automation_service(run_info):
+        _cleanup_stale_automation_service()
+        return {"stopped": False, "already_stopped": True}
+    payload = request_automation_service("POST", "/api/service/stop", start_if_needed=False)
+    _wait_for_automation_service_stop()
+    _cleanup_stale_automation_service()
+    return dict(payload.get("data") or {})
+
+
+def automation_service_ui_url() -> str:
+    ensure_automation_service_running()
+    run_info = read_automation_service_run_info()
+    if not run_info:
+        raise AutomationServiceNotAvailableError()
+    return f"http://{run_info['host']}:{run_info['port']}/"
+
+
+def read_automation_service_run_info() -> dict[str, Any] | None:
+    path = get_app_paths().automation_service_run_info_path
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (FileNotFoundError, OSError, json.JSONDecodeError):
+        return None
+
+
+def _write_automation_service_run_info(info: dict[str, Any]) -> None:
+    path = get_app_paths().automation_service_run_info_path
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(info), encoding="utf-8")
+    tmp.replace(path)
+
+
+def remove_automation_service_run_info() -> None:
+    with contextlib.suppress(OSError):
+        get_app_paths().automation_service_run_info_path.unlink()
+
+
+def _spawn_automation_service() -> None:
+    app_paths = get_app_paths()
+    app_paths.run_dir.mkdir(parents=True, exist_ok=True)
+    env = os.environ.copy()
+    existing_pythonpath = os.environ.get("PYTHONPATH", "")
+    source_root = Path(__file__).resolve().parents[3]
+    pythonpath_parts = [str(source_root)]
+    if existing_pythonpath:
+        pythonpath_parts.append(existing_pythonpath)
+    env["PYTHONPATH"] = os.pathsep.join(pythonpath_parts)
+    log_handle = app_paths.automation_service_log_path.open("ab")
+    process = None
+    try:
+        process = subprocess.Popen(
+            [sys.executable, "-m", "browser_cli.automation.service", "--home", str(app_paths.home)],
+            stdout=log_handle,
+            stderr=subprocess.STDOUT,
+            env=env,
+            start_new_session=True,
+        )
+    finally:
+        log_handle.close()
+    deadline = time.time() + AUTOMATION_STARTUP_TIMEOUT_SECONDS
+    while time.time() < deadline:
+        run_info = read_automation_service_run_info()
+        if _run_info_is_compatible(run_info) and _probe_automation_service(run_info):
+            return
+        time.sleep(AUTOMATION_STARTUP_PROBE_INTERVAL_SECONDS)
+    if process is not None:
+        _terminate_process_tree(process.pid)
+    raise AutomationServiceNotAvailableError(
+        f"Timed out waiting for automation service startup (log={app_paths.automation_service_log_path})."
+    )
+
+
+def _probe_automation_service(run_info: dict[str, Any] | None) -> bool:
+    if not isinstance(run_info, dict):
+        return False
+    host = str(run_info.get("host") or "")
+    port = int(run_info.get("port") or 0)
+    if not host or port <= 0:
+        return False
+    connection: http.client.HTTPConnection | None = None
+    try:
+        connection = http.client.HTTPConnection(host, port, timeout=1.0)
+        connection.request("GET", "/api/service/status")
+        response = connection.getresponse()
+        response.read()
+        return response.status == 200
+    except OSError:
+        return False
+    finally:
+        if connection is not None:
+            with contextlib.suppress(Exception):
+                connection.close()
+
+
+def _wait_for_automation_service_stop(timeout_seconds: float = 3.0) -> bool:
+    deadline = time.time() + timeout_seconds
+    while time.time() < deadline:
+        run_info = read_automation_service_run_info()
+        if not run_info or not _probe_automation_service(run_info):
+            return True
+        time.sleep(0.1)
+    return False
+
+
+def _cleanup_stale_automation_service() -> None:
+    run_info = read_automation_service_run_info()
+    if isinstance(run_info, dict):
+        pid = _coerce_pid(run_info.get("pid"))
+        if pid is not None and _pid_exists(pid) and not _probe_automation_service(run_info):
+            _terminate_process_tree(pid)
+    remove_automation_service_run_info()
+
+
+def _run_info_is_compatible(run_info: dict[str, Any] | None) -> bool:
+    if not isinstance(run_info, dict):
+        return False
+    return (
+        str(run_info.get("package_version") or "") == __version__
+        and str(run_info.get("runtime_version") or "") == "2026-04-12-automation-service-v1"
+    )
+
+
+def _terminate_process_tree(pid: int) -> None:
+    _signal_process_tree(pid, signal.SIGTERM)
+    deadline = time.time() + 3.0
+    while time.time() < deadline:
+        if not _pid_exists(pid):
+            return
+        time.sleep(0.1)
+    _signal_process_tree(pid, signal.SIGKILL)
+
+
+def _signal_process_tree(pid: int, sig: signal.Signals) -> None:
+    try:
+        os.killpg(pid, sig)
+    except OSError:
+        with contextlib.suppress(OSError):
+            os.kill(pid, sig)
+
+
+def _coerce_pid(value: Any) -> int | None:
+    try:
+        pid = int(value)
+    except (TypeError, ValueError):
+        return None
+    return pid if pid > 0 else None
+
+
+def _pid_exists(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+    else:
+        return True
+
+
+__all__ = [
+    "ensure_automation_service_running",
+    "read_automation_service_run_info",
+    "remove_automation_service_run_info",
+    "request_automation_service",
+    "stop_automation_service",
+    "automation_service_ui_url",
+    "_write_automation_service_run_info",
+]

browser_cli/automation/service/runtime.py

@@ -0,0 +1,388 @@
+"""Automation service runtime."""
+
+from __future__ import annotations
+
+import json
+import logging
+import multiprocessing
+import threading
+import time
+from pathlib import Path
+from typing import Any
+
+from browser_cli import __version__, error_codes
+from browser_cli.automation.hooks import run_hook_commands
+from browser_cli.automation.models import AutomationRunEvent
+from browser_cli.automation.persistence import AutomationStore
+from browser_cli.constants import get_app_paths
+from browser_cli.errors import AutomationRunTimeoutError, OperationFailedError
+from browser_cli.task_runtime import run_task_entrypoint
+from browser_cli.task_runtime.client import BrowserCliTaskClient
+
+logger = logging.getLogger(__name__)
+
+AUTOMATION_SERVICE_RUNTIME_VERSION = "2026-04-12-automation-service-v1"
+FAILURE_HOOK_TIMEOUT_SECONDS = 5.0
+
+
+def _run_task_entrypoint_child(
+    queue,
+    *,
+    task_path: str,
+    entrypoint: str,
+    inputs: dict[str, Any],
+    artifacts_dir: str,
+    automation_path: str | None,
+    automation_name: str | None,
+    log_path: str,
+) -> None:
+    try:
+        with open(log_path, "a", encoding="utf-8") as log_handle:
+            result = run_task_entrypoint(
+                task_path=Path(task_path),
+                entrypoint=entrypoint,
+                inputs=inputs,
+                artifacts_dir=Path(artifacts_dir),
+                automation_path=Path(automation_path) if automation_path else None,
+                automation_name=automation_name,
+                client=BrowserCliTaskClient(),
+                stdout_handle=log_handle,
+                stderr_handle=log_handle,
+            )
+        queue.put({"ok": True, "result": result})
+    except BaseException as exc:  # noqa: BLE001
+        queue.put(
+            {
+                "ok": False,
+                "error_message": str(exc),
+                "error_code": (
+                    exc.error_code
+                    if isinstance(exc, OperationFailedError)
+                    else error_codes.AUTOMATION_RUN_FAILED
+                ),
+            }
+        )
+
+
+class AutomationServiceRuntime:
+    def __init__(self, store: AutomationStore | None = None) -> None:
+        self.app_paths = get_app_paths()
+        self.store = store or AutomationStore()
+        self.started_at = time.time()
+        self.stop_event = threading.Event()
+        self._scheduler_thread = threading.Thread(
+            target=self._scheduler_loop,
+            name="automation-service-scheduler",
+            daemon=True,
+        )
+        self._executor_thread = threading.Thread(
+            target=self._executor_loop,
+            name="automation-service-executor",
+            daemon=True,
+        )
+
+    def start(self) -> None:
+        self._scheduler_thread.start()
+        self._executor_thread.start()
+
+    def stop(self) -> None:
+        self.stop_event.set()
+
+    def join(self, timeout: float | None = None) -> None:
+        self._scheduler_thread.join(timeout=timeout)
+        self._executor_thread.join(timeout=timeout)
+
+    def status_payload(self) -> dict[str, Any]:
+        metrics = self.store.service_metrics()
+        return {
+            "service": {
+                "healthy": not self.stop_event.is_set(),
+                "started_at": self.started_at,
+                "runtime_version": AUTOMATION_SERVICE_RUNTIME_VERSION,
+                "package_version": __version__,
+                "db_path": str(self.store.db_path),
+                "runs_dir": str(self.app_paths.automation_runs_dir),
+            },
+            "metrics": metrics,
+        }
+
+    def _scheduler_loop(self) -> None:
+        while not self.stop_event.is_set():
+            try:
+                self.store.enqueue_due_runs()
+            except Exception:
+                logger.exception("Automation scheduler loop failed")
+            self.stop_event.wait(1.0)
+
+    def _executor_loop(self) -> None:
+        while not self.stop_event.is_set():
+            try:
+                run = self.store.claim_next_run()
+                if run is None:
+                    self.stop_event.wait(0.5)
+                    continue
+                self._execute_run(run.run_id)
+            except Exception:
+                logger.exception("Automation executor loop failed")
+                self.stop_event.wait(0.5)
+
+    def _execute_run(self, run_id: str) -> None:
+        run = self.store.get_run(run_id)
+        automation = self.store.get_automation(run.automation_id)
+        run_dir = (automation.output_dir / "runs" / run.run_id).resolve()
+        run_dir.mkdir(parents=True, exist_ok=True)
+        log_path = run_dir / "run.log"
+        result_path = run_dir / "result.json"
+        deadline = self._deadline_for_run(automation.timeout_seconds)
+        stage = "daemon_ready"
+        self.store.add_run_event(
+            run_id,
+            AutomationRunEvent(
+                run_id=run_id,
+                event_type="task_started",
+                message="Task execution started.",
+            ),
+        )
+        try:
+            client = BrowserCliTaskClient()
+            self._run_with_timeout(
+                lambda: client.command("runtime-status"),
+                timeout_seconds=self._remaining_timeout(deadline, stage="daemon_ready"),
+                timeout_message=(
+                    f"Automation run timed out during daemon readiness after "
+                    f"{automation.timeout_seconds} seconds."
+                ),
+            )
+            self.store.add_run_event(
+                run_id,
+                AutomationRunEvent(
+                    run_id=run_id,
+                    event_type="browser_daemon_ready",
+                    message="Browser daemon is reachable.",
+                ),
+            )
+        except Exception as exc:
+            self.store.add_run_event(
+                run_id,
+                AutomationRunEvent(
+                    run_id=run_id,
+                    event_type="browser_daemon_unavailable",
+                    message=str(exc),
+                ),
+            )
+
+        with log_path.open("a", encoding="utf-8") as log_handle:
+            try:
+                hook_env = {
+                    "BROWSER_CLI_AUTOMATION_ID": automation.id,
+                    "BROWSER_CLI_AUTOMATION_NAME": automation.name,
+                    "BROWSER_CLI_TASK_PATH": str(automation.task_path),
+                    "BROWSER_CLI_AUTOMATION_STATUS": "running",
+                }
+                stage = "before_hooks"
+                before_hooks = run_hook_commands(
+                    automation.before_run_hooks,
+                    cwd=automation.task_path.parent,
+                    extra_env=hook_env,
+                    timeout_seconds=self._remaining_timeout(deadline, stage=stage),
+                )
+                if before_hooks:
+                    log_handle.write(
+                        json.dumps({"before_hooks": before_hooks}, ensure_ascii=False) + "\n"
+                    )
+                stage = "task_execution"
+                result = self._run_task_entrypoint_with_timeout(
+                    task_path=automation.task_path,
+                    entrypoint=automation.entrypoint,
+                    inputs=run.effective_inputs,
+                    artifacts_dir=run_dir,
+                    automation_path=automation.output_dir,
+                    automation_name=automation.name,
+                    log_path=log_path,
+                    timeout_seconds=self._remaining_timeout(deadline, stage=stage),
+                )
+                stage = "persist_result"
+                self._ensure_time_remaining(deadline, stage=stage)
+                result_path.write_text(
+                    json.dumps(result, ensure_ascii=False, indent=2),
+                    encoding="utf-8",
+                )
+                if automation.result_json_path is not None:
+                    self._ensure_time_remaining(deadline, stage=stage)
+                    automation.result_json_path.parent.mkdir(parents=True, exist_ok=True)
+                    automation.result_json_path.write_text(
+                        json.dumps(result, ensure_ascii=False, indent=2),
+                        encoding="utf-8",
+                    )
+                stage = "after_success_hooks"
+                success_hooks = run_hook_commands(
+                    automation.after_success_hooks,
+                    cwd=automation.task_path.parent,
+                    extra_env={**hook_env, "BROWSER_CLI_AUTOMATION_STATUS": "success"},
+                    timeout_seconds=self._remaining_timeout(deadline, stage=stage),
+                )
+                if success_hooks:
+                    log_handle.write(
+                        json.dumps({"after_success_hooks": success_hooks}, ensure_ascii=False)
+                        + "\n"
+                    )
+                self.store.complete_run(
+                    run_id,
+                    status="success",
+                    result_json_path=result_path,
+                    artifacts_dir=run_dir,
+                    log_path=log_path,
+                )
+            except Exception as exc:
+                timed_out = isinstance(exc, AutomationRunTimeoutError)
+                if timed_out:
+                    self.store.add_run_event(
+                        run_id,
+                        AutomationRunEvent(
+                            run_id=run_id,
+                            event_type="run_timed_out",
+                            message=str(exc),
+                            payload={"stage": stage},
+                        ),
+                    )
+                try:
+                    failure_hooks = run_hook_commands(
+                        automation.after_failure_hooks,
+                        cwd=automation.task_path.parent,
+                        extra_env={
+                            "BROWSER_CLI_AUTOMATION_ID": automation.id,
+                            "BROWSER_CLI_AUTOMATION_NAME": automation.name,
+                            "BROWSER_CLI_TASK_PATH": str(automation.task_path),
+                            "BROWSER_CLI_AUTOMATION_STATUS": "failure",
+                        },
+                        timeout_seconds=FAILURE_HOOK_TIMEOUT_SECONDS,
+                    )
+                    if failure_hooks:
+                        log_handle.write(
+                            json.dumps({"after_failure_hooks": failure_hooks}, ensure_ascii=False)
+                            + "\n"
+                        )
+                except Exception:
+                    logger.exception("Automation failure hooks failed for %s", automation.id)
+                logger.exception("Automation run failed: %s", run_id)
+                log_handle.write(f"\nERROR: {exc}\n")
+                error_code = (
+                    exc.error_code
+                    if isinstance(exc, OperationFailedError)
+                    else error_codes.AUTOMATION_RUN_FAILED
+                )
+                self.store.complete_run(
+                    run_id,
+                    status="failed",
+                    error_code=error_code,
+                    error_message=str(exc),
+                    result_json_path=result_path if result_path.exists() else None,
+                    artifacts_dir=run_dir,
+                    log_path=log_path,
+                )
+                if not timed_out and automation.retry_attempts > run.attempt_number:
+                    retry_run = self.store.retry_run(run_id)
+                    self.store.add_run_event(
+                        retry_run.run_id,
+                        AutomationRunEvent(
+                            run_id=retry_run.run_id,
+                            event_type="retry_scheduled",
+                            message=f"Retry scheduled after failed run {run_id}.",
+                        ),
+                    )
+
+    @staticmethod
+    def _deadline_for_run(timeout_seconds: float | None) -> float | None:
+        if timeout_seconds is None or timeout_seconds <= 0:
+            return None
+        return time.monotonic() + timeout_seconds
+
+    @staticmethod
+    def _remaining_timeout(deadline: float | None, *, stage: str) -> float | None:
+        if deadline is None:
+            return None
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            raise AutomationRunTimeoutError(
+                f"Automation run timed out during {stage} before work could continue."
+            )
+        return remaining
+
+    @staticmethod
+    def _ensure_time_remaining(deadline: float | None, *, stage: str) -> None:
+        _ = AutomationServiceRuntime._remaining_timeout(deadline, stage=stage)
+
+    @staticmethod
+    def _run_with_timeout(
+        fn,
+        *,
+        timeout_seconds: float | None,
+        timeout_message: str,
+    ):
+        if timeout_seconds is None:
+            return fn()
+        result_box: dict[str, Any] = {}
+        error_box: dict[str, BaseException] = {}
+
+        def _target() -> None:
+            try:
+                result_box["value"] = fn()
+            except BaseException as exc:  # noqa: BLE001
+                error_box["error"] = exc
+
+        thread = threading.Thread(target=_target, daemon=True)
+        thread.start()
+        thread.join(timeout=timeout_seconds)
+        if thread.is_alive():
+            raise AutomationRunTimeoutError(timeout_message)
+        if "error" in error_box:
+            raise error_box["error"]
+        return result_box.get("value")
+
+    @staticmethod
+    def _run_task_entrypoint_with_timeout(
+        *,
+        task_path: Path,
+        entrypoint: str,
+        inputs: dict[str, Any],
+        artifacts_dir: Path,
+        automation_path: Path | None,
+        automation_name: str | None,
+        log_path: Path,
+        timeout_seconds: float | None,
+    ) -> dict[str, Any]:
+        if timeout_seconds is None:
+            timeout_seconds = None
+        context = multiprocessing.get_context("spawn")
+        queue = context.Queue()
+        process = context.Process(
+            target=_run_task_entrypoint_child,
+            kwargs={
+                "queue": queue,
+                "task_path": str(task_path),
+                "entrypoint": entrypoint,
+                "inputs": inputs,
+                "artifacts_dir": str(artifacts_dir),
+                "automation_path": str(automation_path) if automation_path else None,
+                "automation_name": automation_name,
+                "log_path": str(log_path),
+            },
+            daemon=True,
+        )
+        process.start()
+        process.join(timeout=timeout_seconds)
+        if process.is_alive():
+            process.terminate()
+            process.join(timeout=1.0)
+            raise AutomationRunTimeoutError(
+                f"Automation run timed out during task execution after {timeout_seconds} seconds."
+            )
+        if queue.empty():
+            raise OperationFailedError("Task worker exited without returning a result.")
+        payload = queue.get()
+        if bool(payload.get("ok")):
+            return dict(payload.get("result") or {})
+        raise OperationFailedError(
+            str(payload.get("error_message") or "Task worker failed."),
+            error_code=str(payload.get("error_code") or error_codes.AUTOMATION_RUN_FAILED),
+        )

browser_cli/automation/toml.py

@@ -0,0 +1,35 @@
+"""Minimal TOML rendering helpers for automation manifests."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterable
+from typing import Any
+
+
+def dumps_toml_sections(sections: Iterable[tuple[str, dict[str, Any]]]) -> str:
+    lines: list[str] = []
+    first_section = True
+    for section_name, values in sections:
+        if not first_section:
+            lines.append("")
+        first_section = False
+        lines.append(f"[{section_name}]")
+        for key, value in values.items():
+            if value is None:
+                continue
+            lines.append(f"{key} = {_toml_value(value)}")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def _toml_value(value: Any) -> str:
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, int | float):
+        return str(value)
+    if isinstance(value, str):
+        return json.dumps(value, ensure_ascii=False)
+    if isinstance(value, list | tuple):
+        return "[" + ", ".join(_toml_value(item) for item in value) + "]"
+    raise TypeError(f"Unsupported TOML value type: {type(value)!r}")

browser_cli/automation/web/__init__.py

@@ -0,0 +1,5 @@
+"""automation Web UI assets."""
+
+from browser_cli.automation.web.assets import render_index_html
+
+__all__ = ["render_index_html"]