autoglm-gui 0.4.9__tar.gz → 0.4.12__tar.gz

{autoglm_gui-0.4.9 → autoglm_gui-0.4.12}/.gitignore

@@ -16,4 +16,20 @@ AutoGLM_GUI/static/
 # Frontend
 frontend/node_modules/
 frontend/dist/
+
+# Electron
+electron/node_modules/
+electron/dist/
+
+# Build resources
+resources/
+
+# Logs
+*.log
+logs/
+
+# MCP
 .mcp.json
+
+# macOS
+.DS_Store

{autoglm_gui-0.4.9 → autoglm_gui-0.4.12}/AutoGLM_GUI/__init__.py

@@ -5,6 +5,14 @@ import sys
 from functools import wraps
 from importlib import metadata
 
+# 修复 Windows 编码问题 - 必须在所有其他导入之前
+if sys.platform == "win32":
+    import codecs
+
+    sys.stdout = codecs.getwriter("utf-8")(sys.stdout.buffer, "strict")
+    sys.stderr = codecs.getwriter("utf-8")(sys.stderr.buffer, "strict")
+
+
 # ============================================================================
 # Fix Windows encoding issue: Force UTF-8 for all subprocess calls
 # ============================================================================

{autoglm_gui-0.4.9 → autoglm_gui-0.4.12}/AutoGLM_GUI/__main__.py

@@ -1,9 +1,8 @@
 """CLI entry point for AutoGLM-GUI."""
 
 import argparse
-import os
-import socket
 import sys
+import socket
 import threading
 import time
 import webbrowser
@@ -76,13 +75,13 @@ def main() -> None:
     )
     parser.add_argument(
         "--base-url",
-        required=True,
-        help="Base URL of the model API (required, e.g., http://localhost:8080/v1)",
+        required=False,
+        help="Base URL of the model API (e.g., http://localhost:8080/v1)",
     )
     parser.add_argument(
         "--model",
-        default=DEFAULT_MODEL_NAME,
-        help=f"Model name to use (default: {DEFAULT_MODEL_NAME})",
+        default=None,
+        help=f"Model name to use (default: {DEFAULT_MODEL_NAME}, or from config file)",
     )
     parser.add_argument(
         "--apikey",
@@ -110,11 +109,22 @@ def main() -> None:
         action="store_true",
         help="Do not open browser automatically",
     )
-
-    # If no arguments provided, print help and exit
-    if len(sys.argv) == 1:
-        parser.print_help()
-        sys.exit(1)
+    parser.add_argument(
+        "--log-level",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        default="INFO",
+        help="Console log level (default: INFO)",
+    )
+    parser.add_argument(
+        "--log-file",
+        default="logs/autoglm_{time:YYYY-MM-DD}.log",
+        help="Log file path (default: logs/autoglm_{time:YYYY-MM-DD}.log)",
+    )
+    parser.add_argument(
+        "--no-log-file",
+        action="store_true",
+        help="Disable file logging",
+    )
 
     args = parser.parse_args()
 
@@ -131,16 +141,41 @@ def main() -> None:
 
     from AutoGLM_GUI import server
     from AutoGLM_GUI.config import config
+    from AutoGLM_GUI.config_manager import config_manager
+    from AutoGLM_GUI.logger import configure_logger
 
-    # Set model configuration via environment variables (survives reload)
-    os.environ["AUTOGLM_BASE_URL"] = args.base_url
-    os.environ["AUTOGLM_MODEL_NAME"] = args.model
-    if args.apikey is not None:
-        os.environ["AUTOGLM_API_KEY"] = args.apikey
+    # Configure logging system
+    configure_logger(
+        console_level=args.log_level,
+        log_file=None if args.no_log_file else args.log_file,
+    )
+
+    # ==================== 配置系统初始化 ====================
+    # 使用统一配置管理器（四层优先级：CLI > ENV > FILE > DEFAULT）
+
+    # 1. 设置 CLI 参数配置（最高优先级）
+    config_manager.set_cli_config(
+        base_url=args.base_url, model_name=args.model, api_key=args.apikey
+    )
+
+    # 2. 加载环境变量配置
+    config_manager.load_env_config()
+
+    # 3. 加载配置文件
+    config_manager.load_file_config()
 
