autoglm-gui 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

AutoGLM_GUI/api/devices.py

@@ -1,9 +1,17 @@
 """Device discovery routes."""
 
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from fastapi import APIRouter
 
-from AutoGLM_GUI.adb_plus import get_wifi_ip, get_device_serial, pair_device
+if TYPE_CHECKING:
+    from AutoGLM_GUI.device_manager import ManagedDevice
+    from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
+
 from AutoGLM_GUI.adb_plus.qr_pair import qr_pairing_manager
+from AutoGLM_GUI.logger import logger
 
 from AutoGLM_GUI.schemas import (
     DeviceListResponse,
@@ -21,111 +29,126 @@ from AutoGLM_GUI.schemas import (
     QRPairStatusResponse,
     QRPairCancelResponse,
 )
-from AutoGLM_GUI.state import agents
+
+
+def _build_device_response_with_agent(
+    device: ManagedDevice, agent_manager: PhoneAgentManager
+) -> dict:
+    """组合设备信息和 Agent 状态（API 层职责）。
+
+    Args:
+        device: ManagedDevice 实例
+        agent_manager: PhoneAgentManager 实例
+
+    Returns:
+        dict: 完整的设备响应，匹配 DeviceResponse schema
+    """
+    # 获取纯设备信息
+    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)
+
+        if metadata:
+            response["agent"] = {
+                "state": metadata.state.value,
+                "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
+    else:
+        response["agent"] = None
+
+    return response
+
 
 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,  # 真实序列号
-            }
-        )
+    """列出所有 ADB 设备及 Agent 状态."""
+    from AutoGLM_GUI.device_manager import DeviceManager
+    from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
+
+    device_manager = DeviceManager.get_instance()
+    agent_manager = PhoneAgentManager.get_instance()
+
+    # Fallback: 如果轮询未启动,执行同步获取
+    if not device_manager._poll_thread or not device_manager._poll_thread.is_alive():
+        logger.warning("Polling not started, performing synchronous device fetch")
+        device_manager.force_refresh()
+
+    managed_devices = device_manager.get_devices()
+
+    # API 层负责聚合设备信息和 Agent 状态
+    devices_with_agents = [
+        _build_device_response_with_agent(d, agent_manager) for d in managed_devices
+    ]
 
-    return DeviceListResponse(devices=devices_with_serial)
+    return DeviceListResponse(devices=devices_with_agents)
 
 
 @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
+    from AutoGLM_GUI.device_manager import DeviceManager
 
-    conn = ADBConnection()
+    device_manager = DeviceManager.get_instance()
+    success, message, wifi_id = device_manager.connect_wifi(
+        device_id=request.device_id,
+        port=request.port,
+    )
 
-    # 优先使用传入的 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",
-        )
+    if success:
+        # Immediately refresh device list to show new WiFi device
+        device_manager.force_refresh()
 
-    # 已经是 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"
+            message=message,
+            device_id=wifi_id,
+            address=wifi_id,
         )
+    else:
+        # Determine error type from message
+        error_type = "connect"
+        if "not found" in message.lower():
+            error_type = "device_not_found"
+        elif "tcpip" in message.lower():
+            error_type = "tcpip"
+        elif "ip" in message.lower():
+            error_type = "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",
+            message=message,
+            error=error_type,
         )
 
-    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
+    from AutoGLM_GUI.device_manager import DeviceManager
 
-    conn = ADBConnection()
-    ok, msg = conn.disconnect(request.device_id)
+    device_manager = DeviceManager.get_instance()
+    success, message = device_manager.disconnect_wifi(request.device_id)
+
+    if success:
+        # Refresh device list to update status
+        device_manager.force_refresh()
 
     return WiFiDisconnectResponse(
-        success=ok,
-        message=msg,
-        error=None if ok else "disconnect_failed",
+        success=success,
+        message=message,
+        error=None if success else "disconnect_failed",
     )
 
 
