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

AutoGLM_GUI/api/devices.py

@@ -1,8 +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
+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,
@@ -12,112 +21,134 @@ from AutoGLM_GUI.schemas import (
     WiFiDisconnectResponse,
     WiFiManualConnectRequest,
     WiFiManualConnectResponse,
+    WiFiPairRequest,
+    WiFiPairResponse,
+    MdnsDiscoverResponse,
+    MdnsDeviceResponse,
+    QRPairGenerateResponse,
+    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()
 
-    return DeviceListResponse(devices=devices_with_serial)
+    # 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_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"
+            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"
 
-    # 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",
+            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
+
+    device_manager = DeviceManager.get_instance()
+    success, message = device_manager.disconnect_wifi(request.device_id)
 
-    conn = ADBConnection()
-    ok, msg = conn.disconnect(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",
     )
 
 
@@ -128,41 +159,214 @@ 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,
+    )
+
+    if success:
+        # Refresh device list to show new device
+        device_manager.force_refresh()
 
-    # 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",
+            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"
 
-    # 端口范围验证
-    if not (1 <= request.port <= 65535):
         return WiFiManualConnectResponse(
             success=False,
-            message="Port must be between 1 and 65535",
-            error="invalid_port",
+            message=message,
+            error=error_type,
         )
 
-    conn = ADBConnection()
-    address = f"{request.ip}:{request.port}"
 
-    # 直接连接
-    ok, msg = conn.connect(address)
-    if not ok:
-        return WiFiManualConnectResponse(
+@router.post("/api/devices/pair_wifi", response_model=WiFiPairResponse)
+def pair_wifi(request: WiFiPairRequest) -> WiFiPairResponse:
+    """使用无线调试配对并连接到 WiFi 设备 (Android 11+)."""
+    from AutoGLM_GUI.device_manager import DeviceManager
+
+    device_manager = DeviceManager.get_instance()
+    success, message, device_id = device_manager.pair_wifi(
+        ip=request.ip,
+        pairing_port=request.pairing_port,
+        pairing_code=request.pairing_code,
+        connection_port=request.connection_port,
+    )
+
+    if success:
+        # Refresh device list to show newly paired device
+        device_manager.force_refresh()
+
+        return WiFiPairResponse(
+            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"
+
+        return WiFiPairResponse(
             success=False,
-            message=msg or f"Failed to connect to {address}",
-            error="connect_failed",
+            message=message,
+            error=error_type,
+        )
+
+
+@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_plus import discover_mdns_devices
+
+    try:
+        conn = ADBConnection()
+        devices = discover_mdns_devices(conn.adb_path)
+
+        device_responses = [
+            MdnsDeviceResponse(
+                name=dev.name,
+                ip=dev.ip,
+                port=dev.port,
+                has_pairing=dev.has_pairing,
+                service_type=dev.service_type,
+                pairing_port=dev.pairing_port,
+            )
+            for dev in devices
+        ]
+
+        return MdnsDiscoverResponse(
+            success=True,
+            devices=device_responses,
+        )
+
+    except Exception as e:
+        return MdnsDiscoverResponse(
+            success=False,
+            devices=[],
+            error=str(e),
+        )
+
+
+# QR Code Pairing Routes
+
+
+@router.post("/api/devices/qr_pair/generate", response_model=QRPairGenerateResponse)
+def generate_qr_pairing(timeout: int = 90) -> QRPairGenerateResponse:
+    """Generate QR code for wireless pairing and start mDNS listener.
+
+    Args:
+        timeout: Session timeout in seconds (default 90)
+
+    Returns:
+        QR code payload and session information
+    """
+    try:
+        from phone_agent.adb import ADBConnection
+
+        conn = ADBConnection()
+        session = qr_pairing_manager.create_session(
+            timeout=timeout, adb_path=conn.adb_path
         )
 
-    return WiFiManualConnectResponse(
-        success=True,
-        message=f"Successfully connected to {address}",
-        device_id=address,
+        return QRPairGenerateResponse(
+            success=True,
+            qr_payload=session.qr_payload,
+            session_id=session.session_id,
+            expires_at=session.expires_at,
+            message="QR code generated, listening for devices...",
+        )
+    except Exception as e:
+        return QRPairGenerateResponse(
+            success=False,
+            message=f"Failed to generate QR pairing: {str(e)}",
+            error="generation_failed",
+        )
+
+
+def _get_status_message(status: str) -> str:
+    """Get user-friendly message for status code."""
+    messages = {
+        "listening": "等待手机扫描二维码...",
+        "pairing": "正在配对设备...",
+        "paired": "配对成功，正在连接...",
+        "connecting": "正在建立连接...",
+        "connected": "连接成功！",
+        "timeout": "超时：未检测到设备扫码",
+        "error": "配对失败",
+    }
+    return messages.get(status, "未知状态")
+
+
+@router.get(
+    "/api/devices/qr_pair/status/{session_id}", response_model=QRPairStatusResponse
+)
+def get_qr_pairing_status(session_id: str) -> QRPairStatusResponse:
+    """Get current status of a QR pairing session.
+
+    Args:
+        session_id: Session UUID
+
+    Returns:
+        Current session status and device information if connected
+    """
+    session = qr_pairing_manager.get_session(session_id)
+
+    if not session:
+        return QRPairStatusResponse(
+            session_id=session_id,
+            status="error",
+            message="Session not found or expired",
+            error="session_not_found",
+        )
+
+    return QRPairStatusResponse(
+        session_id=session.session_id,
+        status=session.status,
+        device_id=session.device_id,
+        message=_get_status_message(session.status),
+        error=session.error_message,
     )
+
+
+@router.delete("/api/devices/qr_pair/{session_id}", response_model=QRPairCancelResponse)
+def cancel_qr_pairing(session_id: str) -> QRPairCancelResponse:
+    """Cancel an active QR pairing session.
+
+    Args:
+        session_id: Session UUID to cancel
+
+    Returns:
+        Success status
+    """
+    success = qr_pairing_manager.cancel_session(session_id)
+
+    if success:
+        return QRPairCancelResponse(
+            success=True,
+            message="Pairing session cancelled",
+        )
+    else:
+        return QRPairCancelResponse(
+            success=False,
+            message="Session not found or already completed",
+        )

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"}