autoglm-gui 0.4.9__py3-none-any.whl → 0.4.11__py3-none-any.whl

AutoGLM_GUI/__main__.py

@@ -76,8 +76,8 @@ 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",
@@ -110,11 +110,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 +142,45 @@ def main() -> None:
 
     from AutoGLM_GUI import server
     from AutoGLM_GUI.config import config
+    from AutoGLM_GUI.config_manager import load_config_file, merge_configs
+    from AutoGLM_GUI.logger import configure_logger
+
+    # Configure logging system
+    configure_logger(
+        console_level=args.log_level,
+        log_file=None if args.no_log_file else args.log_file,
+    )
+
+    # Load configuration from file
+    file_config = load_config_file()
+
+    # Build CLI config dictionary (only include provided arguments)
+    cli_config = {}
+    if args.base_url:
+        cli_config["base_url"] = args.base_url
+    if args.model:
+        cli_config["model_name"] = args.model
+    if args.apikey:
+        cli_config["api_key"] = args.apikey
+
+    # Merge configurations (CLI > file > defaults)
+    merged_config = merge_configs(file_config, cli_config)
 
     # 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
+    os.environ["AUTOGLM_BASE_URL"] = merged_config["base_url"]
+    os.environ["AUTOGLM_MODEL_NAME"] = merged_config["model_name"]
+    os.environ["AUTOGLM_API_KEY"] = merged_config["api_key"]
 
     # Refresh config from environment variables
     config.refresh_from_env()
 
+    # Determine configuration source
+    config_source = "default"
+    if cli_config:
+        config_source = "CLI arguments"
+    elif file_config:
+        config_source = "config file (~/.config/autoglm/config.json)"
+
     # Display startup banner
     print()
     print("=" * 50)
@@ -151,11 +191,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}")
+    print(f"    Base URL: {merged_config['base_url'] or '(not set)'}")
+    print(f"    Model:    {merged_config['model_name']}")
+    if merged_config["api_key"] != "EMPTY":
+        print("    API Key:  (configured)")
     print()
+
+    # Warning if base_url is not configured
+    if not merged_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/adb_plus/__init__.py