@@ -136,120 +159,78 @@ def connect_wifi_manual(
     request: WiFiManualConnectRequest,
 ) -> WiFiManualConnectResponse:
     """手动连接到 WiFi 设备 (直接连接,无需 USB)."""
-    import re
+    from AutoGLM_GUI.device_manager import DeviceManager
 
-    from phone_agent.adb import ADBConnection
+    device_manager = DeviceManager.get_instance()
+    success, message, device_id = device_manager.connect_wifi_manual(
+        ip=request.ip,
+        port=request.port,
+    )
 
-    # IP 格式验证
-    ip_pattern = r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$"
-    if not re.match(ip_pattern, request.ip):
-        return WiFiManualConnectResponse(
-            success=False,
-            message="Invalid IP address format",
-            error="invalid_ip",
-        )
+    if success:
+        # Refresh device list to show new device
+        device_manager.force_refresh()
 
-    # 端口范围验证
-    if not (1 <= request.port <= 65535):
         return WiFiManualConnectResponse(
-            success=False,
-            message="Port must be between 1 and 65535",
-            error="invalid_port",
+            success=True,
+            message=message,
+            device_id=device_id,
         )
+    else:
+        # Determine error type from message
+        error_type = "connect_failed"
+        if "Invalid IP" in message:
+            error_type = "invalid_ip"
+        elif "Port must be" in message:
+            error_type = "invalid_port"
 
-    conn = ADBConnection()
-    address = f"{request.ip}:{request.port}"
-
-    # 直接连接
-    ok, msg = conn.connect(address)
-    if not ok:
         return WiFiManualConnectResponse(
             success=False,
-            message=msg or f"Failed to connect to {address}",
-            error="connect_failed",
+            message=message,
+            error=error_type,
         )
 
-    return WiFiManualConnectResponse(
-        success=True,
-        message=f"Successfully connected to {address}",
-        device_id=address,
-    )
-
 
 @router.post("/api/devices/pair_wifi", response_model=WiFiPairResponse)
 def pair_wifi(request: WiFiPairRequest) -> WiFiPairResponse:
     """使用无线调试配对并连接到 WiFi 设备 (Android 11+)."""
-    import re
-
-    from phone_agent.adb import ADBConnection
-
-    # IP 格式验证
-    ip_pattern = r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$"
-    if not re.match(ip_pattern, request.ip):
-        return WiFiPairResponse(
-            success=False,
-            message="Invalid IP address format",
-            error="invalid_ip",
-        )
+    from AutoGLM_GUI.device_manager import DeviceManager
 
