autoglm-gui 1.4.1__py3-none-any.whl → 1.5.1__py3-none-any.whl

phone_agent/config/prompts.py

@@ -1,80 +0,0 @@
-"""System prompts for the AI agent."""
-
-from datetime import datetime
-
-today = datetime.today()
-# NOTE: Do NOT use strftime with Chinese characters in format string!
-# On some Windows systems with non-UTF-8 locale (e.g., GBK/CP936),
-# strftime("%Y年%m月%d日") raises UnicodeEncodeError because the C library's
-# strftime uses locale encoding, not Python's UTF-8 mode.
-# Use f-string instead to avoid this issue completely.
-formatted_date = f"{today.year}年{today.month:02d}月{today.day:02d}日"
-
-SYSTEM_PROMPT = (
-    "今天的日期是: "
-    + formatted_date
-    + """
-你是一个智能体分析专家，可以根据操作历史和当前状态图执行一系列操作来完成任务。
-你必须严格按照要求输出以下格式：
-<think>{think}</think>
-<answer>{action}</answer>
-
-其中：
-- {think} 是对你为什么选择这个操作的简短推理说明。
-- {action} 是本次执行的具体操作指令，必须严格遵循下方定义的指令格式。
-
-操作指令及其作用如下：
-- do(action="Launch", app="xxx")  
-    Launch是启动目标app的操作，这比通过主屏幕导航更快。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Tap", element=[x,y])  
-    Tap是点击操作，点击屏幕上的特定点。可用此操作点击按钮、选择项目、从主屏幕打开应用程序，或与任何可点击的用户界面元素进行交互。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Tap", element=[x,y], message="重要操作")  
-    基本功能同Tap，点击涉及财产、支付、隐私等敏感按钮时触发。
-- do(action="Type", text="xxx")  
-    Type是输入操作，在当前聚焦的输入框中输入文本。使用此操作前，请确保输入框已被聚焦（先点击它）。输入的文本将像使用键盘输入一样输入。重要提示：手机可能正在使用 ADB 键盘，该键盘不会像普通键盘那样占用屏幕空间。要确认键盘已激活，请查看屏幕底部是否显示 'ADB Keyboard {ON}' 类似的文本，或者检查输入框是否处于激活/高亮状态。不要仅仅依赖视觉上的键盘显示。自动清除文本：当你使用输入操作时，输入框中现有的任何文本（包括占位符文本和实际输入）都会在输入新文本前自动清除。你无需在输入前手动清除文本——直接使用输入操作输入所需文本即可。操作完成后，你将自动收到结果状态的截图。
-- do(action="Type_Name", text="xxx")  
-    Type_Name是输入人名的操作，基本功能同Type。
-- do(action="Interact")  
-    Interact是当有多个满足条件的选项时而触发的交互操作，询问用户如何选择。
-- do(action="Swipe", start=[x1,y1], end=[x2,y2])  
-    Swipe是滑动操作，通过从起始坐标拖动到结束坐标来执行滑动手势。可用于滚动内容、在屏幕之间导航、下拉通知栏以及项目栏或进行基于手势的导航。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。滑动持续时间会自动调整以实现自然的移动。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Note", message="True")  
-    记录当前页面内容以便后续总结。
-- do(action="Call_API", instruction="xxx")  
-    总结或评论当前页面或已记录的内容。
-- do(action="Long Press", element=[x,y])  
-    Long Pres是长按操作，在屏幕上的特定点长按指定时间。可用于触发上下文菜单、选择文本或激活长按交互。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的屏幕截图。
-- do(action="Double Tap", element=[x,y])  
-    Double Tap在屏幕上的特定点快速连续点按两次。使用此操作可以激活双击交互，如缩放、选择文本或打开项目。坐标系统从左上角 (0,0) 开始到右下角（999,999)结束。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Take_over", message="xxx")  
-    Take_over是接管操作，表示在登录和验证阶段需要用户协助。
-- do(action="Back")  
-    导航返回到上一个屏幕或关闭当前对话框。相当于按下 Android 的返回按钮。使用此操作可以从更深的屏幕返回、关闭弹出窗口或退出当前上下文。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Home") 
-    Home是回到系统桌面的操作，相当于按下 Android 主屏幕按钮。使用此操作可退出当前应用并返回启动器，或从已知状态启动新任务。此操作完成后，您将自动收到结果状态的截图。
-- do(action="Wait", duration="x seconds")  
-    等待页面加载，x为需要等待多少秒。
-- finish(message="xxx")  
-    finish是结束任务的操作，表示准确完整完成任务，message是终止信息。 
-
-必须遵循的规则：
-1. 在执行任何操作前，先检查当前app是否是目标app，如果不是，先执行 Launch。
-2. 如果进入到了无关页面，先执行 Back。如果执行Back后页面没有变化，请点击页面左上角的返回键进行返回，或者右上角的X号关闭。
-3. 如果页面未加载出内容，最多连续 Wait 三次，否则执行 Back重新进入。
-4. 如果页面显示网络问题，需要重新加载，请点击重新加载。
-5. 如果当前页面找不到目标联系人、商品、店铺等信息，可以尝试 Swipe 滑动查找。
-6. 遇到价格区间、时间区间等筛选条件，如果没有完全符合的，可以放宽要求。
-7. 在做小红书总结类任务时一定要筛选图文笔记。
-8. 购物车全选后再点击全选可以把状态设为全不选，在做购物车任务时，如果购物车里已经有商品被选中时，你需要点击全选后再点击取消全选，再去找需要购买或者删除的商品。
-9. 在做外卖任务时，如果相应店铺购物车里已经有其他商品你需要先把购物车清空再去购买用户指定的外卖。
-10. 在做点外卖任务时，如果用户需要点多个外卖，请尽量在同一店铺进行购买，如果无法找到可以下单，并说明某个商品未找到。
-11. 请严格遵循用户意图执行任务，用户的特殊要求可以执行多次搜索，滑动查找。比如（i）用户要求点一杯咖啡，要咸的，你可以直接搜索咸咖啡，或者搜索咖啡后滑动查找咸的咖啡，比如海盐咖啡。（ii）用户要找到XX群，发一条消息，你可以先搜索XX群，找不到结果后，将"群"字去掉，搜索XX重试。（iii）用户要找到宠物友好的餐厅，你可以搜索餐厅，找到筛选，找到设施，选择可带宠物，或者直接搜索可带宠物，必要时可以使用AI搜索。
-12. 在选择日期时，如果原滑动方向与预期日期越来越远，请向反方向滑动查找。
-13. 执行任务过程中如果有多个可选择的项目栏，请逐个查找每个项目栏，直到完成任务，一定不要在同一项目栏多次查找，从而陷入死循环。
-14. 在执行下一步操作前请一定要检查上一步的操作是否生效，如果点击没生效，可能因为app反应较慢，请先稍微等待一下，如果还是不生效请调整一下点击位置重试，如果仍然不生效请跳过这一步继续任务，并在finish message说明点击不生效。
-15. 在执行任务中如果遇到滑动不生效的情况，请调整一下起始点位置，增大滑动距离重试，如果还是不生效，有可能是已经滑到底了，请继续向反方向滑动，直到顶部或底部，如果仍然没有符合要求的结果，请跳过这一步继续任务，并在finish message说明但没找到要求的项目。
-16. 在做游戏任务时如果在战斗页面如果有自动战斗一定要开启自动战斗，如果多轮历史状态相似要检查自动战斗是否开启。
-17. 如果没有合适的搜索结果，可能是因为搜索页面不对，请返回到搜索页面的上一级尝试重新搜索，如果尝试三次返回上一级搜索后仍然没有符合要求的结果，执行 finish(message="原因")。
-18. 在结束任务前请一定要仔细检查任务是否完整准确的完成，如果出现错选、漏选、多选的情况，请返回之前的步骤进行纠正。
-"""
-)

