android-emu-agent 0.1.3__py3-none-any.whl

android_emu_agent/cli/commands/wait.py

@@ -0,0 +1,132 @@
+"""Wait/synchronization CLI commands."""
+
+from __future__ import annotations
+
+import typer
+
+from android_emu_agent.cli.daemon_client import DaemonClient
+from android_emu_agent.cli.utils import handle_response
+
+app = typer.Typer(help="Wait/synchronization commands")
+
+
+def _build_selector(
+    text: str | None, resource_id: str | None, desc: str | None
+) -> dict[str, str] | None:
+    selector: dict[str, str] = {}
+    if text:
+        selector["text"] = text
+    if resource_id:
+        selector["resourceId"] = resource_id
+    if desc:
+        selector["description"] = desc
+    return selector or None
+
+
+@app.command("idle")
+def wait_idle(
+    session_id: str = typer.Argument(..., help="Session ID"),
+    timeout_ms: int | None = typer.Option(None, "--timeout-ms", help="Timeout in ms"),
+    json_output: bool = typer.Option(False, "--json", help="Output JSON"),
+) -> None:
+    """Wait for UI idle."""
+    client = DaemonClient()
+    resp = client.request(
+        "POST",
+        "/wait/idle",
+        json_body={"session_id": session_id, "timeout_ms": timeout_ms},
+    )
+    client.close()
+    handle_response(resp, json_output=json_output)
+
+
+@app.command("activity")
+def wait_activity(
+    session_id: str = typer.Argument(..., help="Session ID"),
+    activity: str = typer.Argument(..., help="Activity substring"),
+    timeout_ms: int | None = typer.Option(None, "--timeout-ms", help="Timeout in ms"),
+    json_output: bool = typer.Option(False, "--json", help="Output JSON"),
+) -> None:
+    """Wait for an activity to appear."""
+    client = DaemonClient()
+    resp = client.request(
+        "POST",
+        "/wait/activity",
+        json_body={"session_id": session_id, "activity": activity, "timeout_ms": timeout_ms},
+    )
+    client.close()
+    handle_response(resp, json_output=json_output)
+
+
+@app.command("text")
+def wait_text(
+    session_id: str = typer.Argument(..., help="Session ID"),
+    text: str = typer.Argument(..., help="Text to wait for"),
+    timeout_ms: int | None = typer.Option(None, "--timeout-ms", help="Timeout in ms"),
+    json_output: bool = typer.Option(False, "--json", help="Output JSON"),
+) -> None:
+    """Wait for text to appear."""
+    client = DaemonClient()
+    resp = client.request(
+        "POST",
+        "/wait/text",
+        json_body={"session_id": session_id, "text": text, "timeout_ms": timeout_ms},
+    )
+    client.close()
+    handle_response(resp, json_output=json_output)
+
+
+@app.command("exists")
+def wait_exists(
+    session_id: str = typer.Argument(..., help="Session ID"),
+    ref: str | None = typer.Option(None, "--ref", help="Element ref (@a1)"),
+    text: str | None = typer.Option(None, "--text", help="Text selector"),
+    resource_id: str | None = typer.Option(None, "--id", help="Resource ID selector"),
+    desc: str | None = typer.Option(None, "--desc", help="Content-desc selector"),
+    timeout_ms: int | None = typer.Option(None, "--timeout-ms", help="Timeout in ms"),
+    json_output: bool = typer.Option(False, "--json", help="Output JSON"),
+) -> None:
+    """Wait for element to exist."""
+    selector = _build_selector(text, resource_id, desc)
+
+    client = DaemonClient()
+    resp = client.request(
+        "POST",
+        "/wait/exists",
+        json_body={
+            "session_id": session_id,
+            "ref": ref,
+            "selector": selector,
+            "timeout_ms": timeout_ms,
+        },
+    )
+    client.close()
+    handle_response(resp, json_output=json_output)
+
+
+@app.command("gone")
+def wait_gone(
+    session_id: str = typer.Argument(..., help="Session ID"),
+    ref: str | None = typer.Option(None, "--ref", help="Element ref (@a1)"),
+    text: str | None = typer.Option(None, "--text", help="Text selector"),
+    resource_id: str | None = typer.Option(None, "--id", help="Resource ID selector"),
+    desc: str | None = typer.Option(None, "--desc", help="Content-desc selector"),
+    timeout_ms: int | None = typer.Option(None, "--timeout-ms", help="Timeout in ms"),
+    json_output: bool = typer.Option(False, "--json", help="Output JSON"),
+) -> None:
+    """Wait for element to disappear."""
+    selector = _build_selector(text, resource_id, desc)
+
+    client = DaemonClient()
+    resp = client.request(
+        "POST",
+        "/wait/gone",
+        json_body={
+            "session_id": session_id,
+            "ref": ref,
+            "selector": selector,
+            "timeout_ms": timeout_ms,
+        },
+    )
+    client.close()
+    handle_response(resp, json_output=json_output)

