autoglm-gui 1.4.0__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/qr_pair.py

@@ -124,9 +124,9 @@ class QRPairingListener(ServiceListener):
 
         self.last_paired_host: Optional[str] = None
 
-    def add_service(self, zc: Zeroconf, service_type: str, name: str) -> None:
+    def add_service(self, zc: Zeroconf, type_: str, name: str) -> None:
         """Handle new service discovery."""
-        info = zc.get_service_info(service_type, name, timeout=3000)
+        info = zc.get_service_info(type_, name, timeout=3000)
         if not info:
             logger.debug(f"[QR Pair] No info for service: {name}")
             return
@@ -144,7 +144,7 @@ class QRPairingListener(ServiceListener):
         key = (host, port)
 
         # Handle pairing service
-        if service_type == PAIR_SERVICE_TYPE and not self.paired:
+        if type_ == PAIR_SERVICE_TYPE and not self.paired:
             if key in self.attempted_pair:
                 logger.debug(f"[QR Pair] Already attempted pairing for {host}:{port}")
                 return
@@ -161,7 +161,7 @@ class QRPairingListener(ServiceListener):
                 logger.info("[QR Pair] Pairing OK. Waiting for connect service...")
 
         # Handle connect service
-        if service_type == CONNECT_SERVICE_TYPE and self.paired and not self.connected:
+        if type_ == CONNECT_SERVICE_TYPE and self.paired and not self.connected:
             # Prefer same host as paired if we have it
             if self.last_paired_host and host != self.last_paired_host:
                 logger.debug(
@@ -186,13 +186,13 @@ class QRPairingListener(ServiceListener):
                 self.session.device_id = f"{host}:{port}"
                 logger.info(f"[QR Pair] Connected! Device ID: {self.session.device_id}")
 
-    def update_service(self, zc: Zeroconf, service_type: str, name: str) -> None:
+    def update_service(self, zc: Zeroconf, type_: str, name: str) -> None:
         """Handle service updates (treat as adds)."""
-        self.add_service(zc, service_type, name)
+        self.add_service(zc, type_, name)
 
-    def remove_service(self, _zc: Zeroconf, _service_type: str, _name: str) -> None:
+    def remove_service(self, zc: Zeroconf, type_: str, name: str) -> None:
         """Handle service removal (no action needed)."""
-        pass
+        _ = (zc, type_, name)  # Mark as intentionally unused
 
 
 class QRPairingManager:

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

@@ -0,0 +1,51 @@
+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)
+
+
+__all__ = [
+    "create_agent",
+    "register_agent",
+    "list_agent_types",
+    "is_agent_type_registered",
+]

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

@@ -0,0 +1,153 @@
+"""Agent factory for creating different agent implementations.
+
+This module provides a factory pattern + registry for creating agents,
+making it easy to add new agent types without modifying existing code.
+"""
+
+from __future__ import annotations
+
+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
+
+
+# Agent registry: agent_type -> (creator_function, config_schema)
+AGENT_REGISTRY: Dict[str, Callable] = {}
+
+
+def register_agent(
+    agent_type: str,
+    creator: Callable,
+) -> None:
+    """
+    Register a new agent type.
+
+    Args:
+        agent_type: Unique identifier for the agent type (e.g., "glm", "mai")
+        creator: Function that creates the agent instance.
+                  Signature: (model_config, agent_config, agent_specific_config, callbacks) -> BaseAgent
+
+    Example:
+        >>> def create_mai_agent(model_config, agent_config, mai_config, callbacks):
+        >>>     return MAIAgentAdapter(...)
+        >>>
+        >>> register_agent("mai", create_mai_agent)
+    """
+    if agent_type in AGENT_REGISTRY:
+        logger.warning(f"Agent type '{agent_type}' already registered, overwriting")
+
+    AGENT_REGISTRY[agent_type] = creator
+    logger.info(f"Registered agent type: {agent_type}")
+
+
+def create_agent(
+    agent_type: str,
+    model_config: ModelConfig,
+    agent_config: AgentConfig,
+    agent_specific_config: AgentSpecificConfig,
+    device,
+    takeover_callback: Callable | None = None,
+    confirmation_callback: Callable | None = None,
+) -> BaseAgent:
+    """
+    Create an agent instance using the factory pattern.
+
+    Args:
+        agent_type: Type of agent to create (e.g., "glm", "mai")
+        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
+
+    Returns:
+        Agent instance implementing BaseAgent interface
+
+    Raises:
+        ValueError: If agent_type is not registered
+    """
+    if agent_type not in AGENT_REGISTRY:
+        available = ", ".join(AGENT_REGISTRY.keys())
+        raise ValueError(
+            f"Unknown agent type: '{agent_type}'. Available types: {available}"
+        )
+
+    creator = AGENT_REGISTRY[agent_type]
+
+    try:
+        agent = creator(
+            model_config=model_config,
+            agent_config=agent_config,
+            agent_specific_config=agent_specific_config,
+            device=device,
+            takeover_callback=takeover_callback,
+            confirmation_callback=confirmation_callback,
+        )
+        logger.debug(f"Created agent of type '{agent_type}'")
+        return agent
+    except Exception as e:
+        logger.error(f"Failed to create agent of type '{agent_type}': {e}")
+        raise
+
+
+def list_agent_types() -> list[str]:
+    """Get list of registered agent types."""
+    return list(AGENT_REGISTRY.keys())
+
+
+def is_agent_type_registered(agent_type: str) -> bool:
+    """Check if an agent type is registered."""
+    return agent_type in AGENT_REGISTRY
+
+
+# ==================== Built-in Agent Creators ====================
+
+
+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,
+) -> BaseAgent:
+    from .glm.agent import GLMAgent
+
+    return GLMAgent(
+        model_config=model_config,
+        agent_config=agent_config,
+        device=device,
+        confirmation_callback=confirmation_callback,
+        takeover_callback=takeover_callback,
+    )
+
+
+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,
+) -> BaseAgent:
+    from .mai.agent import InternalMAIAgent
+
+    history_n = agent_specific_config.get("history_n", 3)
+
+    return InternalMAIAgent(
+        model_config=model_config,
+        agent_config=agent_config,
+        device=device,
+        history_n=history_n,
+        confirmation_callback=confirmation_callback,
+        takeover_callback=takeover_callback,
+    )
+
+
+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",
+]