autoglm-gui 1.4.1__py3-none-any.whl → 1.5.1__py3-none-any.whl

AutoGLM_GUI/schemas.py

@@ -2,63 +2,11 @@
 
 import re
 
-from pydantic import BaseModel, Field, field_validator
-
-
-class APIModelConfig(BaseModel):
-    base_url: str | None = None
-    api_key: str | None = None
-    model_name: str | None = None
-    max_tokens: int = 3000
-    temperature: float = 0.0
-    top_p: float = 0.85
-    frequency_penalty: float = 0.2
-
-    @field_validator("base_url")
-    @classmethod
-    def validate_base_url(cls, v: str | None) -> str | None:
-        """验证 base_url 格式."""
-        if v is None:
-            return v
-        v = v.strip()
-        if not v:
-            return None
-        # 检查是否是有效的 HTTP/HTTPS URL
-        if not re.match(r"^https?://", v):
-            raise ValueError("base_url must start with http:// or https://")
-        return v
-
-
-class APIAgentConfig(BaseModel):
-    max_steps: int = 100
-    device_id: str | None = None
-    lang: str = "cn"
-    system_prompt: str | None = None
-    verbose: bool = True
-
-    @field_validator("max_steps")
-    @classmethod
-    def validate_max_steps(cls, v: int) -> int:
-        """验证 max_steps 范围."""
-        if v <= 0:
-            raise ValueError("max_steps must be positive")
-        if v > 1000:
-            raise ValueError("max_steps must be <= 1000")
-        return v
-
-    @field_validator("lang")
-    @classmethod
-    def validate_lang(cls, v: str) -> str:
-        """验证 lang 有效性."""
-        allowed_langs = ["cn", "en"]
-        if v not in allowed_langs:
-            raise ValueError(f"lang must be one of {allowed_langs}")
-        return v
+from pydantic import BaseModel, field_validator
 
 
 class InitRequest(BaseModel):
-    model: APIModelConfig | None = Field(default=None, alias="model_config")
-    agent: APIAgentConfig | None = Field(default=None, alias="agent_config")
+    device_id: str  # Device ID (required)
 
     # Agent configuration (factory pattern)
     agent_type: str = "glm"  # Agent type to use (e.g., "glm", "mai")
@@ -341,12 +289,6 @@ class ConfigResponse(BaseModel):
     api_key: str  # 返回实际值（明文）
     source: str  # "CLI arguments" | "environment variables" | "config file (...)" | "default"
 
-    # 双模型配置
-    dual_model_enabled: bool = False
-    decision_base_url: str = ""
-    decision_model_name: str = ""
-    decision_api_key: str = ""
-
     # Agent 类型配置
     agent_type: str = "glm"  # Agent type (e.g., "glm", "mai")
     agent_config_params: dict | None = None  # Agent-specific configuration
@@ -354,6 +296,11 @@ class ConfigResponse(BaseModel):
     # Agent 执行配置
     default_max_steps: int = 100  # 单次任务最大执行步数
 
+    # 决策模型配置（用于分层代理）
+    decision_base_url: str | None = None
+    decision_model_name: str | None = None
+    decision_api_key: str | None = None
+
     conflicts: list[dict] | None = None  # 配置冲突信息（可选）
 
 
@@ -364,12 +311,6 @@ class ConfigSaveRequest(BaseModel):
     model_name: str = "autoglm-phone-9b"
     api_key: str | None = None
 
-    # 双模型配置
-    dual_model_enabled: bool | None = None
-    decision_base_url: str | None = None
-    decision_model_name: str | None = None
-    decision_api_key: str | None = None
-
     # Agent 类型配置
     agent_type: str = "glm"  # Agent type to use (e.g., "glm", "mai")
     agent_config_params: dict | None = None  # Agent-specific configuration parameters