@@ -1,9 +1,11 @@
 """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
 
 __all__ = [
+    "ADBKeyboardInstaller",
     "Screenshot",
     "capture_screenshot",
     "touch_down",

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()

AutoGLM_GUI/api/agents.py

@@ -1,16 +1,25 @@
 """Agent lifecycle and chat routes."""
 
 import json
+import os
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
 
 from AutoGLM_GUI.config import config
+from AutoGLM_GUI.config_manager import (
+    delete_config_file,
+    get_config_path,
+    load_config_file,
+    save_config_file,
+)
 from AutoGLM_GUI.schemas import (
     APIAgentConfig,
     APIModelConfig,
     ChatRequest,
     ChatResponse,
+    ConfigResponse,
+    ConfigSaveRequest,
     InitRequest,
     ResetRequest,
     StatusResponse,
@@ -31,6 +40,9 @@ router = APIRouter()
 @router.post("/api/init")
 def init_agent(request: InitRequest) -> dict:
     """初始化 PhoneAgent（多设备支持）。"""
+    from AutoGLM_GUI.adb_plus import ADBKeyboardInstaller
+    from AutoGLM_GUI.logger import logger
+
     req_model_config = request.model or APIModelConfig()
     req_agent_config = request.agent or APIAgentConfig()
 
@@ -41,13 +53,29 @@ def init_agent(request: InitRequest) -> dict:
         )
     config.refresh_from_env()
 
+    # 检查并自动安装 ADB Keyboard
+    logger.info(f"Checking ADB Keyboard for device {device_id}...")
+    installer = ADBKeyboardInstaller(device_id=device_id)
+    status = installer.get_status()
+
+    if not (status["installed"] and status["enabled"]):
+        logger.info(f"Setting up ADB Keyboard for device {device_id}...")
+        success, message = installer.auto_setup()
+        if success:
+            logger.info(f"✓ Device {device_id}: {message}")
+        else:
+            logger.warning(f"✗ Device {device_id}: {message}")
+    else:
+        logger.info(f"✓ Device {device_id}: ADB Keyboard ready")
+
     base_url = req_model_config.base_url or config.base_url
     api_key = req_model_config.api_key or config.api_key
     model_name = req_model_config.model_name or config.model_name
 
     if not base_url:
         raise HTTPException(
-            status_code=400, detail="base_url is required (in model_config or env)"
+            status_code=400,
+            detail="base_url is required. Please configure via Settings or start with --base-url",
         )
 
     model_config = ModelConfig(
@@ -228,3 +256,97 @@ def reset_agent(request: ResetRequest) -> dict:
         "device_id": device_id,
         "message": f"Agent reset for device {device_id}",
     }
+
+
+@router.get("/api/config", response_model=ConfigResponse)
+def get_config_endpoint() -> ConfigResponse:
+    """获取当前有效配置."""
+    from AutoGLM_GUI.config import config
+
+    # 加载配置文件
+    file_config = load_config_file()
+
+    # 读取当前实际运行的配置
+    current_base_url = os.getenv("AUTOGLM_BASE_URL", config.base_url)
+    current_model_name = os.getenv("AUTOGLM_MODEL_NAME", config.model_name)
+    current_api_key = os.getenv("AUTOGLM_API_KEY", config.api_key)
+
+    # 判断配置来源
+    # 如果环境变量中有 CLI 参数设置的值，优先级最高
+    env_config = {
+        "base_url": os.getenv("AUTOGLM_BASE_URL"),
+        "model_name": os.getenv("AUTOGLM_MODEL_NAME"),
+        "api_key": os.getenv("AUTOGLM_API_KEY"),
+    }
+
+    # 检查是否有 CLI 参数（环境变量值不同于默认值且文件配置中没有对应值）
+    has_cli_config = (
+        (env_config["base_url"] and env_config["base_url"] != "") and
+        (not file_config or file_config.get("base_url") != env_config["base_url"])
+    ) or (
+        (env_config["model_name"] and env_config["model_name"] != "autoglm-phone-9b") and
+        (not file_config or file_config.get("model_name") != env_config["model_name"])
+    ) or (
+        (env_config["api_key"] and env_config["api_key"] != "EMPTY") and
+        (not file_config or file_config.get("api_key") != env_config["api_key"])
+    )
+
+    if has_cli_config:
+        source = "CLI arguments"
+    elif file_config:
+        source = "config file"
+    else:
+        source = "default"
+
+    return ConfigResponse(
+        base_url=current_base_url,
+        model_name=current_model_name,
+        api_key=current_api_key if current_api_key != "EMPTY" else "",
+        source=source,
+    )
+
+
+@router.post("/api/config")
+def save_config_endpoint(request: ConfigSaveRequest) -> dict:
+    """保存配置到文件."""
+    try:
+        config_data = {
+            "base_url": request.base_url,
+            "model_name": request.model_name,
+        }
+
+        # 只有提供了 api_key 才保存
+        if request.api_key:
+            config_data["api_key"] = request.api_key
+
+        success = save_config_file(config_data)
+
+        if success:
+            # 刷新全局配置
+            os.environ["AUTOGLM_BASE_URL"] = request.base_url
+            os.environ["AUTOGLM_MODEL_NAME"] = request.model_name
+            if request.api_key:
+                os.environ["AUTOGLM_API_KEY"] = request.api_key
+            config.refresh_from_env()
+
+            return {
+                "success": True,
+                "message": f"Configuration saved to {get_config_path()}",
+            }
+        else:
+            raise HTTPException(status_code=500, detail="Failed to save config")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/api/config")
+def delete_config_endpoint() -> dict:
+    """删除配置文件."""
+    try:
+        success = delete_config_file()
+        if success:
+            return {"success": True, "message": "Configuration deleted"}
+        else:
+            raise HTTPException(status_code=500, detail="Failed to delete config")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))