autoglm-gui 0.4.11__tar.gz → 0.4.13__tar.gz

{autoglm_gui-0.4.11 → autoglm_gui-0.4.13}/.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.11 → autoglm_gui-0.4.13}/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.11 → autoglm_gui-0.4.13}/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
@@ -81,8 +80,8 @@ def main() -> None:
     )
     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",
@@ -142,7 +141,7 @@ 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.config_manager import config_manager
     from AutoGLM_GUI.logger import configure_logger
 
     # Configure logging system
@@ -151,35 +150,31 @@ def main() -> None:
         log_file=None if args.no_log_file else args.log_file,
     )
 
-    # Load configuration from file
-    file_config = load_config_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()
 
-    # 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
+    # 3. 加载配置文件
+    config_manager.load_file_config()
 
-    # Merge configurations (CLI > file > defaults)
-    merged_config = merge_configs(file_config, cli_config)
+    # 4. 获取合并后的有效配置
+    effective_config = config_manager.get_effective_config()
 
-    # Set model configuration via environment variables (survives reload)
-    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"]
+    # 5. 同步到环境变量（reload 模式需要）
+    config_manager.sync_to_env()
 
-    # Refresh config from environment variables
+    # 6. 刷新旧的 config 对象（保持现有代码兼容）
     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)"
+    # 获取配置来源
+    config_source = config_manager.get_config_source()
 
     # Display startup banner
     print()
@@ -191,16 +186,16 @@ def main() -> None:
     print(f"  Server:     http://{args.host}:{args.port}")
     print()
     print("  Model Configuration:")
-    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(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 merged_config["base_url"]:
-        print("  ⚠️  WARNING: 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()
 

{autoglm_gui-0.4.11 → autoglm_gui-0.4.13}/AutoGLM_GUI/adb_plus/__init__.py

@@ -3,6 +3,9 @@
 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",
@@ -11,4 +14,7 @@ __all__ = [
     "touch_down",
     "touch_move",
     "touch_up",
+    "get_wifi_ip",
+    "get_device_serial",
+    "check_device_available",
 ]

autoglm_gui-0.4.13/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.13/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.13/AutoGLM_GUI/adb_plus/serial.py

@@ -0,0 +1,35 @@
+"""Get device serial number using ADB."""
+
+from AutoGLM_GUI.platform_utils import run_cmd_silently_sync
+
+
+def get_device_serial(device_id: str, adb_path: str = "adb") -> str | None:
+    """
+    Get the real hardware serial number of a device.
+
+    This works for both USB and WiFi connected devices,
+    returning the actual hardware serial number (ro.serialno).
+
+    Args:
+        device_id: The device ID (can be USB serial or IP:port for WiFi)
+        adb_path: Path to adb executable (default: "adb")
+
+    Returns:
+        The device hardware serial number, or None if failed
+    """
+    try:
+        # Use getprop to get the actual hardware serial number
+        # This works for both USB and WiFi connections
+        result = run_cmd_silently_sync(
+            [adb_path, "-s", device_id, "shell", "getprop", "ro.serialno"],
+            timeout=3,
+        )
+        if result.returncode == 0:
+            serial = result.stdout.strip()
+            # Filter out error messages and empty values
+            if serial and not serial.startswith("error:") and serial != "unknown":
+                return serial
+    except Exception:
+        pass
+
+    return None

{autoglm_gui-0.4.11 → autoglm_gui-0.4.13}/AutoGLM_GUI/api/__init__.py

@@ -1,5 +1,6 @@
 """FastAPI application factory and route registration."""
 
+import sys
 from importlib.resources import files
 from pathlib import Path
 
@@ -10,11 +11,18 @@ from fastapi.staticfiles import StaticFiles
 
 from AutoGLM_GUI.version import APP_VERSION
 
-from . import agents, control, devices, media
+from . import agents, control, devices, media, version
 
 
 def _get_static_dir() -> Path | None:
     """Locate packaged static assets."""
+    # Priority 1: PyInstaller bundled path (for packaged executable)
+    if getattr(sys, "_MEIPASS", None):
+        bundled_static = Path(sys._MEIPASS) / "AutoGLM_GUI" / "static"
+        if bundled_static.exists():
+            return bundled_static
+
+    # Priority 2: importlib.resources (for installed package)
     try:
         static_dir = files("AutoGLM_GUI").joinpath("static")
         if hasattr(static_dir, "_path"):
@@ -46,6 +54,7 @@ def create_app() -> FastAPI:
     app.include_router(devices.router)
     app.include_router(control.router)
     app.include_router(media.router)
+    app.include_router(version.router)
 
     static_dir = _get_static_dir()
     if static_dir is not None and static_dir.exists():

{autoglm_gui-0.4.11 → autoglm_gui-0.4.13}/AutoGLM_GUI/api/agents.py

@@ -1,18 +1,12 @@
 """Agent lifecycle and chat routes."""
 
 import json
-import os
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
+from pydantic import ValidationError
 
 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,
@@ -41,6 +35,7 @@ router = APIRouter()
 def init_agent(request: InitRequest) -> dict:
     """初始化 PhoneAgent（多设备支持）。"""
     from AutoGLM_GUI.adb_plus import ADBKeyboardInstaller
+    from AutoGLM_GUI.config_manager import config_manager
     from AutoGLM_GUI.logger import logger
 
     req_model_config = request.model or APIModelConfig()
@@ -51,6 +46,10 @@ def init_agent(request: InitRequest) -> dict:
         raise HTTPException(
             status_code=400, detail="device_id is required in agent_config"
         )
+
+    # 热重载配置文件（支持运行时手动修改）
+    config_manager.load_file_config()
+    config_manager.sync_to_env()
     config.refresh_from_env()
 
     # 检查并自动安装 ADB Keyboard
@@ -261,80 +260,86 @@ def reset_agent(request: ResetRequest) -> dict:
 @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"),
-    }
+    from AutoGLM_GUI.config_manager import config_manager
 
-    # 检查是否有 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"])
-    )
+    # 热重载：检查文件是否被外部修改
+    config_manager.load_file_config()
 
