minitap-mobile-use 0.0.1.dev0__py3-none-any.whl

minitap/mobile_use/servers/device_hardware_bridge.py

@@ -0,0 +1,212 @@
+import platform
+import re
+import subprocess
+import threading
+import time
+from enum import Enum
+from typing import Optional
+
+import requests
+from minitap.mobile_use.context import DevicePlatform
+from minitap.mobile_use.servers.utils import is_port_in_use
+
+MAESTRO_STUDIO_PORT = 9999
+DEVICE_HARDWARE_BRIDGE_PORT = MAESTRO_STUDIO_PORT
+
+
+class BridgeStatus(Enum):
+    STOPPED = "stopped"
+    STARTING = "starting"
+    RUNNING = "running"
+    NO_DEVICE = "no_device"
+    PORT_IN_USE = "port_in_use"
+    FAILED = "failed"
+
+
+class DeviceHardwareBridge:
+    def __init__(self, device_id: str, platform: DevicePlatform, adb_host: Optional[str] = None):
+        self.process = None
+        self.status = BridgeStatus.STOPPED
+        self.thread = None
+        self.output = []
+        self.lock = threading.Lock()
+        self.device_id: str = device_id
+        self.platform: DevicePlatform = platform
+        self.adb_host: Optional[str] = adb_host
+
+    def _run_maestro_studio(self):
+        try:
+            creation_flags = 0
+            if hasattr(subprocess, "CREATE_NO_WINDOW"):
+                creation_flags = subprocess.CREATE_NO_WINDOW
+
+            maestro_platform = "android" if self.platform == DevicePlatform.ANDROID else "ios"
+            cmd = ["maestro", "--device", self.device_id, "--platform", maestro_platform]
+            if self.adb_host is not None:
+                cmd.append(f"--host={self.adb_host}")
+            cmd.extend(["studio", "--no-window"])
+
+            self.process = subprocess.Popen(
+                args=cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                encoding="utf-8",
+                errors="replace",
+                creationflags=creation_flags,
+                shell=platform.system() == "Windows",
+            )
+
+            with self.lock:
+                self.status = BridgeStatus.STARTING
+
+            stdout_thread = threading.Thread(target=self._read_stdout, daemon=True)
+            stdout_thread.start()
+
+            stderr_thread = threading.Thread(target=self._read_stderr, daemon=True)
+            stderr_thread.start()
+
+            stdout_thread.join()
+            stderr_thread.join()
+
+            if self.process:
+                self.process.wait()
+
+        except FileNotFoundError:
+            print("Error: 'maestro' command not found. Is Maestro installed and in your PATH?")
+            with self.lock:
+                self.status = BridgeStatus.FAILED
+        except Exception as e:
+            print(f"An unexpected error occurred: {e}")
+            with self.lock:
+                self.status = BridgeStatus.FAILED
+        finally:
+            with self.lock:
+                if self.status not in [
+                    BridgeStatus.RUNNING,
+                    BridgeStatus.NO_DEVICE,
+                    BridgeStatus.PORT_IN_USE,
+                ]:
+                    self.status = BridgeStatus.STOPPED
+            print("Maestro Studio process has terminated.")
+
+    def _read_stdout(self):
+        if not self.process or not self.process.stdout:
+            return
+        for line in iter(self.process.stdout.readline, ""):
+            if not line:
+                break
+
+            line = line.strip()
+            print(f"[Maestro Studio]: {line}")
+            self.output.append(line)
+
+            if "No running devices found" in line:
+                with self.lock:
+                    self.status = BridgeStatus.NO_DEVICE
+                if self.process:
+                    self.process.kill()
+                break
+
+            connected_match = re.search(r"Running on (\S+)", line)
+            if connected_match:
+                with self.lock:
+                    self.device_id = connected_match.group(1)
+
+            if "Maestro Studio is running at" in line:
+                if self._wait_for_health_check():
+                    with self.lock:
+                        self.status = BridgeStatus.RUNNING
+                else:
+                    with self.lock:
+                        self.status = BridgeStatus.FAILED
+                    if self.process:
+                        self.process.kill()
+                break
+
+    def _read_stderr(self):
+        if not self.process or not self.process.stderr:
+            return
+        for line in iter(self.process.stderr.readline, ""):
+            if not line:
+                break
+
+            line = line.strip()
+            print(f"[Maestro Studio ERROR]: {line}")
+            self.output.append(line)
+
+            if "device offline" in line.lower():
+                with self.lock:
+                    self.status = BridgeStatus.FAILED
+                if self.process:
+                    self.process.kill()
+                break
+
+            if "address already in use" in line.lower():
+                with self.lock:
+                    self.status = BridgeStatus.PORT_IN_USE
+                if self.process:
+                    self.process.kill()
+                break
+            else:
+                with self.lock:
+                    if self.status == BridgeStatus.STARTING:
+                        self.status = BridgeStatus.FAILED
+
+    def _wait_for_health_check(self, retries=5, delay=2):
+        health_url = f"http://localhost:{DEVICE_HARDWARE_BRIDGE_PORT}/api/banner-message"
+        for _ in range(retries):
+            try:
+                response = requests.get(health_url, timeout=3)
+                if response.status_code == 200 and "level" in response.json():
+                    print("Health check successful.")
+                    return True
+            except requests.exceptions.RequestException:
+                pass
+            time.sleep(delay)
+        print("Health check failed after multiple retries.")
+        return False
+
+    def _should_start_maestro(self):
+        return self.status in [
+            BridgeStatus.STOPPED,
+            BridgeStatus.FAILED,
+            BridgeStatus.NO_DEVICE,
+            BridgeStatus.PORT_IN_USE,
+        ]
+
+    def start(self):
+        if is_port_in_use(DEVICE_HARDWARE_BRIDGE_PORT):
+            print("Maestro port already in use - assuming Maestro is running.")
+            self.status = BridgeStatus.RUNNING
+            return True
+        if self._should_start_maestro():
+            self.status = BridgeStatus.STARTING
+            self.output.clear()
+            self.thread = threading.Thread(target=self._run_maestro_studio, daemon=True)
+            self.thread.start()
+            return True
+        print(f"Cannot start, current status is {self.status.value}")
+        return False
+
+    def wait(self):
+        if self.thread:
+            self.thread.join()
+
+    def stop(self):
+        if self.process:
+            self.process.kill()
+            self.process = None
+        if self.thread and self.thread.is_alive():
+            self.thread.join(timeout=2)
+        with self.lock:
+            self.status = BridgeStatus.STOPPED
+        print("Maestro Studio stopped.")
+
+    def get_status(self):
+        with self.lock:
+            return {"status": self.status.value, "output": self.output[-10:]}
+
+    def get_device_id(self) -> Optional[str]:
+        with self.lock:
+            return self.device_id