@@ -377,6 +318,11 @@ class ConfigSaveRequest(BaseModel):
     # Agent 执行配置
     default_max_steps: int | None = None  # 单次任务最大执行步数
 
+    # 决策模型配置（用于分层代理）
+    decision_base_url: str | None = None
+    decision_model_name: str | None = None
+    decision_api_key: str | None = None
+
     @field_validator("default_max_steps")
     @classmethod
     def validate_default_max_steps(cls, v: int | None) -> int | None:
@@ -412,12 +358,21 @@ class ConfigSaveRequest(BaseModel):
     @classmethod
     def validate_decision_base_url(cls, v: str | None) -> str | None:
         """验证 decision_base_url 格式."""
-        if v is None or not v.strip():
-            return None
-        v = v.strip()
-        if not re.match(r"^https?://", v):
-            raise ValueError("decision_base_url must start with http:// or https://")
-        return v
+        if v is not None and v.strip():
+            if not re.match(r"^https?://", v):
+                raise ValueError(
+                    "decision_base_url must start with http:// or https://"
+                )
+            return v.rstrip("/")
+        return None
+
+    @field_validator("decision_model_name")
+    @classmethod
+    def validate_decision_model_name(cls, v: str | None) -> str | None:
+        """验证 decision_model_name 非空."""
+        if v is not None and v.strip():
+            return v.strip()
+        return None
 
 
 class WiFiConnectRequest(BaseModel):
@@ -642,3 +597,222 @@ class WorkflowListResponse(BaseModel):
     """Workflow 列表响应."""
 
     workflows: list[WorkflowResponse]
