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

browser_cli/automation/projections.py

@@ -0,0 +1,279 @@
+"""Shared semantic projections for automation manifests and live definitions."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from browser_cli.automation.models import (
+    AutomationManifest,
+    PersistedAutomationDefinition,
+)
+from browser_cli.automation.toml import dumps_toml_sections
+
+
+def manifest_to_persisted_definition(
+    manifest: AutomationManifest,
+    *,
+    enabled: bool = False,
+) -> PersistedAutomationDefinition:
+    return PersistedAutomationDefinition(
+        id=manifest.automation.id,
+        name=manifest.automation.name,
+        task_path=manifest.task.path,
+        task_meta_path=manifest.task.meta_path,
+        output_dir=manifest.outputs.artifact_dir,
+        description=manifest.automation.description,
+        version=str(manifest.automation.version),
+        entrypoint=manifest.task.entrypoint,
+        enabled=enabled,
+        schedule_kind=str(manifest.schedule.get("mode") or "manual"),
+        schedule_payload=dict(manifest.schedule),
+        timezone=str(manifest.schedule.get("timezone") or "UTC"),
+        result_json_path=manifest.outputs.result_json_path,
+        stdout_mode=manifest.outputs.stdout,
+        input_overrides=dict(manifest.inputs),
+        before_run_hooks=manifest.hooks.before_run,
+        after_success_hooks=manifest.hooks.after_success,
+        after_failure_hooks=manifest.hooks.after_failure,
+        retry_attempts=manifest.runtime.retry_attempts,
+        retry_backoff_seconds=manifest.runtime.retry_backoff_seconds,
+        timeout_seconds=manifest.runtime.timeout_seconds,
+        log_level=manifest.runtime.log_level,
+    )
+
+
+def payload_to_persisted_definition(payload: dict[str, Any]) -> PersistedAutomationDefinition:
+    automation_id = str(payload.get("id") or "").strip()
+    if not automation_id:
+        raise ValueError("Automation id is required.")
+    output_dir_raw = str(payload.get("output_dir") or "").strip()
+    result_json_raw = str(payload.get("result_json_path") or "").strip()
+    return PersistedAutomationDefinition(
+        id=automation_id,
+        name=str(payload.get("name") or automation_id),
+        description=str(payload.get("description") or ""),
+        version=str(payload.get("version") or "0.1.0"),
+        task_path=Path(str(payload.get("task_path") or "")),
+        task_meta_path=Path(str(payload.get("task_meta_path") or "")),
+        entrypoint=str(payload.get("entrypoint") or "run"),
+        enabled=bool(payload.get("enabled")),
+        definition_status=str(payload.get("definition_status") or "valid"),
+        definition_error=str(payload.get("definition_error"))
+        if payload.get("definition_error")
+        else None,
+        schedule_kind=str(payload.get("schedule_kind") or "manual"),
+        schedule_payload=dict(payload.get("schedule_payload") or {}),
+        timezone=str(payload.get("timezone") or "UTC"),
+        output_dir=Path(output_dir_raw) if output_dir_raw else Path(),
+        result_json_path=Path(result_json_raw) if result_json_raw else None,
+        stdout_mode=str(payload.get("stdout_mode") or "json"),
+        input_overrides=dict(payload.get("input_overrides") or {}),
+        before_run_hooks=tuple(payload.get("before_run_hooks") or []),
+        after_success_hooks=tuple(payload.get("after_success_hooks") or []),
+        after_failure_hooks=tuple(payload.get("after_failure_hooks") or []),
+        retry_attempts=int(payload.get("retry_attempts") or 0),
+        retry_backoff_seconds=int(payload.get("retry_backoff_seconds") or 0),
+        timeout_seconds=float(payload["timeout_seconds"])
+        if payload.get("timeout_seconds") is not None
+        else None,
+        log_level=str(payload.get("log_level") or "info"),
+    )
+
+
+def persisted_definition_to_manifest_toml(
+    automation: PersistedAutomationDefinition,
+) -> str:
+    return dumps_toml_sections(
+        [
+            (
+                "automation",
+                {
+                    "id": automation.id,
+                    "name": automation.name,
+                    "description": automation.description,
+                    "version": automation.version,
+                },
+            ),
+            (
+                "task",
+                {
+                    "path": str(automation.task_path),
+                    "meta_path": str(automation.task_meta_path),
+                    "entrypoint": automation.entrypoint,
+                },
+            ),
+            ("inputs", dict(automation.input_overrides)),
+            ("schedule", _schedule_values(automation)),
+            (
+                "outputs",
+                {
+                    "artifact_dir": str(automation.output_dir),
+                    "result_json_path": str(automation.result_json_path)
+                    if automation.result_json_path
+                    else None,
+                    "stdout": automation.stdout_mode,
+                },
+            ),
+            (
+                "hooks",
+                {
+                    "before_run": list(automation.before_run_hooks),
+                    "after_success": list(automation.after_success_hooks),
+                    "after_failure": list(automation.after_failure_hooks),
+                },
+            ),
+            (
+                "runtime",
+                {
+                    "retry_attempts": automation.retry_attempts,
+                    "retry_backoff_seconds": automation.retry_backoff_seconds,
+                    "timeout_seconds": automation.timeout_seconds,
+                    "log_level": automation.log_level,
+                },
+            ),
+        ]
+    )
+
+
+def manifest_to_snapshot_manifest_toml(
+    manifest: AutomationManifest,
+    *,
+    version: int,
+    task_path: Path,
+    task_meta_path: Path,
+    output_dir: Path,
+) -> str:
+    result_json_path = _remap_result_json_path(
+        manifest.outputs.artifact_dir,
+        manifest.outputs.result_json_path,
+        output_dir,
+    )
+    return dumps_toml_sections(
+        [
+            (
+                "automation",
+                {
+                    "id": manifest.automation.id,
+                    "name": manifest.automation.name,
+                    "description": manifest.automation.description,
+                    "version": str(version),
+                },
+            ),
+            (
+                "task",
+                {
+                    "path": str(task_path),
+                    "meta_path": str(task_meta_path),
+                    "entrypoint": manifest.task.entrypoint,
+                },
+            ),
+            ("inputs", dict(manifest.inputs)),
+            ("schedule", dict(manifest.schedule)),
+            (
+                "outputs",
+                {
+                    "artifact_dir": str(output_dir),
+                    "result_json_path": str(result_json_path) if result_json_path else None,
+                    "stdout": manifest.outputs.stdout,
+                },
+            ),
+            (
+                "hooks",
+                {
+                    "before_run": list(manifest.hooks.before_run),
+                    "after_success": list(manifest.hooks.after_success),
+                    "after_failure": list(manifest.hooks.after_failure),
+                },
+            ),
+            (
+                "runtime",
+                {
+                    "retry_attempts": manifest.runtime.retry_attempts,
+                    "retry_backoff_seconds": manifest.runtime.retry_backoff_seconds,
+                    "timeout_seconds": manifest.runtime.timeout_seconds,
+                    "log_level": manifest.runtime.log_level,
+                },
+            ),
+        ]
+    )
+
+
+def manifest_to_config_payload(manifest: AutomationManifest) -> dict[str, object]:
+    return {
+        "id": manifest.automation.id,
+        "name": manifest.automation.name,
+        "description": manifest.automation.description,
+        "version": str(manifest.automation.version),
+        "task_path": str(manifest.task.path),
+        "task_meta_path": str(manifest.task.meta_path),
+        "entrypoint": manifest.task.entrypoint,
+        "schedule_kind": str(manifest.schedule.get("mode") or "manual"),
+        "schedule_payload": dict(manifest.schedule),
+        "timezone": str(manifest.schedule.get("timezone") or "UTC"),
+        "output_dir": str(manifest.outputs.artifact_dir),
+        "result_json_path": str(manifest.outputs.result_json_path)
+        if manifest.outputs.result_json_path
+        else None,
+        "stdout_mode": manifest.outputs.stdout,
+        "input_overrides": dict(manifest.inputs),
+        "before_run_hooks": list(manifest.hooks.before_run),
+        "after_success_hooks": list(manifest.hooks.after_success),
+        "after_failure_hooks": list(manifest.hooks.after_failure),
+        "retry_attempts": manifest.runtime.retry_attempts,
+        "retry_backoff_seconds": manifest.runtime.retry_backoff_seconds,
+        "timeout_seconds": manifest.runtime.timeout_seconds,
+        "log_level": manifest.runtime.log_level,
+    }
+
+
+def persisted_definition_to_config_payload(
+    automation: PersistedAutomationDefinition,
+) -> dict[str, object]:
+    return {
+        "id": automation.id,
+        "name": automation.name,
+        "description": automation.description,
+        "version": automation.version,
+        "task_path": str(automation.task_path),
+        "task_meta_path": str(automation.task_meta_path),
+        "entrypoint": automation.entrypoint,
+        "schedule_kind": automation.schedule_kind,
+        "schedule_payload": dict(automation.schedule_payload),
+        "timezone": automation.timezone,
+        "output_dir": str(automation.output_dir),
+        "result_json_path": str(automation.result_json_path)
+        if automation.result_json_path
+        else None,
+        "stdout_mode": automation.stdout_mode,
+        "input_overrides": dict(automation.input_overrides),
+        "before_run_hooks": list(automation.before_run_hooks),
+        "after_success_hooks": list(automation.after_success_hooks),
+        "after_failure_hooks": list(automation.after_failure_hooks),
+        "retry_attempts": automation.retry_attempts,
+        "retry_backoff_seconds": automation.retry_backoff_seconds,
+        "timeout_seconds": automation.timeout_seconds,
+        "log_level": automation.log_level,
+    }
+
+
+def _schedule_values(automation: PersistedAutomationDefinition) -> dict[str, Any]:
+    values = {"mode": automation.schedule_kind, "timezone": automation.timezone}
+    for key, value in automation.schedule_payload.items():
+        if key not in {"mode", "timezone"}:
+            values[key] = value
+    return values
+
+
+def _remap_result_json_path(
+    source_artifact_dir: Path,
+    source_result_json_path: Path | None,
+    target_artifact_dir: Path,
+) -> Path | None:
+    if source_result_json_path is None:
+        return None
+    try:
+        relative = source_result_json_path.relative_to(source_artifact_dir)
+    except ValueError:
+        return target_artifact_dir / source_result_json_path.name
+    return target_artifact_dir / relative

browser_cli/automation/publisher.py

@@ -0,0 +1,153 @@
+"""Publish local task directories as versioned automation snapshots."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from browser_cli.automation.loader import load_automation_manifest
+from browser_cli.automation.projections import manifest_to_snapshot_manifest_toml
+from browser_cli.automation.toml import dumps_toml_sections
+from browser_cli.constants import AppPaths
+from browser_cli.task_runtime import validate_task_dir
+
+
+@dataclass(slots=True, frozen=True)
+class PublishedAutomation:
+    automation_id: str
+    automation_name: str
+    version: int
+    snapshot_dir: Path
+    manifest_path: Path
+    output_dir: Path
+    manifest_source: str
+
+
+def publish_task_dir(task_dir: Path, *, app_paths: AppPaths) -> PublishedAutomation:
+    metadata = validate_task_dir(task_dir)
+    automation_id = str(metadata["task"]["id"])
+    automation_name = str(metadata["task"]["name"])
+    automation_root = app_paths.automations_dir / automation_id
+    versions_dir = automation_root / "versions"
+    versions_dir.mkdir(parents=True, exist_ok=True)
+    while True:
+        version = _next_version(versions_dir)
+        snapshot_dir = versions_dir / str(version)
+        try:
+            snapshot_dir.mkdir(parents=True, exist_ok=False)
+        except FileExistsError:
+            continue
+        break
+
+    task_path = snapshot_dir / "task.py"
+    task_meta_path = snapshot_dir / "task.meta.json"
+    shutil.copy2(task_dir / "task.py", task_path)
+    shutil.copy2(task_dir / "task.meta.json", task_meta_path)
+
+    source_manifest_path = task_dir / "automation.toml"
+    if source_manifest_path.exists():
+        manifest_source = "task_dir"
+        source_manifest = load_automation_manifest(source_manifest_path)
+        rendered_manifest = manifest_to_snapshot_manifest_toml(
+            source_manifest,
+            version=version,
+            task_path=task_path,
+            task_meta_path=task_meta_path,
+            output_dir=automation_root,
+        )
+    else:
+        manifest_source = "generated_defaults"
+        rendered_manifest = render_automation_manifest(
+            automation_id=automation_id,
+            name=automation_name,
+            version=version,
+            task_path=task_path,
+            task_meta_path=task_meta_path,
+            output_dir=automation_root,
+        )
+
+    manifest_path = snapshot_dir / "automation.toml"
+    manifest_path.write_text(rendered_manifest, encoding="utf-8")
+    (snapshot_dir / "publish.json").write_text(
+        json.dumps(
+            {
+                "automation_id": automation_id,
+                "name": automation_name,
+                "version": version,
+                "manifest_source": manifest_source,
+                "source_task_path": str(task_dir),
+                "snapshot_dir": str(snapshot_dir),
+            },
+            ensure_ascii=False,
+            indent=2,
+        ),
+        encoding="utf-8",
+    )
+    return PublishedAutomation(
+        automation_id=automation_id,
+        automation_name=automation_name,
+        version=version,
+        snapshot_dir=snapshot_dir,
+        manifest_path=manifest_path,
+        output_dir=automation_root,
+        manifest_source=manifest_source,
+    )
+
+
+def render_automation_manifest(
+    *,
+    automation_id: str,
+    name: str,
+    version: int,
+    task_path: Path,
+    task_meta_path: Path,
+    output_dir: Path,
+) -> str:
+    sections: list[tuple[str, dict[str, Any]]] = [
+        (
+            "automation",
+            {
+                "id": str(automation_id),
+                "name": str(name),
+                "version": str(version),
+            },
+        ),
+        (
+            "task",
+            {
+                "path": str(task_path),
+                "meta_path": str(task_meta_path),
+                "entrypoint": "run",
+            },
+        ),
+        ("inputs", {}),
+        ("schedule", {"mode": "manual", "timezone": "UTC"}),
+        ("outputs", {"artifact_dir": str(output_dir), "stdout": "json"}),
+        (
+            "hooks",
+            {
+                "before_run": [],
+                "after_success": [],
+                "after_failure": [],
+            },
+        ),
+        (
+            "runtime",
+            {
+                "retry_attempts": 0,
+                "retry_backoff_seconds": 0,
+                "log_level": "info",
+            },
+        ),
+    ]
+    return dumps_toml_sections(sections)
+
+
+def _next_version(versions_dir: Path) -> int:
+    versions = [
+        int(path.name) for path in versions_dir.iterdir() if path.is_dir() and path.name.isdigit()
+    ]
+    return max(versions, default=0) + 1