phone_agent/device_factory.py

@@ -1,166 +0,0 @@
-"""Device factory for selecting ADB or HDC based on device type."""
-
-from enum import Enum
-
-
-class DeviceType(Enum):
-    """Type of device connection tool."""
-
-    ADB = "adb"
-    HDC = "hdc"
-    IOS = "ios"
-
-
-class DeviceFactory:
-    """
-    Factory class for getting device-specific implementations.
-
-    This allows the system to work with both Android (ADB) and HarmonyOS (HDC) devices.
-    """
-
-    def __init__(self, device_type: DeviceType = DeviceType.ADB):
-        """
-        Initialize the device factory.
-
-        Args:
-            device_type: The type of device to use (ADB or HDC).
-        """
-        self.device_type = device_type
-        self._module = None
-
-    @property
-    def module(self):
-        """Get the appropriate device module (adb or hdc)."""
-        if self._module is None:
-            if self.device_type == DeviceType.ADB:
-                from phone_agent import adb
-
-                self._module = adb
-            elif self.device_type == DeviceType.HDC:
-                from phone_agent import hdc
-
-                self._module = hdc
-            else:
-                raise ValueError(f"Unknown device type: {self.device_type}")
-        return self._module
-
-    def get_screenshot(self, device_id: str | None = None, timeout: int = 10):
-        """Get screenshot from device."""
-        return self.module.get_screenshot(device_id, timeout)
-
-    def get_current_app(self, device_id: str | None = None) -> str:
-        """Get current app name."""
-        return self.module.get_current_app(device_id)
-
-    def tap(
-        self, x: int, y: int, device_id: str | None = None, delay: float | None = None
-    ):
-        """Tap at coordinates."""
-        return self.module.tap(x, y, device_id, delay)
-
-    def double_tap(
-        self, x: int, y: int, device_id: str | None = None, delay: float | None = None
-    ):
-        """Double tap at coordinates."""
-        return self.module.double_tap(x, y, device_id, delay)
-
-    def long_press(
-        self,
-        x: int,
-        y: int,
-        duration_ms: int = 3000,
-        device_id: str | None = None,
-        delay: float | None = None,
-    ):
-        """Long press at coordinates."""
-        return self.module.long_press(x, y, duration_ms, device_id, delay)
-
-    def swipe(
-        self,
-        start_x: int,
-        start_y: int,
-        end_x: int,
-        end_y: int,
-        duration_ms: int | None = None,
-        device_id: str | None = None,
-        delay: float | None = None,
-    ):
-        """Swipe from start to end."""
-        return self.module.swipe(
-            start_x, start_y, end_x, end_y, duration_ms, device_id, delay
-        )
-
-    def back(self, device_id: str | None = None, delay: float | None = None):
-        """Press back button."""
-        return self.module.back(device_id, delay)
-
-    def home(self, device_id: str | None = None, delay: float | None = None):
-        """Press home button."""
-        return self.module.home(device_id, delay)
-
-    def launch_app(
-        self, app_name: str, device_id: str | None = None, delay: float | None = None
-    ) -> bool:
-        """Launch an app."""
-        return self.module.launch_app(app_name, device_id, delay)
-
-    def type_text(self, text: str, device_id: str | None = None):
-        """Type text."""
-        return self.module.type_text(text, device_id)
-
-    def clear_text(self, device_id: str | None = None):
-        """Clear text."""
-        return self.module.clear_text(device_id)
-
-    def detect_and_set_adb_keyboard(self, device_id: str | None = None) -> str:
-        """Detect and set keyboard."""
-        return self.module.detect_and_set_adb_keyboard(device_id)
-
-    def restore_keyboard(self, ime: str, device_id: str | None = None):
-        """Restore keyboard."""
-        return self.module.restore_keyboard(ime, device_id)
-
-    def list_devices(self):
-        """List connected devices."""
-        return self.module.list_devices()
-
-    def get_connection_class(self):
-        """Get the connection class (ADBConnection or HDCConnection)."""
-        if self.device_type == DeviceType.ADB:
-            from phone_agent.adb import ADBConnection
-
-            return ADBConnection
-        elif self.device_type == DeviceType.HDC:
-            from phone_agent.hdc import HDCConnection
-
-            return HDCConnection
-        else:
-            raise ValueError(f"Unknown device type: {self.device_type}")
-
-
-# Global device factory instance
-_device_factory: DeviceFactory | None = None
-
-
-def set_device_type(device_type: DeviceType):
-    """
-    Set the global device type.
-
-    Args:
-        device_type: The device type to use (ADB or HDC).
-    """
-    global _device_factory
-    _device_factory = DeviceFactory(device_type)
-
-
-def get_device_factory() -> DeviceFactory:
-    """
-    Get the global device factory instance.
-
-    Returns:
-        The device factory instance.
-    """
-    global _device_factory
-    if _device_factory is None:
-        _device_factory = DeviceFactory(DeviceType.ADB)  # Default to ADB
-    return _device_factory

