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

{phone_agent → AutoGLM_GUI}/adb/device.py

@@ -3,21 +3,13 @@
 import subprocess
 import time
 
-from phone_agent.config.apps import APP_PACKAGES
-from phone_agent.config.timing import TIMING_CONFIG
+from AutoGLM_GUI.adb.apps import APP_PACKAGES
+from AutoGLM_GUI.adb.timing import TIMING_CONFIG
+from AutoGLM_GUI.platform_utils import build_adb_command
 
 
 def get_current_app(device_id: str | None = None) -> str:
-    """
-    Get the currently focused app name.
-
-    Args:
-        device_id: Optional ADB device ID for multi-device setups.
-
-    Returns:
-        The app name if recognized, otherwise "System Home".
-    """
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
     result = subprocess.run(
         adb_prefix + ["shell", "dumpsys", "window"],
@@ -29,7 +21,6 @@ def get_current_app(device_id: str | None = None) -> str:
     if not output:
         raise ValueError("No output from dumpsys window")
 
-    # Parse window focus info
     for line in output.split("\n"):
         if "mCurrentFocus" in line or "mFocusedApp" in line:
             for app_name, package in APP_PACKAGES.items():
@@ -42,19 +33,10 @@ def get_current_app(device_id: str | None = None) -> str:
 def tap(
     x: int, y: int, device_id: str | None = None, delay: float | None = None
 ) -> None:
-    """
-    Tap at the specified coordinates.
-
-    Args:
-        x: X coordinate.
-        y: Y coordinate.
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after tap. If None, uses configured default.
-    """
     if delay is None:
         delay = TIMING_CONFIG.device.default_tap_delay
 
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
     subprocess.run(
         adb_prefix + ["shell", "input", "tap", str(x), str(y)], capture_output=True
@@ -65,19 +47,10 @@ def tap(
 def double_tap(
     x: int, y: int, device_id: str | None = None, delay: float | None = None
 ) -> None:
-    """
-    Double tap at the specified coordinates.
-
-    Args:
-        x: X coordinate.
-        y: Y coordinate.
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after double tap. If None, uses configured default.
-    """
     if delay is None:
         delay = TIMING_CONFIG.device.default_double_tap_delay
 
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
     subprocess.run(
         adb_prefix + ["shell", "input", "tap", str(x), str(y)], capture_output=True
@@ -96,20 +69,10 @@ def long_press(
     device_id: str | None = None,
     delay: float | None = None,
 ) -> None:
-    """
-    Long press at the specified coordinates.
-
-    Args:
-        x: X coordinate.
-        y: Y coordinate.
-        duration_ms: Duration of press in milliseconds.
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after long press. If None, uses configured default.
-    """
     if delay is None:
         delay = TIMING_CONFIG.device.default_long_press_delay
 
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
     subprocess.run(
         adb_prefix
@@ -128,28 +91,15 @@ def swipe(
     device_id: str | None = None,
     delay: float | None = None,
 ) -> None:
-    """
-    Swipe from start to end coordinates.
-
-    Args:
-        start_x: Starting X coordinate.
-        start_y: Starting Y coordinate.
-        end_x: Ending X coordinate.
-        end_y: Ending Y coordinate.
-        duration_ms: Duration of swipe in milliseconds (auto-calculated if None).
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after swipe. If None, uses configured default.
-    """
     if delay is None:
         delay = TIMING_CONFIG.device.default_swipe_delay
 
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
     if duration_ms is None:
-        # Calculate duration based on distance
         dist_sq = (start_x - end_x) ** 2 + (start_y - end_y) ** 2
         duration_ms = int(dist_sq / 1000)
-        duration_ms = max(1000, min(duration_ms, 2000))  # Clamp between 1000-2000ms
+        duration_ms = max(1000, min(duration_ms, 2000))
 
     subprocess.run(
         adb_prefix
@@ -169,17 +119,10 @@ def swipe(
 
 
 def back(device_id: str | None = None, delay: float | None = None) -> None:
-    """
-    Press the back button.
-
-    Args:
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after pressing back. If None, uses configured default.
-    """
     if delay is None:
         delay = TIMING_CONFIG.device.default_back_delay
 
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
     subprocess.run(
         adb_prefix + ["shell", "input", "keyevent", "4"], capture_output=True
@@ -188,17 +131,10 @@ def back(device_id: str | None = None, delay: float | None = None) -> None:
 
 
 def home(device_id: str | None = None, delay: float | None = None) -> None:
-    """
-    Press the home button.
-
-    Args:
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after pressing home. If None, uses configured default.
-    """
     if delay is None:
         delay = TIMING_CONFIG.device.default_home_delay
 
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
     subprocess.run(
         adb_prefix + ["shell", "input", "keyevent", "KEYCODE_HOME"], capture_output=True
@@ -209,24 +145,13 @@ def home(device_id: str | None = None, delay: float | None = None) -> None:
 def launch_app(
     app_name: str, device_id: str | None = None, delay: float | None = None
 ) -> bool:
-    """
-    Launch an app by name.
-
-    Args:
-        app_name: The app name (must be in APP_PACKAGES).
-        device_id: Optional ADB device ID.
-        delay: Delay in seconds after launching. If None, uses configured default.
-
-    Returns:
-        True if app was launched, False if app not found.
-    """
     if delay is None:
         delay = TIMING_CONFIG.device.default_launch_delay
 
     if app_name not in APP_PACKAGES:
         return False
 
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
     package = APP_PACKAGES[app_name]
 
     subprocess.run(
@@ -244,10 +169,3 @@ def launch_app(
     )
     time.sleep(delay)
     return True
-
-
-def _get_adb_prefix(device_id: str | None) -> list:
-    """Get ADB command prefix with optional device specifier."""
-    if device_id:
-        return ["adb", "-s", device_id]
-    return ["adb"]

{phone_agent → AutoGLM_GUI}/adb/input.py

@@ -3,20 +3,11 @@
 import base64
 import subprocess
 
+from AutoGLM_GUI.platform_utils import build_adb_command
+
 
 def type_text(text: str, device_id: str | None = None) -> None:
-    """
-    Type text into the currently focused input field using ADB Keyboard.
-
-    Args:
-        text: The text to type.
-        device_id: Optional ADB device ID for multi-device setups.
-
-    Note:
-        Requires ADB Keyboard to be installed on the device.
-        See: https://github.com/nicnocquee/AdbKeyboard
-    """
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
     encoded_text = base64.b64encode(text.encode("utf-8")).decode("utf-8")
 
     subprocess.run(
@@ -37,13 +28,7 @@ def type_text(text: str, device_id: str | None = None) -> None:
 
 
 def clear_text(device_id: str | None = None) -> None:
-    """
-    Clear text in the currently focused input field.
-
-    Args:
-        device_id: Optional ADB device ID for multi-device setups.
-    """
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
     subprocess.run(
         adb_prefix + ["shell", "am", "broadcast", "-a", "ADB_CLEAR_TEXT"],
@@ -53,18 +38,8 @@ def clear_text(device_id: str | None = None) -> None:
 
 
 def detect_and_set_adb_keyboard(device_id: str | None = None) -> str:
-    """
-    Detect current keyboard and switch to ADB Keyboard if needed.
-
-    Args:
-        device_id: Optional ADB device ID for multi-device setups.
-
-    Returns:
-        The original keyboard IME identifier for later restoration.
-    """
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
-    # Get current IME
     result = subprocess.run(
         adb_prefix + ["shell", "settings", "get", "secure", "default_input_method"],
         capture_output=True,
@@ -72,7 +47,6 @@ def detect_and_set_adb_keyboard(device_id: str | None = None) -> str:
     )
     current_ime = (result.stdout + result.stderr).strip()
 
-    # Switch to ADB Keyboard if not already set
     if "com.android.adbkeyboard/.AdbIME" not in current_ime:
         subprocess.run(
             adb_prefix + ["shell", "ime", "set", "com.android.adbkeyboard/.AdbIME"],
@@ -80,29 +54,14 @@ def detect_and_set_adb_keyboard(device_id: str | None = None) -> str:
             text=True,
         )
 
-    # Warm up the keyboard
     type_text("", device_id)
 
     return current_ime
 
 
 def restore_keyboard(ime: str, device_id: str | None = None) -> None:
-    """
-    Restore the original keyboard IME.
-
-    Args:
-        ime: The IME identifier to restore.
-        device_id: Optional ADB device ID for multi-device setups.
-    """
-    adb_prefix = _get_adb_prefix(device_id)
+    adb_prefix = build_adb_command(device_id)
 
     subprocess.run(
         adb_prefix + ["shell", "ime", "set", ime], capture_output=True, text=True
     )
-
-
-def _get_adb_prefix(device_id: str | None) -> list:
-    """Get ADB command prefix with optional device specifier."""
-    if device_id:
-        return ["adb", "-s", device_id]
-    return ["adb"]

AutoGLM_GUI/adb/screenshot.py

@@ -0,0 +1,11 @@
+"""Screenshot utilities for capturing Android device screen.
+
+DEPRECATED: This module now delegates to adb_plus.screenshot for the actual implementation.
+Use adb_plus.screenshot directly for new code.
+"""
+
+from AutoGLM_GUI.adb_plus.screenshot import Screenshot, capture_screenshot
+
+
+def get_screenshot(device_id: str | None = None, timeout: int = 10) -> Screenshot:
+    return capture_screenshot(device_id=device_id, timeout=timeout)

{phone_agent/config → AutoGLM_GUI/adb}/timing.py

@@ -140,7 +140,7 @@ def update_timing_config(
         connection: New connection timing configuration.
 
     Example:
-        >>> from phone_agent.config.timing import update_timing_config, ActionTimingConfig
+        >>> from AutoGLM_GUI.adb.timing import update_timing_config, ActionTimingConfig
         >>> custom_action = ActionTimingConfig(
         ...     keyboard_switch_delay=0.5,
         ...     text_input_delay=0.5

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]