browser_cli/automation/scheduler/__init__.py

@@ -0,0 +1,5 @@
+"""automation schedule helpers."""
+
+from browser_cli.automation.scheduler.schedule import compute_next_run_at, normalize_schedule
+
+__all__ = ["compute_next_run_at", "normalize_schedule"]

browser_cli/automation/scheduler/schedule.py

@@ -0,0 +1,113 @@
+"""Schedule normalization and next-run calculation."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from typing import Any
+from zoneinfo import ZoneInfo
+
+from browser_cli.errors import InvalidInputError
+
+WEEKDAY_NAMES = {
+    "monday": 0,
+    "tuesday": 1,
+    "wednesday": 2,
+    "thursday": 3,
+    "friday": 4,
+    "saturday": 5,
+    "sunday": 6,
+}
+
+
+def normalize_schedule(
+    kind: str,
+    payload: dict[str, Any] | None,
+    *,
+    timezone_name: str,
+) -> tuple[str, dict[str, Any], str]:
+    normalized_kind = (kind or "manual").strip().lower() or "manual"
+    normalized_payload = dict(payload or {})
+    try:
+        ZoneInfo(timezone_name)
+    except Exception as exc:
+        raise InvalidInputError(f"Invalid automation timezone: {timezone_name}") from exc
+
+    if normalized_kind == "manual":
+        return normalized_kind, {}, timezone_name
+    if normalized_kind == "interval":
+        seconds = int(normalized_payload.get("interval_seconds") or 0)
+        if seconds <= 0:
+            raise InvalidInputError("Interval automations require positive interval_seconds.")
+        return normalized_kind, {"interval_seconds": seconds}, timezone_name
+    if normalized_kind == "daily":
+        hour = int(
+            normalized_payload.get("hour") if normalized_payload.get("hour") is not None else -1
+        )
+        minute = int(
+            normalized_payload.get("minute") if normalized_payload.get("minute") is not None else -1
+        )
+        _validate_hour_minute(hour, minute)
+        return normalized_kind, {"hour": hour, "minute": minute}, timezone_name
+    if normalized_kind == "weekly":
+        weekday = str(normalized_payload.get("weekday") or "").strip().lower()
+        hour = int(
+            normalized_payload.get("hour") if normalized_payload.get("hour") is not None else -1
+        )
+        minute = int(
+            normalized_payload.get("minute") if normalized_payload.get("minute") is not None else -1
+        )
+        if weekday not in WEEKDAY_NAMES:
+            expected = ", ".join(sorted(WEEKDAY_NAMES))
+            raise InvalidInputError(f"Weekly automations require weekday in {{{expected}}}.")
+        _validate_hour_minute(hour, minute)
+        return normalized_kind, {"weekday": weekday, "hour": hour, "minute": minute}, timezone_name
+    raise InvalidInputError(f"Unsupported automation schedule mode: {normalized_kind}")
+
+
+def compute_next_run_at(
+    kind: str,
+    payload: dict[str, Any] | None,
+    *,
+    timezone_name: str,
+    now: datetime | None = None,
+) -> str | None:
+    normalized_kind, normalized_payload, timezone_name = normalize_schedule(
+        kind, payload, timezone_name=timezone_name
+    )
+    if normalized_kind == "manual":
+        return None
+    moment = now or datetime.now(timezone.utc)
+    if moment.tzinfo is None:
+        moment = moment.replace(tzinfo=timezone.utc)
+    if normalized_kind == "interval":
+        seconds = int(normalized_payload["interval_seconds"])
+        return _to_utc_iso(moment + timedelta(seconds=seconds))
+    zone = ZoneInfo(timezone_name)
+    local_now = moment.astimezone(zone)
+    if normalized_kind == "daily":
+        hour = int(normalized_payload["hour"])
+        minute = int(normalized_payload["minute"])
+        candidate = local_now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+        if candidate <= local_now:
+            candidate = candidate + timedelta(days=1)
+        return _to_utc_iso(candidate.astimezone(timezone.utc))
+    weekday = WEEKDAY_NAMES[str(normalized_payload["weekday"])]
+    hour = int(normalized_payload["hour"])
+    minute = int(normalized_payload["minute"])
+    candidate = local_now.replace(hour=hour, minute=minute, second=0, microsecond=0)
+    days_ahead = (weekday - local_now.weekday()) % 7
+    candidate = candidate + timedelta(days=days_ahead)
+    if candidate <= local_now:
+        candidate = candidate + timedelta(days=7)
+    return _to_utc_iso(candidate.astimezone(timezone.utc))
+
+
+def _validate_hour_minute(hour: int, minute: int) -> None:
+    if hour < 0 or hour > 23:
+        raise InvalidInputError("automation schedule hour must be between 0 and 23.")
+    if minute < 0 or minute > 59:
+        raise InvalidInputError("automation schedule minute must be between 0 and 59.")
+
+
+def _to_utc_iso(value: datetime) -> str:
+    return value.astimezone(timezone.utc).isoformat()

browser_cli/automation/service/__init__.py

@@ -0,0 +1,8 @@
+"""automation service helpers."""
+
+from browser_cli.automation.service.client import (
+    ensure_automation_service_running,
+    request_automation_service,
+)
+
+__all__ = ["ensure_automation_service_running", "request_automation_service"]

browser_cli/automation/service/__main__.py

@@ -0,0 +1,64 @@
+"""automation service process entrypoint."""
+
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+from pathlib import Path
+
+from browser_cli import __version__
+from browser_cli.automation.api import AutomationHttpServer, AutomationRequestHandler
+from browser_cli.automation.service.client import (
+    _write_automation_service_run_info,
+    remove_automation_service_run_info,
+)
+from browser_cli.automation.service.runtime import (
+    AUTOMATION_SERVICE_RUNTIME_VERSION,
+    AutomationServiceRuntime,
+)
+from browser_cli.constants import APP_HOME_ENV, get_app_paths
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="browser-cli automation-service")
+    parser.add_argument("--home", help="Override Browser CLI home.")
+    args = parser.parse_args(argv)
+    if args.home:
+        os.environ[APP_HOME_ENV] = str(Path(args.home).expanduser())
+    logging.basicConfig(level=logging.INFO)
+    runtime: AutomationServiceRuntime | None = None
+    server: AutomationHttpServer | None = None
+    try:
+        runtime = AutomationServiceRuntime()
+        runtime.start()
+        app_paths = get_app_paths()
+        server = AutomationHttpServer(
+            (app_paths.automation_service_host, app_paths.automation_service_port or 0),
+            AutomationRequestHandler,
+            runtime,
+        )
+        host, port = server.server_address[:2]
+        _write_automation_service_run_info(
+            {
+                "pid": os.getpid(),
+                "host": host,
+                "port": port,
+                "started_at": runtime.started_at,
+                "package_version": __version__,
+                "runtime_version": AUTOMATION_SERVICE_RUNTIME_VERSION,
+            }
+        )
+        server.serve_forever(poll_interval=0.5)
+    finally:
+        if runtime is not None:
+            runtime.stop()
+            runtime.join(timeout=2.0)
+        if server is not None:
+            server.server_close()
+        remove_automation_service_run_info()
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())