android_emu_agent/cli/daemon_client.py

@@ -0,0 +1,185 @@
+"""Daemon control and HTTP client for CLI commands."""
+
+from __future__ import annotations
+
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+STATE_DIR = Path.home() / ".android-emu-agent"
+SOCKET_PATH = Path("/tmp/android-emu-agent.sock")
+PID_FILE = STATE_DIR / "daemon.pid"
+LOG_FILE = STATE_DIR / "daemon.log"
+BASE_URL = "http://android-emu-agent"
+
+
+class DaemonController:
+    """Start/stop/status for the daemon process."""
+
+    def __init__(self, socket_path: Path = SOCKET_PATH) -> None:
+        self.socket_path = socket_path
+        STATE_DIR.mkdir(parents=True, exist_ok=True)
+
+    def _pid_running(self, pid: int) -> bool:
+        try:
+            os.kill(pid, 0)
+        except OSError:
+            return False
+        return True
+
+    def _read_pid(self) -> int | None:
+        if not PID_FILE.exists():
+            return None
+        try:
+            return int(PID_FILE.read_text().strip())
+        except ValueError:
+            return None
+
+    def _socket_healthy(self) -> bool:
+        if not self.socket_path.exists():
+            return False
+        client = httpx.Client(
+            transport=httpx.HTTPTransport(uds=str(self.socket_path)),
+            base_url=BASE_URL,
+            timeout=1.0,
+        )
+        try:
+            resp = client.get("/health")
+            return resp.status_code == 200
+        except httpx.HTTPError:
+            return False
+        finally:
+            client.close()
+
+    def health(self) -> bool:
+        """Return True if the daemon socket responds to /health."""
+        return self._socket_healthy()
+
+    def start(self) -> int:
+        """Start the daemon; returns PID, or -1 if already running but PID unknown."""
+        pid = self._read_pid()
+        if pid and self._pid_running(pid):
+            return pid
+        if pid:
+            PID_FILE.unlink(missing_ok=True)
+        if self._socket_healthy():
+            return -1
+
+        LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+        args = [
+            sys.executable,
+            "-m",
+            "uvicorn",
+            "android_emu_agent.daemon.server:app",
+            "--uds",
+            str(self.socket_path),
+            "--log-level",
+            "info",
+        ]
+        with LOG_FILE.open("a", encoding="utf-8") as log_handle:
+            proc = subprocess.Popen(
+                args,
+                stdout=log_handle,
+                stderr=log_handle,
+                start_new_session=True,
+            )
+        PID_FILE.write_text(str(proc.pid))
+        return proc.pid
+
+    def stop(self) -> bool:
+        """Stop the daemon if running."""
+        pid = self._read_pid()
+        if not pid:
+            return False
+        if not self._pid_running(pid):
+            PID_FILE.unlink(missing_ok=True)
+            return False
+
+        os.kill(pid, signal.SIGTERM)
+        for _ in range(20):
+            if not self._pid_running(pid):
+                PID_FILE.unlink(missing_ok=True)
+                return True
+            time.sleep(0.1)
+        return False
+
+    def status(self) -> dict[str, Any]:
+        """Return daemon status summary."""
+        pid = self._read_pid()
+        return {
+            "pid": pid,
+            "pid_running": self._pid_running(pid) if pid else False,
+            "socket": str(self.socket_path),
+            "socket_exists": self.socket_path.exists(),
+        }
+
+
+class DaemonClient:
+    """HTTP client using Unix Domain Socket transport."""
+
+    def __init__(
+        self,
+        socket_path: Path = SOCKET_PATH,
+        *,
+        auto_start: bool = True,
+        timeout: float = 10.0,
+    ) -> None:
+        self.socket_path = socket_path
+        self.auto_start = auto_start
+        self.controller = DaemonController(socket_path)
+        self._client = httpx.Client(
+            transport=httpx.HTTPTransport(uds=str(self.socket_path)),
+            base_url=BASE_URL,
+            timeout=timeout,
+        )
+
+    def close(self) -> None:
+        self._client.close()
+
+    def request(
+        self, method: str, path: str, json_body: dict[str, Any] | None = None
+    ) -> httpx.Response:
+        if self.auto_start:
+            self._ensure_ready()
+
+        try:
+            return self._client.request(method, path, json=json_body)
+        except httpx.TransportError:
+            if not self.auto_start:
+                raise
+            self.controller.start()
+            self._wait_for_health()
+            return self._client.request(method, path, json=json_body)
+
+    def _ensure_ready(self) -> None:
+        try:
+            resp = self._client.get("/health")
+            if resp.status_code == 200:
+                return
+        except httpx.TransportError:
+            pass
+        self.controller.start()
+        self._wait_for_health()
+
+    def _wait_for_health(self) -> None:
+        deadline = time.time() + 5
+        while time.time() < deadline:
+            try:
+                resp = self._client.get("/health")
+                if resp.status_code == 200:
+                    return
+            except httpx.TransportError:
+                pass
+            time.sleep(0.1)
+        raise RuntimeError("Daemon did not become healthy in time")
+
+
+def format_json(data: Any) -> str:
+    return json.dumps(data, indent=2, ensure_ascii=True)