+
+
+class RemoteDeviceInfo(BaseModel):
+    """远程设备信息."""
+
+    device_id: str
+    model: str
+    platform: str
+    status: str
+
+
+class RemoteDeviceDiscoverRequest(BaseModel):
+    """远程设备发现请求."""
+
+    base_url: str
+    timeout: int = 5
+
+    @field_validator("base_url")
+    @classmethod
+    def validate_base_url(cls, v: str) -> str:
+        v = v.strip().rstrip("/")
+        if not v.startswith(("http://", "https://")):
+            raise ValueError("base_url must start with http:// or https://")
+        return v
+
+    @field_validator("timeout")
+    @classmethod
+    def validate_timeout(cls, v: int) -> int:
+        if v <= 0:
+            raise ValueError("timeout must be positive")
+        if v > 30:
+            raise ValueError("timeout must be <= 30 seconds")
+        return v
+
+
+class RemoteDeviceDiscoverResponse(BaseModel):
+    """远程设备发现响应."""
+
+    success: bool
+    devices: list[RemoteDeviceInfo]
+    message: str
+    error: str | None = None
+
+
+class RemoteDeviceAddRequest(BaseModel):
+    """添加远程设备请求."""
+
+    base_url: str
+    device_id: str
+
+    @field_validator("base_url")
+    @classmethod
+    def validate_base_url(cls, v: str) -> str:
+        v = v.strip().rstrip("/")
+        if not v.startswith(("http://", "https://")):
+            raise ValueError("base_url must start with http:// or https://")
+        return v
+
+    @field_validator("device_id")
+    @classmethod
+    def validate_device_id(cls, v: str) -> str:
+        v = v.strip()
+        if not v:
+            raise ValueError("device_id cannot be empty")
+        if len(v) > 100:
+            raise ValueError("device_id too long (max 100 characters)")
+        return v
+
+
+class RemoteDeviceAddResponse(BaseModel):
+    """添加远程设备响应."""
+
+    success: bool
+    message: str
+    serial: str | None = None
+    error: str | None = None
+
+
+class RemoteDeviceRemoveRequest(BaseModel):
+    """移除远程设备请求."""
+
+    serial: str
+
+
+class RemoteDeviceRemoveResponse(BaseModel):
+    """移除远程设备响应."""
+
+    success: bool
+    message: str
+    error: str | None = None
+
+
+class ReinitAllAgentsResponse(BaseModel):
+    """批量重新初始化 agent 响应."""
+
+    success: bool
+    total: int
+    succeeded: list[str]
+    failed: dict[str, str]
+    message: str
+
+
+# History Models
+
+
+class MessageRecordResponse(BaseModel):
+    """对话消息响应."""
+
+    role: str  # "user" | "assistant"
+    content: str
+    timestamp: str
+    thinking: str | None = None
+    action: dict | None = None
+    step: int | None = None
+
+
+class HistoryRecordResponse(BaseModel):
+    """历史记录条目响应."""
+
+    id: str
+    task_text: str
+    final_message: str
+    success: bool
+    steps: int
+    start_time: str
+    end_time: str | None
+    duration_ms: int
+    source: str
+    source_detail: str
+    error_message: str | None
+    messages: list[MessageRecordResponse] = []
+
+
+class HistoryListResponse(BaseModel):
+    """历史记录列表响应."""
+
+    records: list[HistoryRecordResponse]
+    total: int
+    limit: int
+    offset: int
+
+
+# Scheduled Task Models
+
+
+class ScheduledTaskCreate(BaseModel):
+    """创建定时任务请求."""
+
+    name: str
+    workflow_uuid: str
+    device_serialno: str
+    cron_expression: str
+    enabled: bool = True
+
+    @field_validator("name")
+    @classmethod
+    def validate_name(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("name cannot be empty")
+        return v.strip()
+
+    @field_validator("cron_expression")
+    @classmethod
+    def validate_cron(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("cron_expression cannot be empty")
+        parts = v.strip().split()
+        if len(parts) != 5:
+            raise ValueError(
+                "cron_expression must have 5 fields (minute hour day month weekday)"
+            )
+        return v.strip()
+
+
+class ScheduledTaskUpdate(BaseModel):
+    """更新定时任务请求."""
+
+    name: str | None = None
+    workflow_uuid: str | None = None
+    device_serialno: str | None = None
+    cron_expression: str | None = None
+    enabled: bool | None = None
+
+    @field_validator("cron_expression")
+    @classmethod
+    def validate_cron(cls, v: str | None) -> str | None:
+        if v is None:
+            return v
+        if not v.strip():
+            raise ValueError("cron_expression cannot be empty")
+        parts = v.strip().split()
+        if len(parts) != 5:
+            raise ValueError(
+                "cron_expression must have 5 fields (minute hour day month weekday)"
+            )
+        return v.strip()
+
+
+class ScheduledTaskResponse(BaseModel):
+    """定时任务响应."""
+
+    id: str
+    name: str
+    workflow_uuid: str
+    device_serialno: str
+    cron_expression: str
+    enabled: bool
+    created_at: str
+    updated_at: str
+    last_run_time: str | None
+    last_run_success: bool | None
+    last_run_message: str | None
+    next_run_time: str | None = None
+
+
+class ScheduledTaskListResponse(BaseModel):
+    """定时任务列表响应."""
+
+    tasks: list[ScheduledTaskResponse]

AutoGLM_GUI/scrcpy_stream.py

@@ -5,6 +5,7 @@ import os
 import socket
 import subprocess
 import sys
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from asyncio.subprocess import Process as AsyncProcess
@@ -23,6 +24,74 @@ from AutoGLM_GUI.scrcpy_protocol import (
 )
 
 
+async def is_port_available(port: int, host: str = "127.0.0.1") -> bool:
+    """Test if TCP port is available for binding.
+
+    Args:
+        port: TCP port number
+        host: Host address to test
+
+    Returns:
+        True if port can be bound (available), False otherwise
+    """
+    sock = None
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.setblocking(False)
+        sock.bind((host, port))
+        logger.debug(f"Port {port} is available for binding")
+        return True
+    except OSError as e:
+        # Handle cross-platform errno for "Address already in use"
+        # macOS: 48, Linux: 98, Windows: 10048
+        logger.debug(f"Port {port} is occupied: {e}")
+        return False
+    finally:
+        if sock:
+            sock.close()
+
+
+async def wait_for_port_release(
+    port: int,
+    timeout: float = 5.0,
+    poll_interval: float = 0.2,
+    host: str = "127.0.0.1",
+) -> bool:
+    """Wait for TCP port to become available with polling.
+
+    Args:
+        port: TCP port to wait for
+        timeout: Maximum wait time in seconds (default: 5.0)
+        poll_interval: Check interval in seconds (default: 0.2)
+        host: Host address
+
+    Returns:
+        True if port became available, False if timeout
+    """
+    start_time = time.time()
+    attempt = 0
+
+    while time.time() - start_time < timeout:
+        attempt += 1
+        if await is_port_available(port, host):
+            elapsed = time.time() - start_time
+            logger.info(
+                f"Port {port} became available after {elapsed:.2f}s ({attempt} checks)"
+            )
+            return True
+
+        # Log progress every second for debugging
+        if attempt % 5 == 0:  # Every 1 second (5 * 0.2s)
+            elapsed = time.time() - start_time
+            logger.debug(f"Still waiting for port {port}... ({elapsed:.1f}s elapsed)")
+
+        await asyncio.sleep(poll_interval)
+
+    logger.warning(f"Port {port} did not release within {timeout}s timeout")
+    return False
+
+
 @dataclass
 class ScrcpyServerOptions:
     max_size: int
@@ -159,29 +228,44 @@ class ScrcpyStreamer:
             raise RuntimeError(f"Failed to start scrcpy server: {e}") from e
 
     async def _cleanup_existing_server(self) -> None:
-        """Kill existing scrcpy server processes on device."""
+        """Kill existing scrcpy server processes and wait for port release."""
         cmd_base = ["adb"]
         if self.device_id:
             cmd_base.extend(["-s", self.device_id])
 
         # Method 1: Try pkill
+        logger.debug("Killing scrcpy processes via pkill...")
         cmd = cmd_base + ["shell", "pkill", "-9", "-f", "app_process.*scrcpy"]
         await run_cmd_silently(cmd)
 
         # Method 2: Find and kill by PID (more reliable)
+        logger.debug("Killing scrcpy processes via PID...")
         cmd = cmd_base + [
             "shell",
             "ps -ef | grep 'app_process.*scrcpy' | grep -v grep | awk '{print $2}' | xargs kill -9",
         ]
         await run_cmd_silently(cmd)
 
-        # Method 3: Remove port forward if exists
+        # Method 3: Remove port forward
+        logger.debug(f"Removing ADB port forward on port {self.port}...")
         cmd_remove_forward = cmd_base + ["forward", "--remove", f"tcp:{self.port}"]
         await run_cmd_silently(cmd_remove_forward)
 
-        # Wait for resources to be released
-        logger.debug("Waiting for cleanup to complete...")
-        await asyncio.sleep(2)
+        # Wait for port to be truly available (instead of fixed sleep)
+        logger.info(f"Waiting for port {self.port} to be released...")
+        port_released = await wait_for_port_release(
+            self.port,
+            timeout=5.0,  # Max 5 seconds (vs old fixed 2s)
+            poll_interval=0.2,  # Check every 200ms
+        )
+
+        if not port_released:
+            logger.warning(
+                f"Port {self.port} still occupied after cleanup. "
+                "Will attempt to start anyway (may fail)."
+            )
+        else:
+            logger.info(f"Port {self.port} successfully released and ready")
 
     async def _push_server(self) -> None:
         """Push scrcpy-server to device."""
@@ -221,9 +305,9 @@ class ScrcpyStreamer:
         )
 
     async def _start_server(self) -> None:
-        """Start scrcpy server on device with retry on address conflict."""
+        """Start scrcpy server on device with intelligent retry."""
         max_retries = 3
-        retry_delay = 2
+        retry_delay = 1.0  # Reduced from 2s (cleanup handles waiting now)
 
         options = self._build_server_options()
 
@@ -275,43 +359,77 @@ class ScrcpyStreamer:
                         error_msg = stderr.decode() if stderr else stdout.decode()
 
             if error_msg is not None:
+                # Detailed error classification
                 if "Address already in use" in error_msg:
+                    logger.error(
+                        f"Port {self.port} conflict detected (attempt {attempt + 1}/{max_retries}). "
+                        f"Error: {error_msg[:200]}"
+                    )
                     if attempt < max_retries - 1:
                         logger.warning(
-                            f"Address in use, retrying in {retry_delay}s (attempt {attempt + 1}/{max_retries})..."
+                            f"Retrying with aggressive cleanup in {retry_delay}s..."
                         )
                         await self._cleanup_existing_server()
                         await asyncio.sleep(retry_delay)
                         continue
+                    # Specific error for port conflicts
                     raise RuntimeError(
-                        f"scrcpy server failed after {max_retries} attempts: {error_msg}"
+                        f"Port {self.port} persistently occupied after {max_retries} attempts. "
+                        "Please check if another scrcpy instance is running."
                     )
-                raise RuntimeError(f"scrcpy server exited immediately: {error_msg}")
+                else:
+                    # Non-port errors fail immediately (no retry)
+                    logger.error(f"Scrcpy server startup failed: {error_msg[:200]}")
+                    raise RuntimeError(f"Scrcpy server failed to start: {error_msg}")
 
+            logger.info("Scrcpy server started successfully")
             return
 
         raise RuntimeError("Failed to start scrcpy server after maximum retries")
 
     async def _connect_socket(self) -> None:
         """Connect to scrcpy TCP socket."""
-        self.tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        self.tcp_socket.settimeout(5)
+        # Retry connection with exponential backoff (max ~6 seconds total)
+        max_attempts = 10
+        retry_delay = 0.3
 
-        try:
-            self.tcp_socket.setsockopt(
-                socket.SOL_SOCKET, socket.SO_RCVBUF, 2 * 1024 * 1024
-            )
-            logger.debug("Set socket receive buffer to 2MB")
-        except OSError as e:
-            logger.warning(f"Failed to set socket buffer size: {e}")
+        for attempt in range(max_attempts):
+            # Create a fresh socket for each attempt to avoid "Invalid argument" error
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(5)
+
+            try:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 2 * 1024 * 1024)
+            except OSError as e:
+                logger.debug(f"Failed to set socket buffer size: {e}")
 
-        for _ in range(5):
             try:
-                self.tcp_socket.connect(("localhost", self.port))
-                self.tcp_socket.settimeout(None)
+                sock.connect(("localhost", self.port))
+                sock.settimeout(None)
+                self.tcp_socket = sock  # Only assign on success
+                logger.debug(f"Connected to scrcpy server on attempt {attempt + 1}")
                 return
-            except (ConnectionRefusedError, OSError):
-                await asyncio.sleep(0.5)
+            except (ConnectionRefusedError, OSError) as e:
+                # Close the failed socket
+                try:
+                    sock.close()
+                except Exception:
+                    pass
+
+                if attempt < max_attempts - 1:
+                    logger.debug(
+                        f"Connection attempt {attempt + 1}/{max_attempts} failed: {e}. "
+                        f"Retrying in {retry_delay}s..."
+                    )
+                    await asyncio.sleep(retry_delay)
+                    # Gradually increase delay for later attempts
+                    if attempt >= 3:
+                        retry_delay = 0.5
+                else:
+                    logger.error(
+                        f"Failed to connect after {max_attempts} attempts. "
+                        f"Last error: {e}"
+                    )
 
         raise ConnectionError("Failed to connect to scrcpy server")