phone_agent/hdc/__init__.py

@@ -1,53 +0,0 @@
-"""HDC utilities for HarmonyOS device interaction."""
-
-from phone_agent.hdc.connection import (
-    HDCConnection,
-    ConnectionType,
-    DeviceInfo,
-    list_devices,
-    quick_connect,
-    set_hdc_verbose,
-)
-from phone_agent.hdc.device import (
-    back,
-    double_tap,
-    get_current_app,
-    home,
-    launch_app,
-    long_press,
-    swipe,
-    tap,
-)
-from phone_agent.hdc.input import (
-    clear_text,
-    detect_and_set_adb_keyboard,
-    restore_keyboard,
-    type_text,
-)
-from phone_agent.hdc.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
-    "HDCConnection",
-    "DeviceInfo",
-    "ConnectionType",
-    "quick_connect",
-    "list_devices",
-    "set_hdc_verbose",
-]

phone_agent/hdc/connection.py

@@ -1,384 +0,0 @@
-"""HDC connection management for HarmonyOS devices."""
-
-import os
-import subprocess
-import time
-from dataclasses import dataclass
-from enum import Enum
-
-from phone_agent.config.timing import TIMING_CONFIG
-
-
-# Global flag to control HDC command output
-_HDC_VERBOSE = os.getenv("HDC_VERBOSE", "false").lower() in ("true", "1", "yes")
-
-
-def _run_hdc_command(cmd: list, **kwargs) -> subprocess.CompletedProcess:
-    """
-    Run HDC command with optional verbose output.
-
-    Args:
-        cmd: Command list to execute.
-        **kwargs: Additional arguments for subprocess.run.
-
-    Returns:
-        CompletedProcess result.
-    """
-    if _HDC_VERBOSE:
-        print(f"[HDC] Running command: {' '.join(cmd)}")
-
-    result = subprocess.run(cmd, **kwargs)
-
-    if _HDC_VERBOSE and result.returncode != 0:
-        print(f"[HDC] Command failed with return code {result.returncode}")
-        if hasattr(result, "stderr") and result.stderr:
-            print(f"[HDC] Error: {result.stderr}")
-
-    return result
-
-
-def set_hdc_verbose(verbose: bool):
-    """Set HDC verbose mode globally."""
-    global _HDC_VERBOSE
-    _HDC_VERBOSE = verbose
-
-
-class ConnectionType(Enum):
-    """Type of HDC 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
-    harmony_version: str | None = None
-
-
-class HDCConnection:
-    """
-    Manages HDC connections to HarmonyOS devices.
-
-    Supports USB, WiFi, and remote TCP/IP connections.
-
-    Example:
-        >>> conn = HDCConnection()
-        >>> # 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, hdc_path: str = "hdc"):
-        """
-        Initialize HDC connection manager.
-
-        Args:
-            hdc_path: Path to HDC executable.
-        """
-        self.hdc_path = hdc_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.
-        """
-        # Validate address format
-        if ":" not in address:
-            address = f"{address}:5555"  # Default HDC port
-
-        try:
-            result = _run_hdc_command(
-                [self.hdc_path, "tconn", address],
-                capture_output=True,
-                text=True,
-                timeout=timeout,
-            )
-
-            output = result.stdout + result.stderr
-
-            if "Connect OK" in output or "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:
-            if address:
-                cmd = [self.hdc_path, "tdisconn", address]
-            else:
-                # HDC doesn't have a "disconnect all" command, so we need to list and disconnect each
-                devices = self.list_devices()
-                for device in devices:
-                    if ":" in device.device_id:  # Remote device
-                        _run_hdc_command(
-                            [self.hdc_path, "tdisconn", device.device_id],
-                            capture_output=True,
-                            text=True,
-                            timeout=5,
-                        )
-                return True, "Disconnected all remote devices"
-
-            result = _run_hdc_command(
-                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 = _run_hdc_command(
-                [self.hdc_path, "list", "targets"],
-                capture_output=True,
-                text=True,
-                timeout=5,
-            )
-
-            devices = []
-            for line in result.stdout.strip().split("\n"):
-                if not line.strip():
-                    continue
-
-                # HDC output format: device_id (status)
-                # Example: "192.168.1.100:5555" or "FMR0223C13000649"
-                device_id = line.strip()
-
-                # Determine connection type
-                if ":" in device_id:
-                    conn_type = ConnectionType.REMOTE
-                else:
-                    conn_type = ConnectionType.USB
-
-                # HDC doesn't provide detailed status in list command
-                # We assume "Connected" status for devices that appear
-                devices.append(
-                    DeviceInfo(
-                        device_id=device_id,
-                        status="device",
-                        connection_type=conn_type,
-                        model=None,
-                    )
-                )
-
-            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 len(devices) > 0
-
-        return any(d.device_id == device_id 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 HDC (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.hdc_path]
-            if device_id:
-                cmd.extend(["-t", device_id])
-            cmd.extend(["tmode", "port", str(port)])
-
-            result = _run_hdc_command(
-                cmd, capture_output=True, text=True, encoding="utf-8", timeout=10
-            )
-
-            output = result.stdout + result.stderr
-
-            if result.returncode == 0 or "success" in output.lower():
-                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.hdc_path]
-            if device_id:
-                cmd.extend(["-t", device_id])
-            cmd.extend(["shell", "ifconfig"])
-
-            result = _run_hdc_command(
-                cmd, capture_output=True, text=True, encoding="utf-8", timeout=5
-            )
-
-            # Parse IP from ifconfig output
-            for line in result.stdout.split("\n"):
-                if "inet addr:" in line or "inet " in line:
-                    parts = line.strip().split()
-                    for i, part in enumerate(parts):
-                        if "addr:" in part:
-                            ip = part.split(":")[1]
-                            # Filter out localhost
-                            if not ip.startswith("127."):
-                                return ip
-                        elif part == "inet" and i + 1 < len(parts):
-                            ip = parts[i + 1].split("/")[0]
-                            if not ip.startswith("127."):
-                                return ip
-
-            return None
-
-        except Exception as e:
-            print(f"Error getting device IP: {e}")
-            return None
-
-    def restart_server(self) -> tuple[bool, str]:
-        """
-        Restart the HDC server.
-
-        Returns:
-            Tuple of (success, message).
-        """
-        try:
-            # Kill server
-            _run_hdc_command([self.hdc_path, "kill"], capture_output=True, timeout=5)
-
-            time.sleep(TIMING_CONFIG.connection.server_restart_delay)
-
-            # Start server (HDC auto-starts when running commands)
-            _run_hdc_command(
-                [self.hdc_path, "start", "-r"], capture_output=True, timeout=5
-            )
-
-            return True, "HDC 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 = HDCConnection()
-    return conn.connect(address)
-
-
-def list_devices() -> list[DeviceInfo]:
-    """
-    Quick helper to list connected devices.
-
-    Returns:
-        List of DeviceInfo objects.
-    """
-    conn = HDCConnection()
-    return conn.list_devices()