autoglm-gui 1.5.0__py3-none-any.whl → 1.5.2__py3-none-any.whl

phone_agent/actions/handler_ios.py

@@ -1,278 +0,0 @@
-"""Action handler for iOS automation using WebDriverAgent."""
-
-import time
-from dataclasses import dataclass
-from typing import Any, Callable
-
-from phone_agent.xctest import (
-    back,
-    double_tap,
-    home,
-    launch_app,
-    long_press,
-    swipe,
-    tap,
-)
-from phone_agent.xctest.input import clear_text, hide_keyboard, type_text
-
-
-@dataclass
-class ActionResult:
-    """Result of an action execution."""
-
-    success: bool
-    should_finish: bool
-    message: str | None = None
-    requires_confirmation: bool = False
-
-
-class IOSActionHandler:
-    """
-    Handles execution of actions from AI model output for iOS devices.
-
-    Args:
-        wda_url: WebDriverAgent URL.
-        session_id: Optional WDA session ID.
-        confirmation_callback: Optional callback for sensitive action confirmation.
-            Should return True to proceed, False to cancel.
-        takeover_callback: Optional callback for takeover requests (login, captcha).
-    """
-
-    def __init__(
-        self,
-        wda_url: str = "http://localhost:8100",
-        session_id: str | None = None,
-        confirmation_callback: Callable[[str], bool] | None = None,
-        takeover_callback: Callable[[str], None] | None = None,
-    ):
-        self.wda_url = wda_url
-        self.session_id = session_id
-        self.confirmation_callback = confirmation_callback or self._default_confirmation
-        self.takeover_callback = takeover_callback or self._default_takeover
-
-    def execute(
-        self, action: dict[str, Any], screen_width: int, screen_height: int
-    ) -> ActionResult:
-        """
-        Execute an action from the AI model.
-
-        Args:
-            action: The action dictionary from the model.
-            screen_width: Current screen width in pixels.
-            screen_height: Current screen height in pixels.
-
-        Returns:
-            ActionResult indicating success and whether to finish.
-        """
-        action_type = action.get("_metadata")
-
-        if action_type == "finish":
-            return ActionResult(
-                success=True, should_finish=True, message=action.get("message")
-            )
-
-        if action_type != "do":
-            return ActionResult(
-                success=False,
-                should_finish=True,
-                message=f"Unknown action type: {action_type}",
-            )
-
-        action_name = action.get("action")
-        handler_method = self._get_handler(action_name)
-
-        if handler_method is None:
-            return ActionResult(
-                success=False,
-                should_finish=False,
-                message=f"Unknown action: {action_name}",
-            )
-
-        try:
-            return handler_method(action, screen_width, screen_height)
-        except Exception as e:
-            return ActionResult(
-                success=False, should_finish=False, message=f"Action failed: {e}"
-            )
-
-    def _get_handler(self, action_name: str) -> Callable | None:
-        """Get the handler method for an action."""
-        handlers = {
-            "Launch": self._handle_launch,
-            "Tap": self._handle_tap,
-            "Type": self._handle_type,
-            "Type_Name": self._handle_type,
-            "Swipe": self._handle_swipe,
-            "Back": self._handle_back,
-            "Home": self._handle_home,
-            "Double Tap": self._handle_double_tap,
-            "Long Press": self._handle_long_press,
-            "Wait": self._handle_wait,
-            "Take_over": self._handle_takeover,
-            "Note": self._handle_note,
-            "Call_API": self._handle_call_api,
-            "Interact": self._handle_interact,
-        }
-        return handlers.get(action_name)
-
-    def _convert_relative_to_absolute(
-        self, element: list[int], screen_width: int, screen_height: int
-    ) -> tuple[int, int]:
-        """Convert relative coordinates (0-1000) to absolute pixels."""
-        x = int(element[0] / 1000 * screen_width)
-        y = int(element[1] / 1000 * screen_height)
-        return x, y
-
-    def _handle_launch(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle app launch action."""
-        app_name = action.get("app")
-        if not app_name:
-            return ActionResult(False, False, "No app name specified")
-
-        success = launch_app(app_name, wda_url=self.wda_url, session_id=self.session_id)
-        if success:
-            return ActionResult(True, False)
-        return ActionResult(False, False, f"App not found: {app_name}")
-
-    def _handle_tap(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle tap action."""
-        element = action.get("element")
-        if not element:
-            return ActionResult(False, False, "No element coordinates")
-
-        x, y = self._convert_relative_to_absolute(element, width, height)
-
-        print(f"Physically tap on ({x}, {y})")
-
-        # Check for sensitive operation
-        if "message" in action:
-            if not self.confirmation_callback(action["message"]):
-                return ActionResult(
-                    success=False,
-                    should_finish=True,
-                    message="User cancelled sensitive operation",
-                )
-
-        tap(x, y, wda_url=self.wda_url, session_id=self.session_id)
-        return ActionResult(True, False)
-
-    def _handle_type(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle text input action."""
-        text = action.get("text", "")
-
-        # Clear existing text and type new text
-        clear_text(wda_url=self.wda_url, session_id=self.session_id)
-        time.sleep(0.5)
-
-        type_text(text, wda_url=self.wda_url, session_id=self.session_id)
-        time.sleep(0.5)
-
-        # Hide keyboard after typing
-        hide_keyboard(wda_url=self.wda_url, session_id=self.session_id)
-        time.sleep(0.5)
-
-        return ActionResult(True, False)
-
-    def _handle_swipe(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle swipe action."""
-        start = action.get("start")
-        end = action.get("end")
-
-        if not start or not end:
-            return ActionResult(False, False, "Missing swipe coordinates")
-
-        start_x, start_y = self._convert_relative_to_absolute(start, width, height)
-        end_x, end_y = self._convert_relative_to_absolute(end, width, height)
-
-        print(f"Physically scroll from ({start_x}, {start_y}) to ({end_x}, {end_y})")
-
-        swipe(
-            start_x,
-            start_y,
-            end_x,
-            end_y,
-            wda_url=self.wda_url,
-            session_id=self.session_id,
-        )
-        return ActionResult(True, False)
-
-    def _handle_back(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle back gesture (swipe from left edge)."""
-        back(wda_url=self.wda_url, session_id=self.session_id)
-        return ActionResult(True, False)
-
-    def _handle_home(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle home button action."""
-        home(wda_url=self.wda_url, session_id=self.session_id)
-        return ActionResult(True, False)
-
-    def _handle_double_tap(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle double tap action."""
-        element = action.get("element")
-        if not element:
-            return ActionResult(False, False, "No element coordinates")
-
-        x, y = self._convert_relative_to_absolute(element, width, height)
-        double_tap(x, y, wda_url=self.wda_url, session_id=self.session_id)
-        return ActionResult(True, False)
-
-    def _handle_long_press(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle long press action."""
-        element = action.get("element")
-        if not element:
-            return ActionResult(False, False, "No element coordinates")
-
-        x, y = self._convert_relative_to_absolute(element, width, height)
-        long_press(
-            x,
-            y,
-            duration=3.0,
-            wda_url=self.wda_url,
-            session_id=self.session_id,
-        )
-        return ActionResult(True, False)
-
-    def _handle_wait(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle wait action."""
-        duration_str = action.get("duration", "1 seconds")
-        try:
-            duration = float(duration_str.replace("seconds", "").strip())
-        except ValueError:
-            duration = 1.0
-
-        time.sleep(duration)
-        return ActionResult(True, False)
-
-    def _handle_takeover(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle takeover request (login, captcha, etc.)."""
-        message = action.get("message", "User intervention required")
-        self.takeover_callback(message)
-        return ActionResult(True, False)
-
-    def _handle_note(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle note action (placeholder for content recording)."""
-        # This action is typically used for recording page content
-        # Implementation depends on specific requirements
-        return ActionResult(True, False)
-
-    def _handle_call_api(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle API call action (placeholder for summarization)."""
-        # This action is typically used for content summarization
-        # Implementation depends on specific requirements
-        return ActionResult(True, False)
-
-    def _handle_interact(self, action: dict, width: int, height: int) -> ActionResult:
-        """Handle interaction request (user choice needed)."""
-        # This action signals that user input is needed
-        return ActionResult(True, False, message="User interaction required")
-
-    @staticmethod
-    def _default_confirmation(message: str) -> bool:
-        """Default confirmation callback using console input."""
-        response = input(f"Sensitive operation: {message}\nConfirm? (Y/N): ")
-        return response.upper() == "Y"
-
-    @staticmethod
-    def _default_takeover(message: str) -> None:
-        """Default takeover callback using console input."""
-        input(f"{message}\nPress Enter after completing manual operation...")

phone_agent/adb/__init__.py

@@ -1,51 +0,0 @@
-"""ADB utilities for Android device interaction."""
-
-from phone_agent.adb.connection import (
-    ADBConnection,
-    ConnectionType,
-    DeviceInfo,
-    list_devices,
-    quick_connect,
-)
-from phone_agent.adb.device import (
-    back,
-    double_tap,
-    get_current_app,
-    home,
-    launch_app,
-    long_press,
-    swipe,
-    tap,
-)
-from phone_agent.adb.input import (
-    clear_text,
-    detect_and_set_adb_keyboard,
-    restore_keyboard,
-    type_text,
-)
-from phone_agent.adb.screenshot import get_screenshot
-
-__all__ = [
-    # Screenshot
-    "get_screenshot",
-    # Input
-    "type_text",
-    "clear_text",
-    "detect_and_set_adb_keyboard",
-    "restore_keyboard",
-    # Device control
-    "get_current_app",
-    "tap",
-    "swipe",
-    "back",
-    "home",
-    "double_tap",
-    "long_press",
-    "launch_app",
-    # Connection management
-    "ADBConnection",
-    "DeviceInfo",
-    "ConnectionType",
-    "quick_connect",
-    "list_devices",
-]

phone_agent/adb/connection.py

@@ -1,358 +0,0 @@
-"""ADB connection management for local and remote devices."""
-
-import subprocess
-import time
-from dataclasses import dataclass
-from enum import Enum
-
-from phone_agent.config.timing import TIMING_CONFIG
-
-
-class ConnectionType(Enum):
-    """Type of ADB connection."""
-
-    USB = "usb"
-    WIFI = "wifi"
-    REMOTE = "remote"
-
-
-@dataclass
-class DeviceInfo:
-    """Information about a connected device."""
-
-    device_id: str
-    status: str
-    connection_type: ConnectionType
-    model: str | None = None
-    android_version: str | None = None
-
-
-class ADBConnection:
-    """
-    Manages ADB connections to Android devices.
-
-    Supports USB, WiFi, and remote TCP/IP connections.
-
-    Example:
-        >>> conn = ADBConnection()
-        >>> # Connect to remote device
-        >>> conn.connect("192.168.1.100:5555")
-        >>> # List devices
-        >>> devices = conn.list_devices()
-        >>> # Disconnect
-        >>> conn.disconnect("192.168.1.100:5555")
-    """
-
-    def __init__(self, adb_path: str = "adb"):
-        """
-        Initialize ADB connection manager.
-
-        Args:
-            adb_path: Path to ADB executable.
-        """
-        self.adb_path = adb_path
-
-    def connect(self, address: str, timeout: int = 10) -> tuple[bool, str]:
-        """
-        Connect to a remote device via TCP/IP.
-
-        Args:
-            address: Device address in format "host:port" (e.g., "192.168.1.100:5555").
-            timeout: Connection timeout in seconds.
-
-        Returns:
-            Tuple of (success, message).
-
-        Note:
-            The remote device must have TCP/IP debugging enabled.
-            On the device, run: adb tcpip 5555
-        """
-        # Validate address format
-        if ":" not in address:
-            address = f"{address}:5555"  # Default ADB port
-
-        try:
-            result = subprocess.run(
-                [self.adb_path, "connect", address],
-                capture_output=True,
-                text=True,
-                timeout=timeout,
-            )
-
-            output = result.stdout + result.stderr
-
-            if "connected" in output.lower():
-                return True, f"Connected to {address}"
-            elif "already connected" in output.lower():
-                return True, f"Already connected to {address}"
-            else:
-                return False, output.strip()
-
-        except subprocess.TimeoutExpired:
-            return False, f"Connection timeout after {timeout}s"
-        except Exception as e:
-            return False, f"Connection error: {e}"
-
-    def disconnect(self, address: str | None = None) -> tuple[bool, str]:
-        """
-        Disconnect from a remote device.
-
-        Args:
-            address: Device address to disconnect. If None, disconnects all.
-
-        Returns:
-            Tuple of (success, message).
-        """
-        try:
-            cmd = [self.adb_path, "disconnect"]
-            if address:
-                cmd.append(address)
-
-            result = subprocess.run(
-                cmd, capture_output=True, text=True, encoding="utf-8", timeout=5
-            )
-
-            output = result.stdout + result.stderr
-            return True, output.strip() or "Disconnected"
-
-        except Exception as e:
-            return False, f"Disconnect error: {e}"
-
-    def list_devices(self) -> list[DeviceInfo]:
-        """
-        List all connected devices.
-
-        Returns:
-            List of DeviceInfo objects.
-        """
-        try:
-            result = subprocess.run(
-                [self.adb_path, "devices", "-l"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-            )
-
-            devices = []
-            for line in result.stdout.strip().split("\n")[1:]:  # Skip header
-                if not line.strip():
-                    continue
-
-                parts = line.split()
-                if len(parts) >= 2:
-                    device_id = parts[0]
-                    status = parts[1]
-
-                    # Determine connection type
-                    if ":" in device_id:
-                        conn_type = ConnectionType.REMOTE
-                    elif "emulator" in device_id:
-                        conn_type = ConnectionType.USB  # Emulator via USB
-                    else:
-                        conn_type = ConnectionType.USB
-
-                    # Parse additional info
-                    model = None
-                    for part in parts[2:]:
-                        if part.startswith("model:"):
-                            model = part.split(":", 1)[1]
-                            break
-
-                    devices.append(
-                        DeviceInfo(
-                            device_id=device_id,
-                            status=status,
-                            connection_type=conn_type,
-                            model=model,
-                        )
-                    )
-
-            return devices
-
-        except Exception as e:
-            print(f"Error listing devices: {e}")
-            return []
-
-    def get_device_info(self, device_id: str | None = None) -> DeviceInfo | None:
-        """
-        Get detailed information about a device.
-
-        Args:
-            device_id: Device ID. If None, uses first available device.
-
-        Returns:
-            DeviceInfo or None if not found.
-        """
-        devices = self.list_devices()
-
-        if not devices:
-            return None
-
-        if device_id is None:
-            return devices[0]
-
-        for device in devices:
-            if device.device_id == device_id:
-                return device
-
-        return None
-
-    def is_connected(self, device_id: str | None = None) -> bool:
-        """
-        Check if a device is connected.
-
-        Args:
-            device_id: Device ID to check. If None, checks if any device is connected.
-
-        Returns:
-            True if connected, False otherwise.
-        """
-        devices = self.list_devices()
-
-        if not devices:
-            return False
-
-        if device_id is None:
-            return any(d.status == "device" for d in devices)
-
-        return any(d.device_id == device_id and d.status == "device" for d in devices)
-
-    def enable_tcpip(
-        self, port: int = 5555, device_id: str | None = None
-    ) -> tuple[bool, str]:
-        """
-        Enable TCP/IP debugging on a USB-connected device.
-
-        This allows subsequent wireless connections to the device.
-
-        Args:
-            port: TCP port for ADB (default: 5555).
-            device_id: Device ID. If None, uses first available device.
-
-        Returns:
-            Tuple of (success, message).
-
-        Note:
-            The device must be connected via USB first.
-            After this, you can disconnect USB and connect via WiFi.
-        """
-        try:
-            cmd = [self.adb_path]
-            if device_id:
-                cmd.extend(["-s", device_id])
-            cmd.extend(["tcpip", str(port)])
-
-            result = subprocess.run(
-                cmd, capture_output=True, text=True, encoding="utf-8", timeout=10
-            )
-
-            output = result.stdout + result.stderr
-
-            if "restarting" in output.lower() or result.returncode == 0:
-                time.sleep(TIMING_CONFIG.connection.adb_restart_delay)
-                return True, f"TCP/IP mode enabled on port {port}"
-            else:
-                return False, output.strip()
-
-        except Exception as e:
-            return False, f"Error enabling TCP/IP: {e}"
-
-    def get_device_ip(self, device_id: str | None = None) -> str | None:
-        """
-        Get the IP address of a connected device.
-
-        Args:
-            device_id: Device ID. If None, uses first available device.
-
-        Returns:
-            IP address string or None if not found.
-        """
-        try:
-            cmd = [self.adb_path]
-            if device_id:
-                cmd.extend(["-s", device_id])
-            cmd.extend(["shell", "ip", "route"])
-
-            result = subprocess.run(
-                cmd, capture_output=True, text=True, encoding="utf-8", timeout=5
-            )
-
-            # Parse IP from route output
-            for line in result.stdout.split("\n"):
-                if "src" in line:
-                    parts = line.split()
-                    for i, part in enumerate(parts):
-                        if part == "src" and i + 1 < len(parts):
-                            return parts[i + 1]
-
-            # Alternative: try wlan0 interface
-            cmd[-1] = "ip addr show wlan0"
-            result = subprocess.run(
-                cmd[:-1] + ["shell", "ip", "addr", "show", "wlan0"],
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                timeout=5,
-            )
-
-            for line in result.stdout.split("\n"):
-                if "inet " in line:
-                    parts = line.strip().split()
-                    if len(parts) >= 2:
-                        return parts[1].split("/")[0]
-
-            return None
-
-        except Exception as e:
-            print(f"Error getting device IP: {e}")
-            return None
-
-    def restart_server(self) -> tuple[bool, str]:
-        """
-        Restart the ADB server.
-
-        Returns:
-            Tuple of (success, message).
-        """
-        try:
-            # Kill server
-            subprocess.run(
-                [self.adb_path, "kill-server"], capture_output=True, timeout=5
-            )
-
-            time.sleep(TIMING_CONFIG.connection.server_restart_delay)
-
-            # Start server
-            subprocess.run(
-                [self.adb_path, "start-server"], capture_output=True, timeout=5
-            )
-
-            return True, "ADB server restarted"
-
-        except Exception as e:
-            return False, f"Error restarting server: {e}"
-
-
-def quick_connect(address: str) -> tuple[bool, str]:
-    """
-    Quick helper to connect to a remote device.
-
-    Args:
-        address: Device address (e.g., "192.168.1.100" or "192.168.1.100:5555").
-
-    Returns:
-        Tuple of (success, message).
-    """
-    conn = ADBConnection()
-    return conn.connect(address)
-
-
-def list_devices() -> list[DeviceInfo]:
-    """
-    Quick helper to list connected devices.
-
-    Returns:
-        List of DeviceInfo objects.
-    """
-    conn = ADBConnection()
-    return conn.list_devices()