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

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/api/__init__.py

@@ -1,5 +1,6 @@
 """FastAPI application factory and route registration."""
 
+import sys
 from importlib.resources import files
 from pathlib import Path
 
@@ -15,6 +16,13 @@ from . import agents, control, devices, media
 
 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"):

AutoGLM_GUI/api/agents.py

@@ -4,6 +4,7 @@ import json
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
+from pydantic import ValidationError
 
 from AutoGLM_GUI.config import config
 from AutoGLM_GUI.schemas import (
@@ -11,6 +12,8 @@ from AutoGLM_GUI.schemas import (
     APIModelConfig,
     ChatRequest,
     ChatResponse,
+    ConfigResponse,
+    ConfigSaveRequest,
     InitRequest,
     ResetRequest,
     StatusResponse,
@@ -31,6 +34,10 @@ router = APIRouter()
 @router.post("/api/init")
 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()
     req_agent_config = request.agent or APIAgentConfig()
 
@@ -39,15 +46,35 @@ 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
+    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 +255,107 @@ 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_manager import config_manager
+
+    # 热重载：检查文件是否被外部修改
+    config_manager.load_file_config()
+
+    # 获取有效配置和来源
+    effective_config = config_manager.get_effective_config()
+    source = config_manager.get_config_source()
+
+    # 检测冲突
+    conflicts = config_manager.detect_conflicts()
+
+    return ConfigResponse(
+        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:
+        # 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",
+        )
+
+        # 保存配置（合并模式，不丢失字段）
+        success = config_manager.save_file_config(
+            base_url=request.base_url,
+            model_name=request.model_name,
+            api_key=request.api_key,
+            merge_mode=True,
+        )
+
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to save config")
+
+        # 同步到环境变量
+        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 {config_manager.get_config_path()}",
+                "warnings": warnings,
+            }
+
+        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))
+
+
+@router.delete("/api/config")
+def delete_config_endpoint() -> dict:
+    """删除配置文件."""
+    from AutoGLM_GUI.config_manager import config_manager
+
+    try:
+        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/api/devices.py

@@ -2,7 +2,15 @@
 
 from fastapi import APIRouter
 
-from AutoGLM_GUI.schemas import DeviceListResponse
+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()
@@ -11,19 +19,101 @@ router = APIRouter()
 @router.get("/api/devices", response_model=DeviceListResponse)
 def list_devices() -> DeviceListResponse:
     """列出所有 ADB 设备。"""
-    from phone_agent.adb import list_devices as adb_list
+    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)
 
-    return DeviceListResponse(
-        devices=[
+        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,  # 真实序列号
             }
-            for d in adb_devices
-        ]
+        )
+
+    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",
     )

AutoGLM_GUI/api/media.py

@@ -1,51 +1,28 @@
-"""Media routes: screenshot, video stream, stream reset."""
+"""Media routes: screenshot and stream reset."""
 
-import asyncio
-import os
-from pathlib import Path
+from __future__ import annotations
 
-from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+from fastapi import APIRouter
 
 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
+from AutoGLM_GUI.socketio_server import stop_streamers
 
 router = APIRouter()
 
-# Debug configuration: Set DEBUG_SAVE_VIDEO_STREAM=1 to save streams to debug_streams/
-DEBUG_SAVE_STREAM = os.getenv("DEBUG_SAVE_VIDEO_STREAM", "0") == "1"
-
 
 @router.post("/api/video/reset")
 async def reset_video_stream(device_id: str | None = None) -> dict:
-    """Reset video stream (cleanup scrcpy server，多设备支持)."""
+    """Reset active scrcpy streams (Socket.IO)."""
+    stop_streamers(device_id=device_id)
     if device_id:
-        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}")
-                    scrcpy_streamers[device_id].stop()
-                    del scrcpy_streamers[device_id]
-                    print(f"[video/reset] Streamer reset for device {device_id}")
-                    return {
-                        "success": True,
-                        "message": f"Video stream reset for device {device_id}",
-                    }
-                return {
-                    "success": True,
-                    "message": f"No active video stream for device {device_id}",
-                }
-        return {"success": True, "message": f"No video stream for device {device_id}"}
-
-    device_ids = list(scrcpy_streamers.keys())
-    for dev_id in device_ids:
-        if dev_id in scrcpy_locks:
-            async with scrcpy_locks[dev_id]:
-                if dev_id in scrcpy_streamers:
-                    scrcpy_streamers[dev_id].stop()
-                    del scrcpy_streamers[dev_id]
-    print("[video/reset] All streamers reset")
+        logger.info("Video stream reset for device %s", device_id)
+        return {
+            "success": True,
+            "message": f"Video stream reset for device {device_id}",
+        }
+    logger.info("All video streams reset")
     return {"success": True, "message": "All video streams reset"}
 
 