-    # Refresh config from environment variables
+    # 4. 获取合并后的有效配置
+    effective_config = config_manager.get_effective_config()
+
+    # 5. 同步到环境变量（reload 模式需要）
+    config_manager.sync_to_env()
+
+    # 6. 刷新旧的 config 对象（保持现有代码兼容）
     config.refresh_from_env()
 
+    # 获取配置来源
+    config_source = config_manager.get_config_source()
+
     # Display startup banner
     print()
     print("=" * 50)
@@ -151,11 +186,19 @@ def main() -> None:
     print(f"  Server:     http://{args.host}:{args.port}")
     print()
     print("  Model Configuration:")
-    print(f"    Base URL: {args.base_url}")
-    print(f"    Model:    {args.model}")
-    if args.apikey is not None:
-        print("    API Key:  (provided via --apikey)")
+    print(f"    Source:   {config_source.value}")
+    print(f"    Base URL: {effective_config.base_url or '(not set)'}")
+    print(f"    Model:    {effective_config.model_name}")
+    if effective_config.api_key != "EMPTY":
+        print("    API Key:  (configured)")
     print()
+
+    # Warning if base_url is not configured
+    if not effective_config.base_url:
+        print("  [!]  WARNING: base_url is not configured!")
+        print("     Please configure via frontend or use --base-url")
+        print()
+
     print("=" * 50)
     print("  Press Ctrl+C to stop")
     print("=" * 50)

{autoglm_gui-0.4.9 → autoglm_gui-0.4.12}/AutoGLM_GUI/adb_plus/__init__.py

@@ -1,12 +1,20 @@
 """Lightweight ADB helpers with a more robust screenshot implementation."""
 
+from .keyboard_installer import ADBKeyboardInstaller
 from .screenshot import Screenshot, capture_screenshot
 from .touch import touch_down, touch_move, touch_up
+from .ip import get_wifi_ip
+from .serial import get_device_serial
+from .device import check_device_available
 
 __all__ = [
+    "ADBKeyboardInstaller",
     "Screenshot",
     "capture_screenshot",
     "touch_down",
     "touch_move",
     "touch_up",
+    "get_wifi_ip",
+    "get_device_serial",
+    "check_device_available",
 ]

autoglm_gui-0.4.12/AutoGLM_GUI/adb_plus/device.py

@@ -0,0 +1,50 @@
+"""Device availability checking utilities."""
+
+import asyncio
+
+from AutoGLM_GUI.exceptions import DeviceNotAvailableError
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.platform_utils import run_cmd_silently
+
+
+async def check_device_available(device_id: str | None = None) -> None:
+    """Check if the device is available.
+
+    Args:
+        device_id: ADB device serial (None for default device)
+
+    Raises:
+        DeviceNotAvailableError: If device is not reachable
+    """
+    cmd = ["adb"]
+    if device_id:
+        cmd.extend(["-s", device_id])
+    cmd.append("get-state")
+
+    try:
+        result = await asyncio.wait_for(run_cmd_silently(cmd), timeout=5.0)
+
+        state = result.stdout.strip() if result.stdout else ""
+        error_output = result.stderr.strip() if result.stderr else ""
+
+        # Check for common error patterns
+        if "not found" in error_output.lower() or "offline" in error_output.lower():
+            raise DeviceNotAvailableError(
+                f"Device {device_id} is not available: {error_output}"
+            )
+
+        if state != "device":
+            raise DeviceNotAvailableError(
+                f"Device {device_id} is not available (state: {state or 'offline'})"
+            )
+
+        logger.debug(f"Device {device_id} is available (state: {state})")
+
+    except asyncio.TimeoutError:
+        raise DeviceNotAvailableError(f"Device {device_id} connection timed out")
+    except FileNotFoundError:
+        raise DeviceNotAvailableError("ADB executable not found")
+    except DeviceNotAvailableError:
+        raise
+    except Exception as e:
+        raise DeviceNotAvailableError(f"Failed to check device {device_id}: {e}")