-    if has_cli_config:
-        source = "CLI arguments"
-    elif file_config:
-        source = "config file"
-    else:
-        source = "default"
+    # 获取有效配置和来源
+    effective_config = config_manager.get_effective_config()
+    source = config_manager.get_config_source()
+
+    # 检测冲突
+    conflicts = config_manager.detect_conflicts()
 
     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,
+        base_url=effective_config.base_url,
+        model_name=effective_config.model_name,
+        api_key=effective_config.api_key if effective_config.api_key != "EMPTY" else "",
+        source=source.value,
+        conflicts=[
+            {
+                "field": c.field,
+                "file_value": c.file_value,
+                "override_value": c.override_value,
+                "override_source": c.override_source.value,
+            }
+            for c in conflicts
+        ]
+        if conflicts
+        else None,
     )
 
 
 @router.post("/api/config")
 def save_config_endpoint(request: ConfigSaveRequest) -> dict:
     """保存配置到文件."""
+    from AutoGLM_GUI.config_manager import ConfigModel, config_manager
+
     try:
-        config_data = {
-            "base_url": request.base_url,
-            "model_name": request.model_name,
-        }
+        # Validate incoming configuration to avoid silently falling back to defaults
+        ConfigModel(
+            base_url=request.base_url,
+            model_name=request.model_name,
+            api_key=request.api_key or "EMPTY",
+        )
 
-        # 只有提供了 api_key 才保存
-        if request.api_key:
-            config_data["api_key"] = request.api_key
+        # 保存配置（合并模式，不丢失字段）
+        success = config_manager.save_file_config(
+            base_url=request.base_url,
+            model_name=request.model_name,
+            api_key=request.api_key,
+            merge_mode=True,
+        )
 
-        success = save_config_file(config_data)
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to save config")
 
-        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()
+        # 同步到环境变量
+        config_manager.sync_to_env()
+        config.refresh_from_env()
 
+        # 检测冲突并返回警告
+        conflicts = config_manager.detect_conflicts()
+
+        if conflicts:
+            warnings = [
+                f"{c.field}: file value overridden by {c.override_source.value}"
+                for c in conflicts
+            ]
             return {
                 "success": True,
-                "message": f"Configuration saved to {get_config_path()}",
+                "message": f"Configuration saved to {config_manager.get_config_path()}",
+                "warnings": warnings,
             }
-        else:
-            raise HTTPException(status_code=500, detail="Failed to save config")
+
+        return {
+            "success": True,
+            "message": f"Configuration saved to {config_manager.get_config_path()}",
+        }
+
+    except ValidationError as e:
+        raise HTTPException(status_code=400, detail=f"Invalid configuration: {e}")
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
@@ -342,11 +347,15 @@ def save_config_endpoint(request: ConfigSaveRequest) -> dict:
 @router.delete("/api/config")
 def delete_config_endpoint() -> dict:
     """删除配置文件."""