android_emu_agent/cli/main.py

@@ -0,0 +1,52 @@
+"""CLI entry point using Typer."""
+
+from __future__ import annotations
+
+import typer
+
+from android_emu_agent.cli.commands import (
+    action,
+    app_cmd,
+    artifact,
+    daemon,
+    device,
+    emulator,
+    reliability,
+    session,
+    ui,
+    wait,
+)
+from android_emu_agent.cli.commands import (
+    file as file_commands,
+)
+
+app = typer.Typer(
+    name="android-emu-agent",
+    help="LLM-driven Android UI control system",
+    no_args_is_help=True,
+)
+
+
+@app.command()
+def version() -> None:
+    """Show version information."""
+    from android_emu_agent import __version__
+
+    typer.echo(f"android-emu-agent v{__version__}")
+
+
+app.add_typer(daemon.app, name="daemon")
+app.add_typer(device.app, name="device")
+app.add_typer(session.app, name="session")
+app.add_typer(ui.app, name="ui")
+app.add_typer(action.app, name="action")
+app.add_typer(wait.app, name="wait")
+app.add_typer(app_cmd.app, name="app")
+app.add_typer(artifact.app, name="artifact")
+app.add_typer(emulator.app, name="emulator")
+app.add_typer(reliability.app, name="reliability")
+app.add_typer(file_commands.app, name="file")
+
+
+if __name__ == "__main__":
+    app()

android_emu_agent/cli/utils.py