-    # 配对端口验证
-    if not (1 <= request.pairing_port <= 65535):
-        return WiFiPairResponse(
-            success=False,
-            message="Pairing port must be between 1 and 65535",
-            error="invalid_port",
-        )
-
-    # 连接端口验证
-    if not (1 <= request.connection_port <= 65535):
-        return WiFiPairResponse(
-            success=False,
-            message="Connection port must be between 1 and 65535",
-            error="invalid_port",
-        )
-
-    # 配对码验证 (6 位数字)
-    if not request.pairing_code.isdigit() or len(request.pairing_code) != 6:
-        return WiFiPairResponse(
-            success=False,
-            message="Pairing code must be 6 digits",
-            error="invalid_pairing_code",
-        )
-
-    conn = ADBConnection()
-
-    # 步骤 1: 配对设备
-    ok, msg = pair_device(
+    device_manager = DeviceManager.get_instance()
+    success, message, device_id = device_manager.pair_wifi(
         ip=request.ip,
-        port=request.pairing_port,
+        pairing_port=request.pairing_port,
         pairing_code=request.pairing_code,
-        adb_path=conn.adb_path,
+        connection_port=request.connection_port,
     )
 
-    if not ok:
+    if success:
+        # Refresh device list to show newly paired device
+        device_manager.force_refresh()
+
         return WiFiPairResponse(
-            success=False,
-            message=msg,
-            error="pair_failed",
+            success=True,
+            message=message,
+            device_id=device_id,
         )
+    else:
+        # Determine error type from message
+        error_type = "connect_failed"
+        if "Invalid IP" in message:
+            error_type = "invalid_ip"
+        elif "port must be" in message.lower():
+            error_type = "invalid_port"
+        elif "Pairing code must be" in message:
+            error_type = "invalid_pairing_code"
+        elif "connection failed" not in message.lower():
+            error_type = "pair_failed"
 
-    # 步骤 2: 使用标准 ADB 端口连接到设备
-    connection_address = f"{request.ip}:{request.connection_port}"
-    ok, connect_msg = conn.connect(connection_address)
-
-    if not ok:
         return WiFiPairResponse(
             success=False,
-            message=f"Paired successfully but connection failed: {connect_msg}",
-            error="connect_failed",
+            message=message,
+            error=error_type,
         )
 
-    return WiFiPairResponse(
-        success=True,
-        message=f"Successfully paired and connected to {connection_address}",
-        device_id=connection_address,
-    )
-
 
 @router.get("/api/devices/discover_mdns", response_model=MdnsDiscoverResponse)
 def discover_mdns() -> MdnsDiscoverResponse:

AutoGLM_GUI/api/workflows.py

@@ -0,0 +1,70 @@
+"""Workflow API 路由."""
+
+from fastapi import APIRouter, HTTPException
+
+from AutoGLM_GUI.schemas import (
+    WorkflowCreate,
+    WorkflowListResponse,
+    WorkflowResponse,
+    WorkflowUpdate,
+)
+
+router = APIRouter()
+
+
+@router.get("/api/workflows", response_model=WorkflowListResponse)
+def list_workflows() -> WorkflowListResponse:
+    """获取所有 workflows."""
+    from AutoGLM_GUI.workflow_manager import workflow_manager
+
+    workflows = workflow_manager.list_workflows()
+    return WorkflowListResponse(workflows=workflows)
+
+
+@router.get("/api/workflows/{workflow_uuid}", response_model=WorkflowResponse)
+def get_workflow(workflow_uuid: str) -> WorkflowResponse:
+    """获取单个 workflow."""
+    from AutoGLM_GUI.workflow_manager import workflow_manager
+
+    workflow = workflow_manager.get_workflow(workflow_uuid)
+    if not workflow:
+        raise HTTPException(status_code=404, detail="Workflow not found")
+    return WorkflowResponse(**workflow)
+
+
+@router.post("/api/workflows", response_model=WorkflowResponse)
+def create_workflow(request: WorkflowCreate) -> WorkflowResponse:
+    """创建新 workflow."""
+    from AutoGLM_GUI.workflow_manager import workflow_manager
+
+    try:
+        workflow = workflow_manager.create_workflow(
+            name=request.name, text=request.text
+        )
+        return WorkflowResponse(**workflow)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.put("/api/workflows/{workflow_uuid}", response_model=WorkflowResponse)
+def update_workflow(workflow_uuid: str, request: WorkflowUpdate) -> WorkflowResponse:
+    """更新 workflow."""
+    from AutoGLM_GUI.workflow_manager import workflow_manager
+
+    workflow = workflow_manager.update_workflow(
+        uuid=workflow_uuid, name=request.name, text=request.text
+    )
+    if not workflow:
+        raise HTTPException(status_code=404, detail="Workflow not found")
+    return WorkflowResponse(**workflow)
+
+
+@router.delete("/api/workflows/{workflow_uuid}")
+def delete_workflow(workflow_uuid: str) -> dict:
+    """删除 workflow."""
+    from AutoGLM_GUI.workflow_manager import workflow_manager
+
+    success = workflow_manager.delete_workflow(workflow_uuid)
+    if not success:
+        raise HTTPException(status_code=404, detail="Workflow not found")
+    return {"success": True, "message": "Workflow deleted"}