autoglm-gui 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

AutoGLM_GUI/api/devices.py

@@ -15,6 +15,19 @@ from AutoGLM_GUI.logger import logger
 
 from AutoGLM_GUI.schemas import (
     DeviceListResponse,
+    DeviceResponse,
+    MdnsDeviceResponse,
+    MdnsDiscoverResponse,
+    QRPairCancelResponse,
+    QRPairGenerateResponse,
+    QRPairStatusResponse,
+    RemoteDeviceAddRequest,
+    RemoteDeviceAddResponse,
+    RemoteDeviceDiscoverRequest,
+    RemoteDeviceDiscoverResponse,
+    RemoteDeviceInfo,
+    RemoteDeviceRemoveRequest,
+    RemoteDeviceRemoveResponse,
     WiFiConnectRequest,
     WiFiConnectResponse,
     WiFiDisconnectRequest,
@@ -23,49 +36,41 @@ from AutoGLM_GUI.schemas import (
     WiFiManualConnectResponse,
     WiFiPairRequest,
     WiFiPairResponse,
-    MdnsDiscoverResponse,
-    MdnsDeviceResponse,
-    QRPairGenerateResponse,
-    QRPairStatusResponse,
-    QRPairCancelResponse,
 )
 
 
 def _build_device_response_with_agent(
-    device: ManagedDevice, agent_manager: PhoneAgentManager
-) -> dict:
-    """组合设备信息和 Agent 状态（API 层职责）。
-
-    Args:
-        device: ManagedDevice 实例
-        agent_manager: PhoneAgentManager 实例
+    device: "ManagedDevice", agent_manager: "PhoneAgentManager"
+) -> DeviceResponse:
+    """聚合设备信息和 Agent 状态（API 层职责）.
 
-    Returns:
-        dict: 完整的设备响应，匹配 DeviceResponse schema
+    API 层负责协调 DeviceManager 和 PhoneAgentManager，
+    通过遍历设备的所有连接来查找已初始化的 Agent。
     """
-    # 获取纯设备信息
-    response = device.to_dict()
 
-    # 通过 serial 查找 Agent（支持连接切换）
-    agent_device_id = agent_manager.find_agent_by_serial(device.serial)
-
-    if agent_device_id:
-        metadata = agent_manager.get_metadata(agent_device_id)
+    response = device.to_dict()
 
+    # 遍历设备的所有连接，查找已初始化的 Agent
+    # 使用 device.connections 公开属性（ManagedDevice 提供）
+    for conn in device.connections:
+        # 只调用 PhoneAgentManager 的公开方法
+        metadata = agent_manager.get_metadata(conn.device_id)
         if metadata:
+            # 找到了已初始化的 Agent
             response["agent"] = {
-                "state": metadata.state.value,
+                "state": metadata.state,  # AgentState is str, Enum, already a string
                 "created_at": metadata.created_at,
                 "last_used": metadata.last_used,
                 "error_message": metadata.error_message,
                 "model_name": metadata.model_config.model_name,
             }
-        else:
-            response["agent"] = None
+
+            break  # 找到第一个 Agent 即可退出
     else:
+        # 没有找到任何已初始化的 Agent
         response["agent"] = None
 
-    return response
+    return DeviceResponse.model_validate(response)
 
 
 router = APIRouter()
@@ -97,9 +102,15 @@ def list_devices() -> DeviceListResponse:
 
 @router.post("/api/devices/connect_wifi", response_model=WiFiConnectResponse)
 def connect_wifi(request: WiFiConnectRequest) -> WiFiConnectResponse:
-    """从 USB 启用 TCP/IP 并连接到 WiFi。"""
     from AutoGLM_GUI.device_manager import DeviceManager
 
+    if not request.device_id:
+        return WiFiConnectResponse(
+            success=False,
+            message="device_id is required",
+            error="device_not_found",
+        )
+
     device_manager = DeviceManager.get_instance()
     success, message, wifi_id = device_manager.connect_wifi(
         device_id=request.device_id,
@@ -235,7 +246,7 @@ def pair_wifi(request: WiFiPairRequest) -> WiFiPairResponse:
 @router.get("/api/devices/discover_mdns", response_model=MdnsDiscoverResponse)
 def discover_mdns() -> MdnsDiscoverResponse:
     """Discover wireless ADB devices via mDNS."""
-    from phone_agent.adb import ADBConnection
+    from AutoGLM_GUI.adb import ADBConnection
     from AutoGLM_GUI.adb_plus import discover_mdns_devices
 
     try:
@@ -281,7 +292,7 @@ def generate_qr_pairing(timeout: int = 90) -> QRPairGenerateResponse:
         QR code payload and session information
     """
     try:
-        from phone_agent.adb import ADBConnection
+        from AutoGLM_GUI.adb import ADBConnection
 
         conn = ADBConnection()
         session = qr_pairing_manager.create_session(
@@ -370,3 +381,76 @@ def cancel_qr_pairing(session_id: str) -> QRPairCancelResponse:
             success=False,
             message="Session not found or already completed",
         )
+
+
+@router.post(
+    "/api/devices/discover_remote", response_model=RemoteDeviceDiscoverResponse
+)
+def discover_remote_devices(
+    request: RemoteDeviceDiscoverRequest,
+) -> RemoteDeviceDiscoverResponse:
+    """Discover devices from a remote Device Agent Server."""
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    device_manager = DeviceManager.get_instance()
+    success, message, devices_list = device_manager.discover_remote_devices(
+        base_url=request.base_url,
+        timeout=request.timeout,
+    )
+
+    devices = [RemoteDeviceInfo(**d) for d in devices_list]
+
+    return RemoteDeviceDiscoverResponse(
+        success=success,
+        devices=devices,
+        message=message,
+        error=None if success else message,
+    )
+
+
+@router.post("/api/devices/add_remote", response_model=RemoteDeviceAddResponse)
+def add_remote_device(request: RemoteDeviceAddRequest) -> RemoteDeviceAddResponse:
+    """Add a remote HTTP proxy device manually."""
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    device_manager = DeviceManager.get_instance()
+    success, message, serial = device_manager.add_remote_device(
+        base_url=request.base_url,
+        device_id=request.device_id,
+    )
+
+    if success:
+        return RemoteDeviceAddResponse(
+            success=True,
+            message=message,
+            serial=serial,
+        )
+    else:
+        error_type = "add_failed"
+        if "already exists" in message.lower():
+            error_type = "already_exists"
+        elif "connection failed" in message.lower():
+            error_type = "connection_failed"
+
+        return RemoteDeviceAddResponse(
+            success=False,
+            message=message,
+            error=error_type,
+        )
+
+
+@router.post("/api/devices/remove_remote", response_model=RemoteDeviceRemoveResponse)
+def remove_remote_device(
+    request: RemoteDeviceRemoveRequest,
+) -> RemoteDeviceRemoveResponse:
+    """Remove a remote device."""
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    device_manager = DeviceManager.get_instance()
+    success, message = device_manager.remove_remote_device(request.serial)
+
+    return RemoteDeviceRemoveResponse(
+        success=success,
+        message=message,
+        error=None if success else "remove_failed",
+    )

AutoGLM_GUI/api/health.py

@@ -0,0 +1,13 @@
+from fastapi import APIRouter
+
+from AutoGLM_GUI.version import APP_VERSION
+
+router = APIRouter(prefix="/api", tags=["health"])
+
+
+@router.get("/health")
+async def health_check() -> dict:
+    return {
+        "status": "healthy",
+        "version": APP_VERSION,
+    }

AutoGLM_GUI/api/history.py

@@ -0,0 +1,78 @@
+"""History API routes."""
+
+from fastapi import APIRouter, HTTPException
+
+from AutoGLM_GUI.history_manager import history_manager
+from AutoGLM_GUI.schemas import HistoryListResponse, HistoryRecordResponse
+
+router = APIRouter()
+
+
+@router.get("/api/history/{serialno}", response_model=HistoryListResponse)
+def list_history(
+    serialno: str, limit: int = 50, offset: int = 0
+) -> HistoryListResponse:
+    if limit < 1 or limit > 100:
+        raise HTTPException(status_code=400, detail="limit must be between 1 and 100")
+    if offset < 0:
+        raise HTTPException(status_code=400, detail="offset must be non-negative")
+
+    records = history_manager.list_records(serialno, limit=limit, offset=offset)
+    total = history_manager.get_total_count(serialno)
+
+    return HistoryListResponse(
+        records=[
+            HistoryRecordResponse(
+                id=r.id,
+                task_text=r.task_text,
+                final_message=r.final_message,
+                success=r.success,
+                steps=r.steps,
+                start_time=r.start_time.isoformat(),
+                end_time=r.end_time.isoformat() if r.end_time else None,
+                duration_ms=r.duration_ms,
+                source=r.source,
+                source_detail=r.source_detail,
+                error_message=r.error_message,
+            )
+            for r in records
+        ],
+        total=total,
+        limit=limit,
+        offset=offset,
+    )
+
+
+@router.get("/api/history/{serialno}/{record_id}", response_model=HistoryRecordResponse)
+def get_history_record(serialno: str, record_id: str) -> HistoryRecordResponse:
+    record = history_manager.get_record(serialno, record_id)
+    if not record:
+        raise HTTPException(status_code=404, detail="Record not found")
+
+    return HistoryRecordResponse(
+        id=record.id,
+        task_text=record.task_text,
+        final_message=record.final_message,
+        success=record.success,
+        steps=record.steps,
+        start_time=record.start_time.isoformat(),
+        end_time=record.end_time.isoformat() if record.end_time else None,
+        duration_ms=record.duration_ms,
+        source=record.source,
+        source_detail=record.source_detail,
+        error_message=record.error_message,
+    )
+
+
+@router.delete("/api/history/{serialno}/{record_id}")
+def delete_history_record(serialno: str, record_id: str) -> dict:
+    success = history_manager.delete_record(serialno, record_id)
+    if not success:
+        raise HTTPException(status_code=404, detail="Record not found")
+    return {"success": True, "message": "Record deleted"}
+
+
+@router.delete("/api/history/{serialno}")
+def clear_history(serialno: str) -> dict:
+    history_manager.clear_device_history(serialno)
+    return {"success": True, "message": f"History cleared for {serialno}"}