minitap/mobile_use/servers/device_screen_api.py

@@ -0,0 +1,143 @@
+import base64
+import json
+import threading
+import time
+from contextlib import asynccontextmanager
+
+import requests
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+from minitap.mobile_use.servers.config import server_settings
+from minitap.mobile_use.servers.utils import is_port_in_use
+from sseclient import SSEClient
+
+DEVICE_HARDWARE_BRIDGE_BASE_URL = server_settings.DEVICE_HARDWARE_BRIDGE_BASE_URL
+DEVICE_HARDWARE_BRIDGE_API_URL = f"{DEVICE_HARDWARE_BRIDGE_BASE_URL}/api"
+
+_latest_screen_data = None
+_data_lock = threading.Lock()
+_stream_thread = None
+_stop_event = threading.Event()
+
+
+def _stream_worker():
+    global _latest_screen_data
+    sse_url = f"{DEVICE_HARDWARE_BRIDGE_API_URL}/device-screen/sse"
+    headers = {"Accept": "text/event-stream"}
+
+    while not _stop_event.is_set():
+        try:
+            with requests.get(sse_url, stream=True, headers=headers) as response:
+                response.raise_for_status()
+                print("--- Stream connected, listening for events... ---")
+                event_source = (chunk for chunk in response.iter_content())
+                client = SSEClient(event_source)
+                for event in client.events():
+                    if _stop_event.is_set():
+                        break
+                    if event.event == "message" and event.data:
+                        data = json.loads(event.data)
+                        screenshot_path = data.get("screenshot")
+                        elements = data.get("elements", [])
+                        width = data.get("width")
+                        height = data.get("height")
+                        platform = data.get("platform")
+
+                        image_url = f"{DEVICE_HARDWARE_BRIDGE_BASE_URL}{screenshot_path}"
+                        image_response = requests.get(image_url)
+                        image_response.raise_for_status()
+                        base64_image = base64.b64encode(image_response.content).decode("utf-8")
+                        base64_data_url = f"data:image/png;base64,{base64_image}"
+
+                        with _data_lock:
+                            _latest_screen_data = {
+                                "base64": base64_data_url,
+                                "elements": elements,
+                                "width": width,
+                                "height": height,
+                                "platform": platform,
+                            }
+
+        except requests.exceptions.RequestException as e:
+            print(f"Connection error in stream worker: {e}. Retrying in 2 seconds...")
+            with _data_lock:
+                _latest_screen_data = None
+            time.sleep(2)
+
+
+def start_stream():
+    global _stream_thread
+    if _stream_thread is None or not _stream_thread.is_alive():
+        _stop_event.clear()
+        _stream_thread = threading.Thread(target=_stream_worker, daemon=True)
+        _stream_thread.start()
+        print("--- Background screen streaming started ---")
+
+
+def stop_stream():
+    global _stream_thread
+    if _stream_thread and _stream_thread.is_alive():
+        _stop_event.set()
+        _stream_thread.join(timeout=2)
+        print("--- Background screen streaming stopped ---")
+
+
+@asynccontextmanager
+async def lifespan(_: FastAPI):
+    start_stream()
+    yield
+    stop_stream()
+
+
+app = FastAPI(lifespan=lifespan)
+
+
+def get_latest_data():
+    """Helper to get the latest data safely, with retries."""
+    max_wait_time = 30  # seconds
+    retry_delay = 2  # seconds
+    start_time = time.time()
+
+    while time.time() - start_time < max_wait_time:
+        with _data_lock:
+            if _latest_screen_data is not None:
+                return _latest_screen_data
+        time.sleep(retry_delay)
+
+    raise HTTPException(
+        status_code=503,
+        detail="Screen data is not yet available after multiple retries.",
+    )
+
+
+@app.get("/screen-info")
+async def get_screen_info():
+    data = get_latest_data()
+    return JSONResponse(content=data)
+
+
+@app.get("/health")
+async def health_check():
+    """Check if the Maestro Studio server is healthy."""
+    health_url = f"{DEVICE_HARDWARE_BRIDGE_API_URL}/banner-message"
+    try:
+        response = requests.get(health_url, timeout=5)
+        response.raise_for_status()
+        with _data_lock:
+            if _latest_screen_data is None:
+                raise HTTPException(
+                    status_code=503,
+                    detail="Screen data is not yet available after multiple retries.",
+                )
+        return JSONResponse(content=response.json())
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(status_code=503, detail=f"Maestro Studio not available: {e}")
+
+
+def start():
+    if not is_port_in_use(server_settings.DEVICE_SCREEN_API_PORT):
+        uvicorn.run(app, host="0.0.0.0", port=server_settings.DEVICE_SCREEN_API_PORT)
+        return True
+    print(f"Device screen API is already running on port {server_settings.DEVICE_SCREEN_API_PORT}")
+    return False