autoglm_gui-0.4.12/AutoGLM_GUI/adb_plus/ip.py

@@ -0,0 +1,78 @@
+"""ADB IP helpers (prefer WiFi address, skip cellular interfaces)."""
+
+from __future__ import annotations
+
+import re
+import subprocess
+from typing import Optional
+
+__all__ = ["get_wifi_ip"]
+
+
+def _run(adb_path: str, device_id: Optional[str], cmd: list[str]) -> str:
+    base_cmd = [adb_path]
+    if device_id:
+        base_cmd.extend(["-s", device_id])
+    result = subprocess.run(
+        base_cmd + ["shell", *cmd], capture_output=True, text=True, timeout=5
+    )
+    return (result.stdout or "") + (result.stderr or "")
+
+
+def _extract_ip(text: str) -> Optional[str]:
+    m = re.search(r"\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b", text)
+    if not m:
+        return None
+    ip = m.group(0)
+    if ip == "0.0.0.0":
+        return None
+    return ip
+
+
+def get_wifi_ip(
+    adb_path: str = "adb", device_id: Optional[str] = None
+) -> Optional[str]:
+    """
+    Prefer WiFi IP when multiple interfaces exist.
+
+    - First try `ip -4 route get 8.8.8.8`, skip typical cellular interfaces (ccmni/rmnet).
+    - Fallback to `ip -4 addr show wlan0`.
+    Returns None if no suitable IP is found or on error.
+    """
+    # 1) route
+    try:
+        route_out = _run(adb_path, device_id, ["ip", "-4", "route", "get", "8.8.8.8"])
+        for line in route_out.splitlines():
+            if "src" not in line:
+                continue
+            parts = line.split()
+            iface = None
+            ip = None
+            if "dev" in parts:
+                try:
+                    iface = parts[parts.index("dev") + 1]
+                except Exception:
+                    pass
+            if "src" in parts:
+                try:
+                    ip = parts[parts.index("src") + 1]
+                except Exception:
+                    pass
+            if not ip or ip == "0.0.0.0":
+                continue
+            if iface and (iface.startswith("ccmni") or iface.startswith("rmnet")):
+                continue
+            return ip
+    except Exception:
+        pass
+
+    # 2) wlan0 addr
+    try:
+        addr_out = _run(adb_path, device_id, ["ip", "-4", "addr", "show", "wlan0"])
+        ip = _extract_ip(addr_out)
+        if ip:
+            return ip
+    except Exception:
+        pass
+
+    return None

autoglm_gui-0.4.12/AutoGLM_GUI/adb_plus/keyboard_installer.py

