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

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

AutoGLM_GUI/api/media.py

@@ -7,6 +7,7 @@ from pathlib import Path
 from fastapi import APIRouter, WebSocket, WebSocketDisconnect
 
 from AutoGLM_GUI.adb_plus import capture_screenshot
+from AutoGLM_GUI.logger import logger
 from AutoGLM_GUI.schemas import ScreenshotRequest, ScreenshotResponse
 from AutoGLM_GUI.scrcpy_stream import ScrcpyStreamer
 from AutoGLM_GUI.state import scrcpy_locks, scrcpy_streamers
@@ -24,10 +25,10 @@ async def reset_video_stream(device_id: str | None = None) -> dict:
         if device_id in scrcpy_locks:
             async with scrcpy_locks[device_id]:
                 if device_id in scrcpy_streamers:
-                    print(f"[video/reset] Stopping streamer for device {device_id}")
+                    logger.info(f"Stopping streamer for device {device_id}")
                     scrcpy_streamers[device_id].stop()
                     del scrcpy_streamers[device_id]
-                    print(f"[video/reset] Streamer reset for device {device_id}")
+                    logger.info(f"Streamer reset for device {device_id}")
                     return {
                         "success": True,
                         "message": f"Video stream reset for device {device_id}",
@@ -45,7 +46,7 @@ async def reset_video_stream(device_id: str | None = None) -> dict:
                 if dev_id in scrcpy_streamers:
                     scrcpy_streamers[dev_id].stop()
                     del scrcpy_streamers[dev_id]
-    print("[video/reset] All streamers reset")
+    logger.info("All streamers reset")
     return {"success": True, "message": "All video streams reset"}
 
 
@@ -84,43 +85,45 @@ async def video_stream_ws(
         await websocket.send_json({"error": "device_id is required"})
         return
 
-    print(f"[video/stream] WebSocket connection for device {device_id}")
+    logger.info(f"WebSocket connection for device {device_id}")
 
     # Debug: Save stream to file for analysis (controlled by DEBUG_SAVE_VIDEO_STREAM env var)
     debug_file = None
     if DEBUG_SAVE_STREAM:
         debug_dir = Path("debug_streams")
         debug_dir.mkdir(exist_ok=True)
-        debug_file_path = debug_dir / f"{device_id}_{int(__import__('time').time())}.h264"
+        debug_file_path = (
+            debug_dir / f"{device_id}_{int(__import__('time').time())}.h264"
+        )
         debug_file = open(debug_file_path, "wb")
-        print(f"[video/stream] DEBUG: Saving stream to {debug_file_path}")
+        logger.debug(f"DEBUG: Saving stream to {debug_file_path}")
 
     if device_id not in scrcpy_locks:
         scrcpy_locks[device_id] = asyncio.Lock()
 
     async with scrcpy_locks[device_id]:
         if device_id not in scrcpy_streamers:
-            print(f"[video/stream] Creating streamer for device {device_id}")
+            logger.info(f"Creating streamer for device {device_id}")
             scrcpy_streamers[device_id] = ScrcpyStreamer(
                 device_id=device_id, max_size=1280, bit_rate=4_000_000
             )
 
             try:
-                print(f"[video/stream] Starting scrcpy server for device {device_id}")
+                logger.info(f"Starting scrcpy server for device {device_id}")
                 await scrcpy_streamers[device_id].start()
-                print(f"[video/stream] Scrcpy server started for device {device_id}")
+                logger.info(f"Scrcpy server started for device {device_id}")
 
                 # Read NAL units until we have SPS, PPS, and IDR
                 streamer = scrcpy_streamers[device_id]
 
-                print("[video/stream] Reading NAL units for initialization...")
+                logger.debug("Reading NAL units for initialization...")
                 for attempt in range(20):  # Max 20 NAL units for initialization
                     try:
                         nal_unit = await streamer.read_nal_unit(auto_cache=True)
                         nal_type = nal_unit[4] & 0x1F if len(nal_unit) > 4 else -1
                         nal_type_names = {5: "IDR", 7: "SPS", 8: "PPS"}
-                        print(
-                            f"[video/stream] Read NAL unit: type={nal_type_names.get(nal_type, nal_type)}, size={len(nal_unit)} bytes"
+                        logger.debug(
+                            f"Read NAL unit: type={nal_type_names.get(nal_type, nal_type)}, size={len(nal_unit)} bytes"
                         )
 
                         # Check if we have all required parameter sets
@@ -129,12 +132,12 @@ async def video_stream_ws(
                             and streamer.cached_pps
                             and streamer.cached_idr
                         ):
-                            print(
-                                f"[video/stream] ✓ Initialization complete: SPS={len(streamer.cached_sps)}B, PPS={len(streamer.cached_pps)}B, IDR={len(streamer.cached_idr)}B"
+                            logger.debug(
+                                f"✓ Initialization complete: SPS={len(streamer.cached_sps)}B, PPS={len(streamer.cached_pps)}B, IDR={len(streamer.cached_idr)}B"
                             )
                             break
                     except Exception as e:
-                        print(f"[video/stream] Failed to read NAL unit: {e}")
+                        logger.warning(f"Failed to read NAL unit: {e}")
                         await asyncio.sleep(0.5)
                         continue
 
@@ -147,8 +150,8 @@ async def video_stream_ws(
 
                 # Send initialization data as ONE message (SPS+PPS+IDR combined)
                 await websocket.send_bytes(init_data)
-                print(
-                    f"[video/stream] ✓ Sent initialization data to first client: {len(init_data)} bytes total"
+                logger.debug(
+                    f"✓ Sent initialization data to first client: {len(init_data)} bytes total"
                 )
 
                 # Debug: Save to file
@@ -157,10 +160,7 @@ async def video_stream_ws(
                     debug_file.flush()
 
             except Exception as e:
-                import traceback
-
-                print(f"[video/stream] Failed to start streamer: {e}")
-                print(f"[video/stream] Traceback:\n{traceback.format_exc()}")
+                logger.exception(f"Failed to start streamer: {e}")
                 scrcpy_streamers[device_id].stop()
                 del scrcpy_streamers[device_id]
                 try:
@@ -169,7 +169,7 @@ async def video_stream_ws(
                     pass
                 return
         else:
-            print(f"[video/stream] Reusing streamer for device {device_id}")
+            logger.info(f"Reusing streamer for device {device_id}")
 
             streamer = scrcpy_streamers[device_id]
             # CRITICAL: Send complete initialization data (SPS+PPS+IDR)
@@ -181,29 +181,29 @@ async def video_stream_ws(
                 init_data = streamer.get_initialization_data()
                 if init_data:
                     break
-                print(
-                    f"[video/stream] Waiting for initialization data (attempt {attempt + 1}/10)..."
+                logger.debug(
+                    f"Waiting for initialization data (attempt {attempt + 1}/10)..."
                 )
                 await asyncio.sleep(0.5)
 
             if init_data:
                 # Log what we're sending
-                print(
-                    f"[video/stream] ✓ Sending cached initialization data for device {device_id}:"
+                logger.debug(
+                    f"✓ Sending cached initialization data for device {device_id}:"
                 )
-                print(
+                logger.debug(
                     f"  - SPS: {len(streamer.cached_sps) if streamer.cached_sps else 0}B"
                 )
-                print(
+                logger.debug(
                     f"  - PPS: {len(streamer.cached_pps) if streamer.cached_pps else 0}B"
                 )
-                print(
+                logger.debug(
                     f"  - IDR: {len(streamer.cached_idr) if streamer.cached_idr else 0}B"
                 )
-                print(f"  - Total: {len(init_data)} bytes")
+                logger.debug(f"  - Total: {len(init_data)} bytes")
 
                 await websocket.send_bytes(init_data)
-                print("[video/stream] ✓ Initialization data sent successfully")
+                logger.debug("✓ Initialization data sent successfully")
 
                 # Debug: Save to file
                 if debug_file:
@@ -211,7 +211,7 @@ async def video_stream_ws(
                     debug_file.flush()
             else:
                 error_msg = f"Initialization data not ready for device {device_id} after 5 seconds"
-                print(f"[video/stream] ERROR: {error_msg}")
+                logger.error(f"ERROR: {error_msg}")
                 try:
                     await websocket.send_json({"error": error_msg})
                 except Exception:
@@ -237,11 +237,9 @@ async def video_stream_ws(
 
                 nal_count += 1
                 if nal_count % 100 == 0:
-                    print(
-                        f"[video/stream] Device {device_id}: Sent {nal_count} NAL units"
-                    )
+                    logger.debug(f"Device {device_id}: Sent {nal_count} NAL units")
             except ConnectionError as e:
-                print(f"[video/stream] Device {device_id}: Connection error: {e}")
+                logger.warning(f"Device {device_id}: Connection error: {e}")
                 stream_failed = True
                 try:
                     await websocket.send_json({"error": f"Stream error: {str(e)}"})
@@ -250,12 +248,9 @@ async def video_stream_ws(
                 break
 
     except WebSocketDisconnect:
-        print(f"[video/stream] Device {device_id}: Client disconnected")
+        logger.info(f"Device {device_id}: Client disconnected")
     except Exception as e:
-        import traceback
-
-        print(f"[video/stream] Device {device_id}: Error: {e}")
-        print(f"[video/stream] Traceback:\n{traceback.format_exc()}")
+        logger.exception(f"Device {device_id}: Error: {e}")
         stream_failed = True
         try:
             await websocket.send_json({"error": str(e)})
@@ -265,13 +260,13 @@ async def video_stream_ws(
     if stream_failed:
         async with scrcpy_locks[device_id]:
             if device_id in scrcpy_streamers:
-                print(f"[video/stream] Resetting streamer for device {device_id}")
+                logger.info(f"Resetting streamer for device {device_id}")
                 scrcpy_streamers[device_id].stop()
                 del scrcpy_streamers[device_id]
 
     # Debug: Close file
     if debug_file:
         debug_file.close()
-        print("[video/stream] DEBUG: Closed debug file")
+        logger.debug("DEBUG: Closed debug file")
 
-    print(f"[video/stream] Device {device_id}: Stream ended")
+    logger.info(f"Device {device_id}: Stream ended")

AutoGLM_GUI/config_manager.py

@@ -0,0 +1,124 @@
+"""配置文件管理模块."""
+
+import json
+from pathlib import Path
+
+from AutoGLM_GUI.logger import logger
+
+# 默认配置
+DEFAULT_CONFIG = {"base_url": "", "model_name": "autoglm-phone-9b", "api_key": "EMPTY"}
+
+
+def get_config_path() -> Path:
+    """获取配置文件路径.
+
+    Returns:
+        Path: 配置文件路径 (~/.config/autoglm/config.json)
+    """
+    config_dir = Path.home() / ".config" / "autoglm"
+    return config_dir / "config.json"
+
+
+def load_config_file() -> dict | None:
+    """从文件加载配置.
+
+    Returns:
+        dict | None: 配置字典，如果文件不存在或加载失败则返回 None
+    """
+    config_path = get_config_path()
+
+    # 文件不存在（首次运行）
+    if not config_path.exists():
+        logger.debug(f"Config file not found at {config_path}")
+        return None
+
+    try:
+        with open(config_path, "r", encoding="utf-8") as f:
+            config = json.load(f)
+            logger.info(f"Loaded configuration from {config_path}")
+            return config
+    except json.JSONDecodeError as e:
+        logger.warning(f"Failed to parse config file {config_path}: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Failed to read config file {config_path}: {e}")
+        return None
+
+
+def save_config_file(config: dict) -> bool:
+    """保存配置到文件（原子写入）.
+
+    Args:
+        config: 配置字典
+
+    Returns:
+        bool: 成功返回 True，失败返回 False
+    """
+    config_path = get_config_path()
+
+    try:
+        # 确保目录存在
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # 原子写入：先写入临时文件，然后重命名
+        temp_path = config_path.with_suffix(".tmp")
+        with open(temp_path, "w", encoding="utf-8") as f:
+            json.dump(config, f, indent=2, ensure_ascii=False)
+
+        # 重命名（原子操作）
+        temp_path.replace(config_path)
+
+        logger.info(f"Configuration saved to {config_path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to save config file {config_path}: {e}")
+        return False
+
+
+def delete_config_file() -> bool:
+    """删除配置文件.
+
+    Returns:
+        bool: 成功返回 True，失败返回 False
+    """
+    config_path = get_config_path()
+
+    if not config_path.exists():
+        logger.debug(f"Config file does not exist: {config_path}")
+        return True
+
+    try:
+        config_path.unlink()
+        logger.info(f"Configuration deleted: {config_path}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to delete config file {config_path}: {e}")
+        return False
+
+
+def merge_configs(file_config: dict | None, cli_config: dict | None) -> dict:
+    """合并配置（优先级：CLI > 文件 > 默认值）.
+
+    Args:
+        file_config: 从文件加载的配置（可为 None）
+        cli_config: CLI 参数配置（可为 None）
+
+    Returns:
+        dict: 合并后的配置字典
+    """
+    # 从默认配置开始
+    merged = DEFAULT_CONFIG.copy()
+
+    # 应用文件配置（如果存在）
+    if file_config:
+        for key in DEFAULT_CONFIG.keys():
+            if key in file_config:
+                merged[key] = file_config[key]
+
+    # 应用 CLI 配置（最高优先级）
+    if cli_config:
+        for key in DEFAULT_CONFIG.keys():
+            if key in cli_config:
+                merged[key] = cli_config[key]
+
+    return merged

AutoGLM_GUI/logger.py

@@ -0,0 +1,85 @@
+"""
+Centralized logging configuration using loguru.
+"""
+
+import sys
+from pathlib import Path
+from loguru import logger
+
+# Remove default handler
+logger.remove()
+
+# Default configuration - will be overridden by configure_logger()
+_configured = False
+
+
+def configure_logger(
+    console_level: str = "INFO",
+    log_file: str | None = "logs/autoglm_{time:YYYY-MM-DD}.log",
+    log_level: str = "DEBUG",
+    rotation: str = "100 MB",
+    retention: str = "7 days",
+    compression: str = "zip",
+) -> None:
+    """
+    Configure the global logger with console and file handlers.
+
+    Args:
+        console_level: Console output level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Log file path (None to disable file logging)
+        log_level: File logging level
+        rotation: Log rotation policy (e.g., "100 MB", "1 day")
+        retention: Log retention policy (e.g., "7 days", "1 week")
+        compression: Compression format for rotated logs (e.g., "zip", "gz")
+    """
+    global _configured
+
+    # Remove existing handlers if reconfiguring
+    if _configured:
+        logger.remove()
+
+    # Console handler with colors
+    logger.add(
+        sys.stderr,
+        format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>",
+        level=console_level,
+        colorize=True,
+    )
+
+    # File handler
+    if log_file:
+        # Create logs directory if it doesn't exist
+        log_path = Path(log_file)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+
+        logger.add(
+            log_file,
+            rotation=rotation,
+            retention=retention,
+            compression=compression,
+            level=log_level,
+            format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}",
+            encoding="utf-8",
+        )
+
+        # Separate error log file
+        error_file = str(log_path.parent / f"errors_{log_path.name.split('_', 1)[1]}")
+        logger.add(
+            error_file,
+            rotation="50 MB",
+            retention="30 days",
+            compression=compression,
+            level="ERROR",
+            format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}",
+            backtrace=True,
+            diagnose=True,
+            encoding="utf-8",
+        )
+
+    _configured = True
+
+
+# Default initialization (can be reconfigured later)
+configure_logger()
+
+__all__ = ["logger", "configure_logger"]

AutoGLM_GUI/platform_utils.py

@@ -0,0 +1,43 @@
+"""Platform-aware subprocess helpers to avoid duplicated Windows branches."""
+
+import asyncio
+import platform
+import subprocess
+from typing import Any, Sequence
+
+
+def is_windows() -> bool:
+    """Return True if running on Windows."""
+    return platform.system() == "Windows"
+
+
+async def run_cmd_silently(cmd: Sequence[str]) -> subprocess.CompletedProcess:
+    """Run a command, suppressing output but preserving it in the result; safe for async contexts on all platforms."""
+    if is_windows():
+        # Avoid blocking the event loop with a blocking subprocess call on Windows.
+        return await asyncio.to_thread(
+            subprocess.run, cmd, capture_output=True, text=True, check=False
+        )
+
+    # Use PIPE on macOS/Linux to capture output
+    process = await asyncio.create_subprocess_exec(
+        *cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+    )
+    stdout, stderr = await process.communicate()
+    # Decode bytes to string for API consistency across platforms
+    stdout_str = stdout.decode("utf-8") if stdout else ""
+    stderr_str = stderr.decode("utf-8") if stderr else ""
+    # Return CompletedProcess with stdout/stderr for API consistency across platforms
+    return_code = process.returncode if process.returncode is not None else -1
+    return subprocess.CompletedProcess(cmd, return_code, stdout_str, stderr_str)
+
+
+async def spawn_process(cmd: Sequence[str], *, capture_output: bool = False) -> Any:
+    """Start a long-running process with optional stdio capture."""
+    stdout = subprocess.PIPE if capture_output else None
+    stderr = subprocess.PIPE if capture_output else None
+
+    if is_windows():
+        return subprocess.Popen(cmd, stdout=stdout, stderr=stderr)
+
+    return await asyncio.create_subprocess_exec(*cmd, stdout=stdout, stderr=stderr)