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

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,7 +85,7 @@ 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
@@ -95,34 +96,34 @@ async def video_stream_ws(
             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
@@ -131,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
 
@@ -149,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
@@ -159,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:
@@ -171,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)
@@ -183,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:
@@ -213,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:
@@ -239,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)}"})
@@ -252,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)})
@@ -267,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

@@ -12,18 +12,24 @@ def is_windows() -> bool:
 
 
 async def run_cmd_silently(cmd: Sequence[str]) -> subprocess.CompletedProcess:
-    """Run a command, suppressing output; safe for async contexts on all platforms."""
+    """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, check=False
+            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.DEVNULL, stderr=subprocess.DEVNULL
+        *cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
     )
-    await process.wait()
-    return subprocess.CompletedProcess(cmd, process.returncode, None, None)
+    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: