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

AutoGLM_GUI/adb/timing.py

@@ -0,0 +1,167 @@
+"""Timing configuration for Phone Agent.
+
+This module defines all configurable waiting times used throughout the application.
+Users can customize these values by modifying this file or by setting environment variables.
+"""
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass
+class ActionTimingConfig:
+    """Configuration for action handler timing delays."""
+
+    # Text input related delays (in seconds)
+    keyboard_switch_delay: float = 1.0  # Delay after switching to ADB keyboard
+    text_clear_delay: float = 1.0  # Delay after clearing text
+    text_input_delay: float = 1.0  # Delay after typing text
+    keyboard_restore_delay: float = 1.0  # Delay after restoring original keyboard
+
+    def __post_init__(self):
+        """Load values from environment variables if present."""
+        self.keyboard_switch_delay = float(
+            os.getenv("PHONE_AGENT_KEYBOARD_SWITCH_DELAY", self.keyboard_switch_delay)
+        )
+        self.text_clear_delay = float(
+            os.getenv("PHONE_AGENT_TEXT_CLEAR_DELAY", self.text_clear_delay)
+        )
+        self.text_input_delay = float(
+            os.getenv("PHONE_AGENT_TEXT_INPUT_DELAY", self.text_input_delay)
+        )
+        self.keyboard_restore_delay = float(
+            os.getenv("PHONE_AGENT_KEYBOARD_RESTORE_DELAY", self.keyboard_restore_delay)
+        )
+
+
+@dataclass
+class DeviceTimingConfig:
+    """Configuration for device operation timing delays."""
+
+    # Default delays for various device operations (in seconds)
+    default_tap_delay: float = 1.0  # Default delay after tap
+    default_double_tap_delay: float = 1.0  # Default delay after double tap
+    double_tap_interval: float = 0.1  # Interval between two taps in double tap
+    default_long_press_delay: float = 1.0  # Default delay after long press
+    default_swipe_delay: float = 1.0  # Default delay after swipe
+    default_back_delay: float = 1.0  # Default delay after back button
+    default_home_delay: float = 1.0  # Default delay after home button
+    default_launch_delay: float = 1.0  # Default delay after launching app
+
+    def __post_init__(self):
+        """Load values from environment variables if present."""
+        self.default_tap_delay = float(
+            os.getenv("PHONE_AGENT_TAP_DELAY", self.default_tap_delay)
+        )
+        self.default_double_tap_delay = float(
+            os.getenv("PHONE_AGENT_DOUBLE_TAP_DELAY", self.default_double_tap_delay)
+        )
+        self.double_tap_interval = float(
+            os.getenv("PHONE_AGENT_DOUBLE_TAP_INTERVAL", self.double_tap_interval)
+        )
+        self.default_long_press_delay = float(
+            os.getenv("PHONE_AGENT_LONG_PRESS_DELAY", self.default_long_press_delay)
+        )
+        self.default_swipe_delay = float(
+            os.getenv("PHONE_AGENT_SWIPE_DELAY", self.default_swipe_delay)
+        )
+        self.default_back_delay = float(
+            os.getenv("PHONE_AGENT_BACK_DELAY", self.default_back_delay)
+        )
+        self.default_home_delay = float(
+            os.getenv("PHONE_AGENT_HOME_DELAY", self.default_home_delay)
+        )
+        self.default_launch_delay = float(
+            os.getenv("PHONE_AGENT_LAUNCH_DELAY", self.default_launch_delay)
+        )
+
+
+@dataclass
+class ConnectionTimingConfig:
+    """Configuration for ADB connection timing delays."""
+
+    # ADB server and connection delays (in seconds)
+    adb_restart_delay: float = 2.0  # Wait time after enabling TCP/IP mode
+    server_restart_delay: float = (
+        1.0  # Wait time between killing and starting ADB server
+    )
+
+    def __post_init__(self):
+        """Load values from environment variables if present."""
+        self.adb_restart_delay = float(
+            os.getenv("PHONE_AGENT_ADB_RESTART_DELAY", self.adb_restart_delay)
+        )
+        self.server_restart_delay = float(
+            os.getenv("PHONE_AGENT_SERVER_RESTART_DELAY", self.server_restart_delay)
+        )
+
+
+@dataclass
+class TimingConfig:
+    """Master timing configuration combining all timing settings."""
+
+    action: ActionTimingConfig
+    device: DeviceTimingConfig
+    connection: ConnectionTimingConfig
+
+    def __init__(self):
+        """Initialize all timing configurations."""
+        self.action = ActionTimingConfig()
+        self.device = DeviceTimingConfig()
+        self.connection = ConnectionTimingConfig()
+
+
+# Global timing configuration instance
+# Users can modify these values at runtime or through environment variables
+TIMING_CONFIG = TimingConfig()
+
+
+def get_timing_config() -> TimingConfig:
+    """
+    Get the global timing configuration.
+
+    Returns:
+        The global TimingConfig instance.
+    """
+    return TIMING_CONFIG
+
+
+def update_timing_config(
+    action: ActionTimingConfig | None = None,
+    device: DeviceTimingConfig | None = None,
+    connection: ConnectionTimingConfig | None = None,
+) -> None:
+    """
+    Update the global timing configuration.
+
+    Args:
+        action: New action timing configuration.
+        device: New device timing configuration.
+        connection: New connection timing configuration.
+
+    Example:
+        >>> from AutoGLM_GUI.adb.timing import update_timing_config, ActionTimingConfig
+        >>> custom_action = ActionTimingConfig(
+        ...     keyboard_switch_delay=0.5,
+        ...     text_input_delay=0.5
+        ... )
+        >>> update_timing_config(action=custom_action)
+    """
+    global TIMING_CONFIG
+    if action is not None:
+        TIMING_CONFIG.action = action
+    if device is not None:
+        TIMING_CONFIG.device = device
+    if connection is not None:
+        TIMING_CONFIG.connection = connection
+
+
+__all__ = [
+    "ActionTimingConfig",
+    "DeviceTimingConfig",
+    "ConnectionTimingConfig",
+    "TimingConfig",
+    "TIMING_CONFIG",
+    "get_timing_config",
+    "update_timing_config",
+]