@@ -70,210 +47,3 @@ def take_screenshot(request: ScreenshotRequest) -> ScreenshotResponse:
             is_sensitive=False,
             error=str(e),
         )
-
-
-@router.websocket("/api/video/stream")
-async def video_stream_ws(
-    websocket: WebSocket,
-    device_id: str | None = None,
-):
-    """Stream real-time H.264 video from scrcpy server via WebSocket（多设备支持）."""
-    await websocket.accept()
-
-    if not device_id:
-        await websocket.send_json({"error": "device_id is required"})
-        return
-
-    print(f"[video/stream] 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 = open(debug_file_path, "wb")
-        print(f"[video/stream] 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}")
-            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}")
-                await scrcpy_streamers[device_id].start()
-                print(f"[video/stream] 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...")
-                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"
-                        )
-
-                        # Check if we have all required parameter sets
-                        if (
-                            streamer.cached_sps
-                            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"
-                            )
-                            break
-                    except Exception as e:
-                        print(f"[video/stream] Failed to read NAL unit: {e}")
-                        await asyncio.sleep(0.5)
-                        continue
-
-                # Get initialization data (SPS + PPS + IDR)
-                init_data = streamer.get_initialization_data()
-                if not init_data:
-                    raise RuntimeError(
-                        "Failed to get initialization data (missing SPS/PPS/IDR)"
-                    )
-
-                # 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"
-                )
-
-                # Debug: Save to file
-                if debug_file:
-                    debug_file.write(init_data)
-                    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()}")
-                scrcpy_streamers[device_id].stop()
-                del scrcpy_streamers[device_id]
-                try:
-                    await websocket.send_json({"error": str(e)})
-                except Exception:
-                    pass
-                return
-        else:
-            print(f"[video/stream] Reusing streamer for device {device_id}")
-
-            streamer = scrcpy_streamers[device_id]
-            # CRITICAL: Send complete initialization data (SPS+PPS+IDR)
-            # Without IDR frame, decoder cannot start and will show black screen
-
-            # Wait for initialization data to be ready (max 5 seconds)
-            init_data = None
-            for attempt in range(10):
-                init_data = streamer.get_initialization_data()
-                if init_data:
-                    break
-                print(
-                    f"[video/stream] 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}:"
-                )
-                print(
-                    f"  - SPS: {len(streamer.cached_sps) if streamer.cached_sps else 0}B"
-                )
-                print(
-                    f"  - PPS: {len(streamer.cached_pps) if streamer.cached_pps else 0}B"
-                )
-                print(
-                    f"  - IDR: {len(streamer.cached_idr) if streamer.cached_idr else 0}B"
-                )
-                print(f"  - Total: {len(init_data)} bytes")
-
-                await websocket.send_bytes(init_data)
-                print("[video/stream] ✓ Initialization data sent successfully")
-
-                # Debug: Save to file
-                if debug_file:
-                    debug_file.write(init_data)
-                    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}")
-                try:
-                    await websocket.send_json({"error": error_msg})
-                except Exception:
-                    pass
-                return
-
-    streamer = scrcpy_streamers[device_id]
-
-    stream_failed = False
-    try:
-        nal_count = 0
-        while True:
-            try:
-                # Read one complete NAL unit
-                # Each WebSocket message = one complete NAL unit (clear semantic boundary)
-                nal_unit = await streamer.read_nal_unit(auto_cache=True)
-                await websocket.send_bytes(nal_unit)
-
-                # Debug: Save to file
-                if debug_file:
-                    debug_file.write(nal_unit)
-                    debug_file.flush()
-
-                nal_count += 1
-                if nal_count % 100 == 0:
-                    print(
-                        f"[video/stream] Device {device_id}: Sent {nal_count} NAL units"
-                    )
-            except ConnectionError as e:
-                print(f"[video/stream] Device {device_id}: Connection error: {e}")
-                stream_failed = True
-                try:
-                    await websocket.send_json({"error": f"Stream error: {str(e)}"})
-                except Exception:
-                    pass
-                break
-
-    except WebSocketDisconnect:
-        print(f"[video/stream] 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()}")
-        stream_failed = True
-        try:
-            await websocket.send_json({"error": str(e)})
-        except Exception:
-            pass
-
-    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}")
-                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")
-
-    print(f"[video/stream] Device {device_id}: Stream ended")