@@ -0,0 +1,380 @@
+"""ADB Keyboard Auto-Installation and Enablement Tool.
+
+This module provides automatic installation, configuration, and enabling of ADB Keyboard,
+without requiring users to manually download and install APK.
+"""
+
+import asyncio
+import urllib.request
+from pathlib import Path
+from typing import Optional, Tuple
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.platform_utils import run_cmd_silently
+
+ADB_KEYBOARD_PACKAGE = "com.android.adbkeyboard"
+ADB_KEYBOARD_IME = "com.android.adbkeyboard/.AdbIME"
+ADB_KEYBOARD_APK_URL = (
+    "https://github.com/senzhk/ADBKeyBoard/raw/master/ADBKeyboard.apk"
+)
+ADB_KEYBOARD_APK_FILENAME = "ADBKeyboard.apk"
+
+# APK file in user cache directory (fallback)
+USER_CACHE_APK_PATH = Path.home() / ".cache" / "autoglm" / ADB_KEYBOARD_APK_FILENAME
+
+
+class ADBKeyboardInstaller:
+    """ADB Keyboard Auto-Installer."""
+
+    def __init__(self, device_id: Optional[str] = None):
+        """
+        Initialize the installer.
+
+        Args:
+            device_id: Optional ADB device ID for multi-device scenarios.
+        """
+        self.device_id = device_id
+        self.adb_prefix = ["adb"]
+        if device_id:
+            self.adb_prefix.extend(["-s", device_id])
+
+        logger.debug(
+            f"Initialized ADBKeyboardInstaller for device: {device_id or 'default'}"
+        )
+
+    def is_installed(self) -> bool:
+        """
+        Check if ADB Keyboard is installed (via package name).
+
+        Returns:
+            bool: True if installed, False otherwise.
+        """
+        try:
+            logger.debug(
+                f"Checking if ADB Keyboard is installed on device {self.device_id or 'default'}"
+            )
+            result = asyncio.run(
+                run_cmd_silently(self.adb_prefix + ["shell", "pm", "list", "packages"])
+            )
+            package_list = result.stdout.strip()
+            installed = ADB_KEYBOARD_PACKAGE in package_list
+            logger.debug(f"ADB Keyboard installed: {installed}")
+            return installed
+        except Exception as e:
+            logger.error(f"Error checking keyboard installation status: {e}")
+            return False
+
+    def is_enabled(self) -> bool:
+        """
+        Check if ADB Keyboard is enabled (usable).
+
+        Determined by checking the list of enabled input methods.
+
+        Returns:
+            bool: True if enabled, False otherwise.
+        """
+        try:
+            logger.debug(
+                f"Checking if ADB Keyboard is enabled on device {self.device_id or 'default'}"
+            )
+            # Use ime list -s to check only enabled input methods
+            result = asyncio.run(
+                run_cmd_silently(self.adb_prefix + ["shell", "ime", "list", "-s"])
+            )
+            ime_list_enabled = result.stdout.strip()
+            enabled = ADB_KEYBOARD_IME in ime_list_enabled
+            logger.debug(f"ADB Keyboard enabled: {enabled}")
+            return enabled
+        except Exception as e:
+            logger.error(f"Error checking keyboard enable status: {e}")
+            return False
+
+    def get_apk_path(self) -> Optional[Path]:
+        """
+        Get APK file path.
+
+        Prioritizes returning the APK file within the project (bundled in wheel),
+        falls back to user cache if not exists.
+
+        Returns:
+            Optional[Path]: APK file path, or None if neither exists.
+        """
+        # Priority 1: Try bundled resource (packaged in wheel)
+        try:
+            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
+            )
+            # Convert to Path
+            if hasattr(resource, "read_bytes"):
+                # For Python 3.9+, use as_file() context manager
+                from importlib.resources import as_file
+
+                with as_file(resource) as path:
+                    if path.exists():
+                        logger.info(f"Found bundled APK: {path}")
+                        return path
+            elif hasattr(resource, "_path"):
+                # Fallback for older importlib.resources
+                path = Path(str(resource))
+                if path.exists():
+                    logger.info(f"Found bundled APK: {path}")
+                    return path
+        except Exception as e:
+            logger.debug(f"Bundled APK not found: {e}")
+
+        # Priority 2: Try user cache directory
+        if USER_CACHE_APK_PATH.exists():
+            logger.info(f"Found cached APK: {USER_CACHE_APK_PATH}")
+            return USER_CACHE_APK_PATH
+
+        logger.warning("APK file not found in bundled resources or cache")
+        return None
+
+    def download_apk(self, force: bool = False) -> bool:
+        """
+        Get or download ADB Keyboard APK.
+
+        Prioritizes using the APK file within the project, downloads from GitHub if not exists.
+
+        Args:
+            force: Whether to force re-download even if file already exists.
+
+        Returns:
+            bool: True if APK is successfully obtained, False otherwise.
+        """
+        # Check if APK already exists
+        existing_apk = self.get_apk_path()
+        if existing_apk and not force:
+            logger.debug(f"APK already exists at {existing_apk}, skipping download")
+            return True
+
+        # Download from GitHub
+        logger.info(f"Downloading ADB Keyboard APK from {ADB_KEYBOARD_APK_URL}")
+
+        # Ensure cache directory exists
+        USER_CACHE_APK_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+        try:
+            urllib.request.urlretrieve(ADB_KEYBOARD_APK_URL, USER_CACHE_APK_PATH)
+
+            if USER_CACHE_APK_PATH.exists() and USER_CACHE_APK_PATH.stat().st_size > 0:
+                logger.info(f"APK downloaded successfully to {USER_CACHE_APK_PATH}")
+                return True
+            else:
+                logger.error("Downloaded APK is empty or invalid")
+                return False
+
+        except Exception as e:
+            logger.error(f"Failed to download APK: {e}")
+            # Clean up incomplete file
+            if USER_CACHE_APK_PATH.exists():
+                USER_CACHE_APK_PATH.unlink()
+            return False
+
+    def install(self) -> Tuple[bool, str]:
+        """
+        Install ADB Keyboard APK.
+
+        Returns:
+            Tuple[bool, str]: (success, message)
+        """
+        apk_path = self.get_apk_path()
+        if not apk_path or not apk_path.exists():
+            error_msg = "APK file not found. Please download first."
+            logger.error(error_msg)
+            return False, error_msg
+
+        try:
+            logger.info(f"Installing ADB Keyboard from {apk_path}")
+            result = asyncio.run(
+                run_cmd_silently(self.adb_prefix + ["install", "-r", str(apk_path)])
+            )
+
+            if "Success" in result.stdout or result.returncode == 0:
+                success_msg = "ADB Keyboard installed successfully"
+                logger.info(success_msg)
+                return True, success_msg
+            else:
+                error_msg = f"Installation failed: {result.stdout} {result.stderr}"
+                logger.error(error_msg)
+                return False, error_msg
+
+        except Exception as e:
+            error_msg = f"Installation error: {e}"
+            logger.exception("Unexpected error during installation")
+            return False, error_msg
+
+    def enable(self) -> Tuple[bool, str]:
+        """
+        Enable ADB Keyboard (enable only, do not modify default input method).
+
+        Note: This only enables ADB Keyboard, does not set it as default input method.
+        In actual usage, Phone Agent will temporarily switch via detect_and_set_adb_keyboard().
+
+        Returns:
+            Tuple[bool, str]: (success, message)
+        """
+        try:
+            logger.info("Enabling ADB Keyboard IME")
+            # Enable keyboard
+            result = asyncio.run(
+                run_cmd_silently(
+                    self.adb_prefix + ["shell", "ime", "enable", ADB_KEYBOARD_IME]
+                )
+            )
+
+            if result.returncode == 0:
+                success_msg = "ADB Keyboard enabled successfully"
+                logger.info(success_msg)
+                return True, success_msg
+            else:
+                # Some devices return non-zero but still succeed, verify with is_enabled()
+                if self.is_enabled():
+                    success_msg = "ADB Keyboard enabled (verified)"
+                    logger.info(success_msg)
+                    return True, success_msg
+                else:
+                    error_msg = f"Enable failed: {result.stdout} {result.stderr}"
+                    logger.warning(error_msg)
+                    return False, error_msg
+
+        except Exception as e:
+            error_msg = f"Enable error: {e}"
+            logger.exception("Unexpected error during enable")
+            return False, error_msg
+
+    def auto_setup(self) -> Tuple[bool, str]:
+        """
+        Automatically complete installation and enablement process.
+
+        Intelligent handling:
+        1. Installed and enabled - skip, return True
+        2. Installed but not enabled - enable only, return result
+        3. Not installed - install+enable, return result
+
+        Note: This method does not interact with users, all user prompts should be handled by the caller.
+
+        Returns:
+            Tuple[bool, str]: (success, message)
+        """
+        logger.debug("Starting auto-setup for ADB Keyboard")
+
+        # Check current status
+        installed = self.is_installed()
+        enabled = self.is_enabled()
+
+        # Status 1: Installed and enabled
+        if installed and enabled:
+            msg = "ADB Keyboard is ready (already installed and enabled)"
+            logger.info(msg)
+            return True, msg
+
+        # Status 2: Installed but not enabled
+        if installed and not enabled:
+            logger.info("ADB Keyboard is installed but not enabled, enabling now")
+            return self.enable()
+
+        # Status 3: Not installed
+        if not installed:
+            logger.info("ADB Keyboard is not installed, starting installation")
+
+            # Step 1: Download APK (if not already available)
+            if not self.download_apk():
+                error_msg = "Failed to download APK"
+                logger.error(error_msg)
+                return False, error_msg
+
+            # Step 2: Install
+            success, message = self.install()
+            if not success:
+                logger.error(f"Installation failed: {message}")
+                return False, message
+
+            # Step 3: Enable
+            success, message = self.enable()
+            if not success:
+                logger.error(f"Enable failed: {message}")
+                return False, message
+
+            # Verify final status
+            if self.is_installed() and self.is_enabled():
+                success_msg = "ADB Keyboard setup completed successfully"
+                logger.info(success_msg)
+                return True, success_msg
+            else:
+                error_msg = "Setup completed but verification failed"
+                logger.warning(error_msg)
+                return False, error_msg
+
+        # Default return failure
+        error_msg = "Unknown status, setup failed"
+        logger.error(error_msg)
+        return False, error_msg
+
+    def get_status(self) -> dict:
+        """
+        Get detailed status of ADB Keyboard.
+
+        Returns:
+            dict: Dictionary containing installation and enablement status.
+        """
+        apk_path = self.get_apk_path()
+        installed = self.is_installed()
+        enabled = self.is_enabled()
+
+        # Determine current status
+        if installed and enabled:
+            status = "ready"  # Ready
+        elif installed and not enabled:
+            status = "installed_but_disabled"  # Installed but not enabled
+        elif not installed:
+            status = "not_installed"  # Not installed
+        else:
+            status = "unknown"  # Unknown
+
+        return {
+            "installed": installed,
+            "enabled": enabled,
+            "status": status,
+            "status_text": {
+                "ready": "Installed and enabled",
+                "installed_but_disabled": "Installed but not enabled",
+                "not_installed": "Not installed",
+                "unknown": "Unknown status",
+            }.get(status, "Unknown"),
+            "apk_exists": apk_path is not None and apk_path.exists(),
+            "apk_path": str(apk_path) if apk_path else "N/A",
+            "cache_apk_exists": USER_CACHE_APK_PATH.exists(),
+            "cache_apk_path": str(USER_CACHE_APK_PATH),
+        }
+
+
+def auto_setup_adb_keyboard(device_id: Optional[str] = None) -> Tuple[bool, str]:
+    """
+    Convenience function: One-click auto-install and enable ADB Keyboard.
+
+    Args:
+        device_id: Optional device ID.
+
+    Returns:
+        Tuple[bool, str]: (success, message)
+    """
+    installer = ADBKeyboardInstaller(device_id)
+    return installer.auto_setup()
+
+
+def check_and_suggest_installation() -> bool:
+    """
+    Check if ADB Keyboard needs installation.
+
+    Note: This function does not interact with users, only returns boolean value.
+    All user prompts should be handled by the caller.
+
+    Returns:
+        bool: True if not installed, False otherwise.
+    """
+    installer = ADBKeyboardInstaller()
+    return not installer.is_installed()