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

AutoGLM_GUI/__init__.py

@@ -5,6 +5,9 @@ import sys
 from functools import wraps
 from importlib import metadata
 
+from AutoGLM_GUI.config import AgentConfig, ModelConfig, StepResult
+from AutoGLM_GUI.logger import logger
+
 # 修复 Windows 编码问题 - 必须在所有其他导入之前
 if sys.platform == "win32":
     import codecs
@@ -58,3 +61,11 @@ try:
     __version__ = metadata.version("autoglm-gui")
 except metadata.PackageNotFoundError:
     __version__ = "unknown"
+
+__all__ = [
+    "__version__",
+    "ModelConfig",
+    "AgentConfig",
+    "StepResult",
+    "logger",
+]

AutoGLM_GUI/__main__.py

@@ -44,19 +44,25 @@ def find_available_port(
     )
 
 
-def open_browser(host: str, port: int, delay: float = 1.5) -> None:
+def open_browser(
+    host: str, port: int, use_ssl: bool = False, delay: float = 1.5
+) -> None:
     """Open browser after a delay to ensure server is ready.
 
     Args:
         host: Server host
         port: Server port
+        use_ssl: Whether to use HTTPS
         delay: Delay in seconds before opening browser
     """
 
     def _open():
         time.sleep(delay)
+        protocol = "https" if use_ssl else "http"
         url = (
-            f"http://127.0.0.1:{port}" if host == "0.0.0.0" else f"http://{host}:{port}"
+            f"{protocol}://127.0.0.1:{port}"
+            if host == "0.0.0.0"
+            else f"{protocol}://{host}:{port}"
         )
         try:
             webbrowser.open(url)
@@ -125,6 +131,16 @@ def main() -> None:
         action="store_true",
         help="Disable file logging",
     )
+    parser.add_argument(
+        "--ssl-keyfile",
+        default=None,
+        help="SSL key file path (for HTTPS)",
+    )
+    parser.add_argument(
+        "--ssl-certfile",
+        default=None,
+        help="SSL certificate file path (for HTTPS)",
+    )
 
     args = parser.parse_args()
 
@@ -172,6 +188,9 @@ def main() -> None:
     # 获取配置来源
     config_source = config_manager.get_config_source()
 
+    # Determine if SSL is enabled
+    use_ssl = args.ssl_keyfile is not None and args.ssl_certfile is not None
+
     # Display startup banner
     print()
     print("=" * 50)
@@ -179,7 +198,8 @@ def main() -> None:
     print("=" * 50)
     print(f"  Version:    {__version__}")
     print()
-    print(f"  Server:     http://{args.host}:{args.port}")
+    protocol = "https" if use_ssl else "http"
+    print(f"  Server:     {protocol}://{args.host}:{args.port}")
     print()
     print("  Model Configuration:")
     print(f"    Source:   {config_source.value}")
@@ -202,13 +222,15 @@ def main() -> None:
 
     # Open browser automatically unless disabled
     if not args.no_browser:
-        open_browser(args.host, args.port)
+        open_browser(args.host, args.port, use_ssl=use_ssl)
 
     uvicorn.run(
         server.app if not args.reload else "AutoGLM_GUI.server:app",
         host=args.host,
         port=args.port,
         reload=args.reload,
+        ssl_keyfile=args.ssl_keyfile,
+        ssl_certfile=args.ssl_certfile,
     )
 
 

AutoGLM_GUI/actions/__init__.py

@@ -0,0 +1,6 @@
+"""Action system for executing phone operations."""
+
+from .handler import ActionHandler
+from .types import ActionResult
+
+__all__ = ["ActionHandler", "ActionResult"]

phone_agent/actions/handler_ios.py → AutoGLM_GUI/actions/handler.py

@@ -1,69 +1,27 @@
-"""Action handler for iOS automation using WebDriverAgent."""
+"""Action handler for executing phone operations."""
 
 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
+from AutoGLM_GUI.device_protocol import DeviceProtocol
 
+from .types import ActionResult
 