+    from AutoGLM_GUI.config_manager import config_manager
+
     try:
-        success = delete_config_file()
-        if success:
-            return {"success": True, "message": "Configuration deleted"}
-        else:
+        success = config_manager.delete_file_config()
+
+        if not success:
             raise HTTPException(status_code=500, detail="Failed to delete config")
+
+        return {"success": True, "message": "Configuration deleted"}
+
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))

autoglm_gui-0.4.13/AutoGLM_GUI/api/devices.py

@@ -0,0 +1,119 @@
+"""Device discovery routes."""
+
+from fastapi import APIRouter
+
+from AutoGLM_GUI.adb_plus import get_wifi_ip, get_device_serial
+
+from AutoGLM_GUI.schemas import (
+    DeviceListResponse,
+    WiFiConnectRequest,
+    WiFiConnectResponse,
+    WiFiDisconnectRequest,
+    WiFiDisconnectResponse,
+)
+from AutoGLM_GUI.state import agents
+
+router = APIRouter()
+
+
+@router.get("/api/devices", response_model=DeviceListResponse)
+def list_devices() -> DeviceListResponse:
+    """列出所有 ADB 设备。"""
+    from phone_agent.adb import list_devices as adb_list, ADBConnection
+
+    adb_devices = adb_list()
+    conn = ADBConnection()
+
+    devices_with_serial = []
+    for d in adb_devices:
+        # 使用 adb_plus 的 get_device_serial 获取真实序列号
+        serial = get_device_serial(d.device_id, conn.adb_path)
+
+        devices_with_serial.append(
+            {
+                "id": d.device_id,
+                "model": d.model or "Unknown",
+                "status": d.status,
+                "connection_type": d.connection_type.value,
+                "is_initialized": d.device_id in agents,
+                "serial": serial,  # 真实序列号
+            }
+        )
+
+    return DeviceListResponse(devices=devices_with_serial)
+
+
+@router.post("/api/devices/connect_wifi", response_model=WiFiConnectResponse)
+def connect_wifi(request: WiFiConnectRequest) -> WiFiConnectResponse:
+    """从 USB 启用 TCP/IP 并连接到 WiFi。"""
+    from phone_agent.adb import ADBConnection, ConnectionType
+
+    conn = ADBConnection()
+
+    # 优先使用传入的 device_id，否则取第一个在线设备
+    device_info = conn.get_device_info(request.device_id)
+    if not device_info:
+        return WiFiConnectResponse(
+            success=False,
+            message="No connected device found",
+            error="device_not_found",
+        )
+
+    # 已经是 WiFi 连接则直接返回
+    if device_info.connection_type == ConnectionType.REMOTE:
+        address = device_info.device_id
+        return WiFiConnectResponse(
+            success=True,
+            message="Already connected over WiFi",
+            device_id=address,
+            address=address,
+        )
+
+    # 1) 启用 tcpip
+    ok, msg = conn.enable_tcpip(port=request.port, device_id=device_info.device_id)
+    if not ok:
+        return WiFiConnectResponse(
+            success=False, message=msg or "Failed to enable tcpip", error="tcpip"
+        )
+
+    # 2) 读取设备 IP：先用本地 adb_plus 的 WiFi 优先逻辑，失败再回退上游接口
+    ip = get_wifi_ip(conn.adb_path, device_info.device_id) or conn.get_device_ip(
+        device_info.device_id
+    )
+    if not ip:
+        return WiFiConnectResponse(
+            success=False, message="Failed to get device IP", error="ip"
+        )
+
+    address = f"{ip}:{request.port}"
+
+    # 3) 连接 WiFi
+    ok, msg = conn.connect(address)
+    if not ok:
+        return WiFiConnectResponse(
+            success=False,
+            message=msg or "Failed to connect over WiFi",
+            error="connect",
+        )
+
+    return WiFiConnectResponse(
+        success=True,
+        message="Switched to WiFi successfully",
+        device_id=address,
+        address=address,
+    )
+
+
+@router.post("/api/devices/disconnect_wifi", response_model=WiFiDisconnectResponse)
+def disconnect_wifi(request: WiFiDisconnectRequest) -> WiFiDisconnectResponse:
+    """断开 WiFi 连接。"""
+    from phone_agent.adb import ADBConnection
+
+    conn = ADBConnection()
+    ok, msg = conn.disconnect(request.device_id)
+
+    return WiFiDisconnectResponse(
+        success=ok,
+        message=msg,
+        error=None if ok else "disconnect_failed",
+    )