AutoGLM_GUI/adb_plus/keyboard_installer.py

@@ -104,8 +104,10 @@ class ADBKeyboardInstaller:
             from importlib.resources import files
 
             logger.debug("Searching for bundled APK in wheel package")
-            resource = files("AutoGLM_GUI").joinpath(
-                "resources/apks", ADB_KEYBOARD_APK_FILENAME
+            resource = (
+                files("AutoGLM_GUI")
+                .joinpath("resources/apks")
+                .joinpath(ADB_KEYBOARD_APK_FILENAME)
             )
             # Convert to Path
             if hasattr(resource, "read_bytes"):

AutoGLM_GUI/adb_plus/screenshot.py

@@ -13,6 +13,8 @@ from io import BytesIO
 
 from PIL import Image
 
+from AutoGLM_GUI.exceptions import DeviceNotAvailableError
+
 
 PNG_SIGNATURE = b"\x89PNG\r\n\x1a\n"
 
@@ -44,9 +46,13 @@ def capture_screenshot(
 
     Returns:
         Screenshot object; falls back to a black image on failure.
+
+    Raises:
+        DeviceNotAvailableError: When device is not found or offline.
     """
     attempts = max(1, retries + 1)
     for _ in range(attempts):
+        # _try_capture may raise DeviceNotAvailableError, let it propagate
         data = _try_capture(device_id=device_id, adb_path=adb_path, timeout=timeout)
         if not data:
             continue
@@ -72,7 +78,11 @@ def capture_screenshot(
 
 
 def _try_capture(device_id: str | None, adb_path: str, timeout: int) -> bytes | None:
-    """Run exec-out screencap and return raw bytes or None on failure."""
+    """Run exec-out screencap and return raw bytes or None on failure.
+
+    Raises:
+        DeviceNotAvailableError: When device is not found or offline.
+    """
     cmd: list[str | bytes] = [adb_path]
     if device_id:
         cmd.extend(["-s", device_id])
@@ -85,9 +95,20 @@ def _try_capture(device_id: str | None, adb_path: str, timeout: int) -> bytes |
             timeout=timeout,
         )
         if result.returncode != 0:
+            # Check for device not found or offline errors
+            stderr = (
+                result.stderr.decode("utf-8", errors="ignore") if result.stderr else ""
+            )
+            stderr_lower = stderr.lower()
+            if "device not found" in stderr_lower or "offline" in stderr_lower:
+                raise DeviceNotAvailableError(
+                    f"Device {device_id} not found or offline"
+                )
             return None
         # stdout should hold the PNG data
         return result.stdout if isinstance(result.stdout, (bytes, bytearray)) else None
+    except DeviceNotAvailableError:
+        raise  # Re-raise to caller
     except Exception:
         return None
 

AutoGLM_GUI/adb_plus/serial.py

@@ -49,12 +49,22 @@ def extract_serial_from_mdns(device_id: str) -> Optional[str]:
     return None
 
 
-def get_device_serial(device_id: str, adb_path: str = "adb") -> str | None:
+# Serial number properties to try, in order of preference
+_SERIAL_PROPS = [
+    "ro.serialno",
+    "ro.boot.serialno",
+    "ro.product.serial",
+]
+
+
+def get_device_serial(device_id: str, adb_path: str = "adb") -> str:
     """
     Get the real hardware serial number of a device.
 
     For mDNS devices, attempts to extract serial from service name first.
     Falls back to getprop for USB/WiFi devices or if extraction fails.
+    If all methods fail, returns device_id as fallback (for emulators or
+    restricted devices that don't expose serial number).
 
     This works for both USB and WiFi connected devices,
     returning the actual hardware serial number (ro.serialno).
@@ -64,7 +74,8 @@ def get_device_serial(device_id: str, adb_path: str = "adb") -> str | None:
         adb_path: Path to adb executable (default: "adb")
 
     Returns:
-        The device hardware serial number, or None if failed
+        The device hardware serial number. Always returns a value - uses
+        device_id as fallback if serial cannot be obtained.
     """
     from AutoGLM_GUI.logger import logger
 
@@ -74,21 +85,28 @@ def get_device_serial(device_id: str, adb_path: str = "adb") -> str | None:
         logger.debug(f"Extracted serial from mDNS name: {device_id} → {mdns_serial}")
         return mdns_serial
 
-    # Fallback: Use getprop (original behavior)
-    try:
-        # Use getprop to get the actual hardware serial number
-        # This works for both USB and WiFi connections
-        result = run_cmd_silently_sync(
-            [adb_path, "-s", device_id, "shell", "getprop", "ro.serialno"],
-            timeout=3,
-        )
-        if result.returncode == 0:
-            serial = result.stdout.strip()
-            # Filter out error messages and empty values
-            if serial and not serial.startswith("error:") and serial != "unknown":
-                logger.debug(f"Got serial via getprop: {device_id} → {serial}")
-                return serial
-    except Exception as e:
-        logger.debug(f"Failed to get serial via getprop for {device_id}: {e}")
-
-    return None
+    # Try multiple serial properties (some emulators use different props)
+    for prop in _SERIAL_PROPS:
+        try:
+            result = run_cmd_silently_sync(
+                [adb_path, "-s", device_id, "shell", "getprop", prop],
+                timeout=5,  # Increased timeout for network devices
+            )
+            if result.returncode == 0:
+                serial = result.stdout.strip()
+                # Filter out error messages and empty values
+                if serial and not serial.startswith("error:") and serial != "unknown":
+                    logger.debug(f"Got serial via {prop}: {device_id} → {serial}")
+                    return serial
+        except Exception as e:
+            logger.debug(f"Failed to get serial via {prop} for {device_id}: {e}")
+            continue
+
+    # Fallback: Use device_id itself as serial
+    # This handles emulators (MuMu, Nox, etc.) and restricted devices
+    # that don't expose serial number via getprop
+    logger.warning(
+        f"Could not get hardware serial for {device_id}, "
+        f"using device_id as serial (emulator/restricted device)"
+    )
+    return device_id

AutoGLM_GUI/adb_plus/touch.py

@@ -3,12 +3,7 @@
 import subprocess
 import time
 
-
-def _get_adb_prefix(device_id: str | None, adb_path: str = "adb") -> list[str]:
-    """Get ADB command prefix with optional device specifier."""
-    if device_id:
-        return [adb_path, "-s", device_id]
-    return [adb_path]
+from AutoGLM_GUI.platform_utils import build_adb_command
 
 
 def touch_down(
@@ -28,7 +23,7 @@ def touch_down(
         delay: Delay in seconds after event (default: 0.0 for real-time).
         adb_path: Path to adb binary.
     """
-    adb_prefix = _get_adb_prefix(device_id, adb_path)
+    adb_prefix = build_adb_command(device_id, adb_path)
 
     subprocess.run(
         adb_prefix + ["shell", "input", "motionevent", "DOWN", str(x), str(y)],
@@ -55,7 +50,7 @@ def touch_move(
         delay: Delay in seconds after event (default: 0.0 for real-time).
         adb_path: Path to adb binary.
     """
-    adb_prefix = _get_adb_prefix(device_id, adb_path)
+    adb_prefix = build_adb_command(device_id, adb_path)
 
     subprocess.run(
         adb_prefix + ["shell", "input", "motionevent", "MOVE", str(x), str(y)],
@@ -82,7 +77,7 @@ def touch_up(
         delay: Delay in seconds after event (default: 0.0 for real-time).
         adb_path: Path to adb binary.
     """
-    adb_prefix = _get_adb_prefix(device_id, adb_path)
+    adb_prefix = build_adb_command(device_id, adb_path)
 
     subprocess.run(
         adb_prefix + ["shell", "input", "motionevent", "UP", str(x), str(y)],

AutoGLM_GUI/agents/__init__.py

@@ -1,20 +1,51 @@
-"""Agent adapters and factory for different agent implementations."""
+from __future__ import annotations
+
+from typing import Callable
+
+
+def register_agent(agent_type: str, creator: Callable) -> None:
+    from .factory import register_agent as _register_agent
+
+    _register_agent(agent_type=agent_type, creator=creator)
+
+
+def create_agent(
+    agent_type: str,
+    model_config,
+    agent_config,
+    agent_specific_config,
+    device,
+    takeover_callback: Callable | None = None,
+    confirmation_callback: Callable | None = None,
+):
+    from .factory import create_agent as _create_agent
+
+    return _create_agent(
+        agent_type=agent_type,
+        model_config=model_config,
+        agent_config=agent_config,
+        agent_specific_config=agent_specific_config,
+        device=device,
+        takeover_callback=takeover_callback,
+        confirmation_callback=confirmation_callback,
+    )
+
+
+def list_agent_types() -> list[str]:
+    from .factory import list_agent_types as _list_agent_types
+
+    return _list_agent_types()
+
+
+def is_agent_type_registered(agent_type: str) -> bool:
+    from .factory import is_agent_type_registered as _is_agent_type_registered
+
+    return _is_agent_type_registered(agent_type)
 
-from .factory import (
-    create_agent,
-    is_agent_type_registered,
-    list_agent_types,
-    register_agent,
-)
-from .mai_adapter import MAIAgentAdapter, MAIAgentConfig
 
 __all__ = [
-    # Factory
     "create_agent",
     "register_agent",
     "list_agent_types",
     "is_agent_type_registered",
-    # Adapters
-    "MAIAgentAdapter",
-    "MAIAgentConfig",
 ]

AutoGLM_GUI/agents/events.py

@@ -0,0 +1,19 @@
+from enum import Enum
+from typing import Any, TypedDict
+
+
+class AgentEventType(str, Enum):
+    """Agent 事件类型."""
+
+    THINKING = "thinking_chunk"
+    STEP = "step"
+    DONE = "done"
+    ERROR = "error"
+    ABORTED = "aborted"
+
+
+class AgentEvent(TypedDict):
+    """Agent 事件（统一类型）."""
+
+    type: str  # 使用字符串以兼容现有 SSE 类型
+    data: dict[str, Any]

AutoGLM_GUI/agents/factory.py

@@ -6,20 +6,14 @@ making it easy to add new agent types without modifying existing code.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Callable, Dict
+from typing import Callable, Dict
 
+from AutoGLM_GUI.config import AgentConfig, ModelConfig
 from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.types import AgentSpecificConfig
 
 from .protocols import BaseAgent
 
-if TYPE_CHECKING:
-    from phone_agent import PhoneAgent
-    from phone_agent.agent import AgentConfig
-    from phone_agent.model import ModelConfig
-
-    from .mai_adapter import MAIAgentAdapter
-
 
 # Agent registry: agent_type -> (creator_function, config_schema)
 AGENT_REGISTRY: Dict[str, Callable] = {}
@@ -52,12 +46,13 @@ def register_agent(
 
 def create_agent(
     agent_type: str,
-    model_config: "ModelConfig",
-    agent_config: "AgentConfig",
+    model_config: ModelConfig,
+    agent_config: AgentConfig,
     agent_specific_config: AgentSpecificConfig,
+    device,
     takeover_callback: Callable | None = None,
     confirmation_callback: Callable | None = None,
-) -> "BaseAgent":
+) -> BaseAgent:
     """
     Create an agent instance using the factory pattern.
 
@@ -66,6 +61,7 @@ def create_agent(
         model_config: Model configuration
         agent_config: Agent configuration
         agent_specific_config: Agent-specific configuration (e.g., MAIConfig fields)
+        device: DeviceProtocol instance (provided by PhoneAgentManager)
         takeover_callback: Takeover callback
         confirmation_callback: Confirmation callback
 
@@ -88,6 +84,7 @@ def create_agent(
             model_config=model_config,
             agent_config=agent_config,
             agent_specific_config=agent_specific_config,
+            device=device,
             takeover_callback=takeover_callback,
             confirmation_callback=confirmation_callback,
         )
@@ -111,50 +108,46 @@ def is_agent_type_registered(agent_type: str) -> bool:
 # ==================== Built-in Agent Creators ====================
 
 
-def _create_phone_agent(
-    model_config: "ModelConfig",
-    agent_config: "AgentConfig",
+def _create_glm_agent_v2(
+    model_config: ModelConfig,
+    agent_config: AgentConfig,
     agent_specific_config: AgentSpecificConfig,
+    device,
     takeover_callback: Callable | None = None,
     confirmation_callback: Callable | None = None,
-) -> "PhoneAgent":
-    from phone_agent import PhoneAgent
+) -> BaseAgent:
+    from .glm.agent import GLMAgent
 
-    return PhoneAgent(
+    return GLMAgent(
         model_config=model_config,
         agent_config=agent_config,
-        takeover_callback=takeover_callback,
+        device=device,
         confirmation_callback=confirmation_callback,
+        takeover_callback=takeover_callback,
     )
 
 
-def _create_mai_agent(
-    model_config: "ModelConfig",
-    agent_config: "AgentConfig",
+def _create_internal_mai_agent(
+    model_config: ModelConfig,
+    agent_config: AgentConfig,
     agent_specific_config: AgentSpecificConfig,
+    device,
     takeover_callback: Callable | None = None,
     confirmation_callback: Callable | None = None,
-) -> "MAIAgentAdapter":
-    from .mai_adapter import MAIAgentAdapter, MAIAgentConfig
-
-    # Build MAI config from dict
-    mai_config = MAIAgentConfig(
-        history_n=agent_specific_config.get("history_n", 3),
-        max_pixels=agent_specific_config.get("max_pixels"),
-        min_pixels=agent_specific_config.get("min_pixels"),
-        tools=agent_specific_config.get("tools"),
-        use_mai_prompt=agent_specific_config.get("use_mai_prompt", False),
-    )
+) -> BaseAgent:
+    from .mai.agent import InternalMAIAgent
+
+    history_n = agent_specific_config.get("history_n", 3)
 
-    return MAIAgentAdapter(
+    return InternalMAIAgent(
         model_config=model_config,
         agent_config=agent_config,
-        mai_config=mai_config,
-        takeover_callback=takeover_callback,
+        device=device,
+        history_n=history_n,
         confirmation_callback=confirmation_callback,
+        takeover_callback=takeover_callback,
     )
 
 
-# Register built-in agents
-register_agent("glm", _create_phone_agent)
-register_agent("mai", _create_mai_agent)
+register_agent("glm", _create_glm_agent_v2)
+register_agent("mai", _create_internal_mai_agent)

AutoGLM_GUI/agents/glm/__init__.py

@@ -0,0 +1,7 @@
+from .prompts_en import SYSTEM_PROMPT as SYSTEM_PROMPT_EN
+from .prompts_zh import SYSTEM_PROMPT as SYSTEM_PROMPT_ZH
+
+__all__ = [
+    "SYSTEM_PROMPT_EN",
+    "SYSTEM_PROMPT_ZH",
+]