@@ -0,0 +1,171 @@
+"""Shared CLI helpers and constants."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Any, cast
+
+import typer
+
+from android_emu_agent.cli.daemon_client import format_json
+
+RELIABILITY_TIMEOUT = 60.0
+RELIABILITY_BUGREPORT_TIMEOUT = 300.0
+RELIABILITY_PULL_TIMEOUT = 180.0
+RELIABILITY_DUMPHEAP_TIMEOUT = 180.0
+FILE_TRANSFER_TIMEOUT = 120.0
+FILE_APP_TRANSFER_TIMEOUT = 180.0
+
+
+def _parse_response_json(resp: Any) -> dict[str, Any]:
+    try:
+        return cast(dict[str, Any], resp.json())
+    except Exception as exc:  # pragma: no cover - defensive
+        typer.echo("Failed to parse response")
+        raise typer.Exit(code=1) from exc
+
+
+def _maybe_render_error(data: dict[str, Any]) -> None:
+    if not (isinstance(data, dict) and data.get("error")):
+        return
+    error = data["error"]
+    message = f"{error.get('code')}: {error.get('message')}"
+    remediation = error.get("remediation")
+    typer.echo(message)
+    if remediation:
+        typer.echo(f"Hint: {remediation}")
+    raise typer.Exit(code=1)
+
+
+def _maybe_render_done(data: dict[str, Any]) -> bool:
+    if not (isinstance(data, dict) and data.get("status") == "done"):
+        return False
+    message = "✓ Done"
+    if "elapsed_ms" in data:
+        message += f" ({data['elapsed_ms']} ms)"
+    if "path" in data:
+        message += f" -> {data['path']}"
+    typer.echo(message)
+    return True
+
+
+def _maybe_render_output(data: dict[str, Any]) -> bool:
+    if not (isinstance(data, dict) and "output" in data):
+        return False
+    output = data.get("output")
+    if output:
+        typer.echo(output)
+        return True
+    return False
+
+
+def handle_response(resp: Any, json_output: bool = False) -> None:
+    data = _parse_response_json(resp)
+    if json_output:
+        typer.echo(format_json(data))
+        return
+
+    _maybe_render_error(data)
+    if _maybe_render_done(data):
+        return
+    typer.echo(format_json(data))
+
+
+def handle_output_response(resp: Any, json_output: bool = False) -> None:
+    data = _parse_response_json(resp)
+    if json_output:
+        typer.echo(format_json(data))
+        return
+
+    _maybe_render_error(data)
+    if _maybe_render_output(data):
+        return
+    if _maybe_render_done(data):
+        return
+    typer.echo(format_json(data))
+
+
+def handle_response_with_pull(
+    resp: Any,
+    *,
+    json_output: bool = False,
+    pull: bool = False,
+    output: str | None = None,
+) -> None:
+    data = _parse_response_json(resp)
+    pulled_path: Path | None = None
+
+    if pull and not data.get("error"):
+        try:
+            path = data.get("path")
+            if not path:
+                raise typer.BadParameter("Response missing path; cannot pull artifact")
+            pulled_path = pull_artifact_path(path, output)
+            data["pulled_path"] = str(pulled_path)
+        except typer.BadParameter as exc:
+            typer.echo(f"Error: {exc}")
+            raise typer.Exit(code=1) from None
+
+    if json_output:
+        typer.echo(format_json(data))
+        return
+
+    _maybe_render_error(data)
+    if _maybe_render_done(data):
+        if pulled_path:
+            typer.echo(f"✓ Pulled -> {pulled_path}")
+        return
+    typer.echo(format_json(data))
+
+
+def target_payload(device: str | None, session_id: str | None) -> dict[str, Any]:
+    if device and session_id:
+        raise typer.BadParameter("--device and --session are mutually exclusive")
+    if not device and not session_id:
+        raise typer.BadParameter("Provide --device or --session")
+    if device:
+        return {"serial": device}
+    assert session_id is not None
+    return {"session_id": session_id}
+
+
+def resolve_session_id(session_arg: str | None, session_opt: str | None) -> str | None:
+    if session_arg and session_opt:
+        raise typer.BadParameter("Provide session ID once (argument or --session)")
+    return session_arg or session_opt
+
+
+def pull_artifact_path(path_str: str, output: str | None = None) -> Path:
+    src = Path(path_str).expanduser()
+    if not src.exists():
+        raise typer.BadParameter(f"Artifact not found: {src}")
+
+    if output is None:
+        dest = Path.cwd() / src.name
+    else:
+        output_path = Path(output).expanduser()
+        output_str = str(output)
+        if output_path.exists() and output_path.is_dir():
+            dest = output_path / src.name
+        elif output_str.endswith(("/", "\\")):
+            output_path.mkdir(parents=True, exist_ok=True)
+            dest = output_path / src.name
+        else:
+            dest = output_path
+            dest.parent.mkdir(parents=True, exist_ok=True)
+
+    if src.resolve() == dest.resolve():
+        return dest
+
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copy2(src, dest)
+    return dest
+
+
+def require_target(device: str | None, session_id: str | None) -> dict[str, Any]:
+    try:
+        return target_payload(device, session_id)
+    except typer.BadParameter as exc:
+        typer.echo(f"Error: {exc}")
+        raise typer.Exit(code=1) from None

android_emu_agent/daemon/__init__.py

@@ -0,0 +1 @@
+"""Daemon - Core server managing device connections and sessions."""

android_emu_agent/daemon/core.py

@@ -0,0 +1,62 @@
+"""Daemon core - lifecycle, request routing, state management."""
+
+import structlog
+
+from android_emu_agent.actions.executor import ActionExecutor
+from android_emu_agent.actions.wait import WaitEngine
+from android_emu_agent.artifacts.manager import ArtifactManager
+from android_emu_agent.daemon.health import HealthMonitor
+from android_emu_agent.db.models import Database
+from android_emu_agent.device.manager import DeviceManager
+from android_emu_agent.device.session import SessionManager
+from android_emu_agent.files.manager import FileManager
+from android_emu_agent.reliability.manager import ReliabilityManager
+from android_emu_agent.ui.context import ContextResolver
+from android_emu_agent.ui.ref_resolver import RefResolver
+from android_emu_agent.ui.snapshotter import UISnapshotter
+
+logger = structlog.get_logger()
+
+
+class DaemonCore:
+    """Central daemon coordinator managing all subsystems."""
+
+    def __init__(self) -> None:
+        self.database = Database()
+        self.device_manager = DeviceManager()
+        self.session_manager = SessionManager(self.database)
+        self.snapshotter = UISnapshotter()
+        self.ref_resolver = RefResolver()
+        self.action_executor = ActionExecutor()
+        self.wait_engine = WaitEngine()
+        self.artifact_manager = ArtifactManager()
+        self.file_manager = FileManager()
+        self.reliability_manager = ReliabilityManager()
+        self.context_resolver = ContextResolver()
+        self.health_monitor = HealthMonitor(self.device_manager, self.session_manager)
+        self._running = False
+
+    async def start(self) -> None:
+        """Initialize all subsystems."""
+        logger.info("daemon_core_starting")
+        await self.database.connect()
+        await self.device_manager.start()
+        await self.session_manager.start()
+        await self.health_monitor.start()
+        self._running = True
+        logger.info("daemon_core_started")
+
+    async def stop(self) -> None:
+        """Gracefully shutdown all subsystems."""
+        logger.info("daemon_core_stopping")
+        self._running = False
+        await self.health_monitor.stop()
+        await self.session_manager.stop()
+        await self.device_manager.stop()
+        await self.database.disconnect()
+        logger.info("daemon_core_stopped")
+
+    @property
+    def is_running(self) -> bool:
+        """Check if daemon is running."""
+        return self._running