-@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).
-    """
 
+class ActionHandler:
     def __init__(
         self,
-        wda_url: str = "http://localhost:8100",
-        session_id: str | None = None,
+        device: DeviceProtocol,
         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.device = device
         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":
@@ -79,6 +37,13 @@ class IOSActionHandler:
             )
 
         action_name = action.get("action")
+        if not isinstance(action_name, str) or not action_name:
+            return ActionResult(
+                success=False,
+                should_finish=False,
+                message=f"Unknown action: {action_name}",
+            )
+
         handler_method = self._get_handler(action_name)
 
         if handler_method is None:
@@ -96,7 +61,6 @@ class IOSActionHandler:
             )
 
     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,
@@ -110,41 +74,33 @@ class IOSActionHandler:
             "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)
+        success = self.device.launch_app(app_name)
         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(
@@ -153,28 +109,27 @@ class IOSActionHandler:
                     message="User cancelled sensitive operation",
                 )
 
-        tap(x, y, wda_url=self.wda_url, session_id=self.session_id)
+        self.device.tap(x, y)
         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)
+        original_ime = self.device.detect_and_set_adb_keyboard()
         time.sleep(0.5)
 
-        type_text(text, wda_url=self.wda_url, session_id=self.session_id)
-        time.sleep(0.5)
+        self.device.clear_text()
+        time.sleep(0.3)
 
-        # Hide keyboard after typing
-        hide_keyboard(wda_url=self.wda_url, session_id=self.session_id)
+        self.device.type_text(text)
         time.sleep(0.5)
 
+        self.device.restore_keyboard(original_ime)
+        time.sleep(0.3)
+
         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")
 
@@ -184,56 +139,36 @@ class IOSActionHandler:
         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,
-        )
+        self.device.swipe(start_x, start_y, end_x, end_y)
         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)
+        self.device.back()
         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)
+        self.device.home()
         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)
+        self.device.double_tap(x, y)
         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,
-        )
+        self.device.long_press(x, y)
         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())
@@ -244,35 +179,18 @@ class IOSActionHandler:
         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"
+        response = input(f"\n⚠️  Confirm action: {message} (y/n): ")
+        return response.lower() in ("y", "yes")
 
     @staticmethod
     def _default_takeover(message: str) -> None:
-        """Default takeover callback using console input."""
-        input(f"{message}\nPress Enter after completing manual operation...")
+        input(f"\n🤚 {message}. Press Enter to continue...")

AutoGLM_GUI/actions/types.py

@@ -0,0 +1,15 @@
+"""Type definitions for actions."""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class ActionResult:
+    success: bool
+    should_finish: bool
+    message: str | None = None
+    requires_confirmation: bool = False
+
+
+Action = dict[str, Any]

{phone_agent → AutoGLM_GUI}/adb/__init__.py

@@ -1,13 +1,12 @@
-"""ADB utilities for Android device interaction."""
-
-from phone_agent.adb.connection import (
+from AutoGLM_GUI.adb.apps import APP_PACKAGES, get_app_name, get_package_name
+from AutoGLM_GUI.adb.connection import (
     ADBConnection,
     ConnectionType,
     DeviceInfo,
     list_devices,
     quick_connect,
 )
-from phone_agent.adb.device import (
+from AutoGLM_GUI.adb.device import (
     back,
     double_tap,
     get_current_app,
@@ -17,35 +16,38 @@ from phone_agent.adb.device import (
     swipe,
     tap,
 )
-from phone_agent.adb.input import (
+from AutoGLM_GUI.adb.input import (
     clear_text,
     detect_and_set_adb_keyboard,
     restore_keyboard,
     type_text,
 )
-from phone_agent.adb.screenshot import get_screenshot
+from AutoGLM_GUI.adb.screenshot import Screenshot, get_screenshot
+from AutoGLM_GUI.adb.timing import TIMING_CONFIG, TimingConfig
 
 __all__ = [
-    # Screenshot
-    "get_screenshot",
-    # Input
-    "type_text",
-    "clear_text",
-    "detect_and_set_adb_keyboard",
-    "restore_keyboard",
-    # Device control
-    "get_current_app",
+    "ADBConnection",
+    "ConnectionType",
+    "DeviceInfo",
+    "list_devices",
+    "quick_connect",
+    "TIMING_CONFIG",
+    "TimingConfig",
+    "APP_PACKAGES",
+    "get_package_name",
+    "get_app_name",
     "tap",
+    "double_tap",
+    "long_press",
     "swipe",
     "back",
     "home",
-    "double_tap",
-    "long_press",
     "launch_app",
-    # Connection management
-    "ADBConnection",
-    "DeviceInfo",
-    "ConnectionType",
-    "quick_connect",
-    "list_devices",
+    "get_current_app",
+    "type_text",
+    "clear_text",
+    "detect_and_set_adb_keyboard",
+    "restore_keyboard",
+    "Screenshot",
+    "get_screenshot",
 ]

{phone_agent → AutoGLM_GUI}/adb/connection.py

@@ -5,7 +5,8 @@ import time
 from dataclasses import dataclass
 from enum import Enum
 
-from phone_agent.config.timing import TIMING_CONFIG
+from AutoGLM_GUI.adb.timing import TIMING_CONFIG
+from AutoGLM_GUI.adb_plus.ip import get_wifi_ip
 
 
 class ConnectionType(Enum):
@@ -261,51 +262,15 @@ class ADBConnection:
         """
         Get the IP address of a connected device.
 
+        Delegates to adb_plus.ip.get_wifi_ip() for better WiFi interface detection.
+
         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
+        return get_wifi_ip(adb_path=self.adb_path, device_id=device_id)
 
     def restart_server(self) -> tuple[bool, str]:
         """