minitap/mobile_use/servers/start_servers.py

@@ -0,0 +1,151 @@
+import multiprocessing
+import os
+import signal
+import sys
+import time
+from enum import Enum
+from typing import Annotated, Optional
+
+import requests
+import typer
+from minitap.mobile_use.context import DevicePlatform
+from minitap.mobile_use.servers.config import server_settings
+from minitap.mobile_use.servers.device_hardware_bridge import DeviceHardwareBridge
+from minitap.mobile_use.servers.device_screen_api import start as _start_device_screen_api
+from minitap.mobile_use.servers.stop_servers import stop_servers
+from minitap.mobile_use.utils.logger import get_server_logger
+
+logger = get_server_logger()
+
+running_processes = []
+bridge_instance = None
+shutdown_requested = False
+
+
+def check_device_screen_api_health(base_url: Optional[str] = None, max_retries=30, delay=1):
+    base_url = base_url or f"http://localhost:{server_settings.DEVICE_SCREEN_API_PORT}"
+    health_url = f"{base_url}/health"
+
+    max_retries = int(os.getenv("MOBILE_USE_HEALTH_RETRIES", max_retries))
+    delay = int(os.getenv("MOBILE_USE_HEALTH_DELAY", delay))
+
+    for attempt in range(max_retries):
+        try:
+            response = requests.get(health_url, timeout=3)
+            if response.status_code == 200:
+                logger.success(
+                    f"Device Screen API is healthy on port {server_settings.DEVICE_SCREEN_API_PORT}"
+                )
+                return True
+        except requests.exceptions.RequestException:
+            pass
+
+        if attempt == 0:
+            logger.info(f"Waiting for Device Screen API to become healthy on {base_url}...")
+
+        time.sleep(delay)
+
+    logger.error(f"Device Screen API failed to become healthy after {max_retries} attempts")
+    return False
+
+
+def _start_device_screen_api_process() -> Optional[multiprocessing.Process]:
+    try:
+        process = multiprocessing.Process(target=start_device_screen_api, daemon=True)
+        process.start()
+        return process
+    except Exception as e:
+        logger.error(f"Failed to start Device Screen API process: {e}")
+        return None
+
+
+def start_device_hardware_bridge(
+    device_id: str, platform: DevicePlatform
+) -> Optional[DeviceHardwareBridge]:
+    logger.info("Starting Device Hardware Bridge...")
+
+    try:
+        bridge = DeviceHardwareBridge(
+            device_id=device_id,
+            platform=platform,
+            adb_host=server_settings.ADB_HOST,
+        )
+        success = bridge.start()
+
+        if success:
+            logger.info("Device Hardware Bridge started successfully")
+            return bridge
+        else:
+            logger.error("Failed to start Device Hardware Bridge. Exiting.")
+            return None
+
+    except Exception as e:
+        logger.error(f"Error starting Device Hardware Bridge: {e}")
+        return None
+
+
+def start_device_screen_api(use_process: bool = False):
+    logger.info("Starting Device Screen API...")
+    if use_process:
+        api_process = _start_device_screen_api_process()
+        if not api_process:
+            logger.error("Failed to start Device Screen API. Exiting.")
+            return False
+        logger.info("Device Screen API started successfully")
+        return api_process
+    else:
+        return _start_device_screen_api()
+
+
+cli = typer.Typer(add_completion=False, pretty_exceptions_enable=False)
+
+
+class SupportedServers(str, Enum):
+    DEVICE_HARDWARE_BRIDGE = "hardware_bridge"
+    DEVICE_SCREEN_API = "screen_api"
+    ALL = "all"
+
+
+@cli.command()
+def start(
+    device_id: Annotated[str, typer.Option("--device", help="Device ID")],
+    platform: Annotated[DevicePlatform, typer.Option("--platform", help="Device platform")],
+    only: Annotated[
+        SupportedServers, typer.Option("--only", help="Start only one server")
+    ] = SupportedServers.ALL,
+):
+    servers_to_stop = {"device_screen_api": False, "device_hardware_bridge": False}
+
+    def signal_handler(signum, frame):
+        logger.info("Signal received, stopping servers...")
+        if any(servers_to_stop.values()):
+            stop_servers(**servers_to_stop)
+        sys.exit(0)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    try:
+        if only == SupportedServers.ALL:
+            hardware_bridge = start_device_hardware_bridge(device_id=device_id, platform=platform)
+            if hardware_bridge:
+                servers_to_stop["device_hardware_bridge"] = True
+            start_device_screen_api(use_process=False)
+
+        elif only == SupportedServers.DEVICE_HARDWARE_BRIDGE:
+            hardware_bridge = start_device_hardware_bridge(device_id=device_id, platform=platform)
+            if hardware_bridge:
+                servers_to_stop["device_hardware_bridge"] = True
+                hardware_bridge.wait()
+
+        elif only == SupportedServers.DEVICE_SCREEN_API:
+            start_device_screen_api(use_process=False)
+
+    except KeyboardInterrupt:
+        logger.info("Keyboard interrupt received. Shutting down...")
+    finally:
+        signal_handler(signal.SIGINT, None)
+
+
+if __name__ == "__main__":
+    cli()