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

AutoGLM_GUI/device_metadata_manager.py

@@ -0,0 +1,174 @@
+"""Device metadata persistence manager."""
+
+from __future__ import annotations
+
+import json
+import threading
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from AutoGLM_GUI.logger import logger
+
+DISPLAY_NAME_MAX_LENGTH = 100
+
+
+@dataclass
+class DeviceMetadata:
+    """Device user-defined metadata."""
+
+    serial: str
+    display_name: Optional[str] = None
+    last_updated: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict:
+        """Convert to serializable dict."""
+        return {
+            "serial": self.serial,
+            "display_name": self.display_name,
+            "last_updated": self.last_updated.isoformat(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "DeviceMetadata":
+        """Create instance from dict."""
+        last_updated_str = data.get("last_updated")
+        last_updated = (
+            datetime.fromisoformat(last_updated_str)
+            if last_updated_str
+            else datetime.now()
+        )
+        return cls(
+            serial=data.get("serial", ""),
+            display_name=data.get("display_name"),
+            last_updated=last_updated,
+        )
+
+
+class DeviceMetadataManager:
+    """
+    Singleton manager for device metadata persistence.
+
+    Stores user-defined device names and other metadata.
+    Design: Lazy persistence - only save when metadata changes.
+    """
+
+    _instance: Optional[DeviceMetadataManager] = None
+    _lock = threading.Lock()
+
+    def __init__(self, storage_dir: Optional[Path] = None):
+        """Private constructor. Use get_instance() instead."""
+        if storage_dir is None:
+            storage_dir = Path.home() / ".config" / "autoglm" / "devices"
+
+        self.storage_dir = storage_dir
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+        self.metadata_file = self.storage_dir / "metadata.json"
+
+        self._metadata: dict[str, DeviceMetadata] = {}
+        self._data_lock = threading.RLock()
+
+        self._load_metadata()
+
+    @classmethod
+    def get_instance(cls, storage_dir: Optional[Path] = None) -> DeviceMetadataManager:
+        """Get singleton instance (thread-safe)."""
+        if cls._instance is None:
+            with cls._lock:
+                if cls._instance is None:
+                    cls._instance = cls(storage_dir=storage_dir)
+                    logger.info("DeviceMetadataManager singleton created")
+        return cls._instance
+
+    def _load_metadata(self) -> None:
+        """Load metadata from disk."""
+        if not self.metadata_file.exists():
+            logger.debug("No metadata file found, starting fresh")
+            return
+
+        try:
+            with open(self.metadata_file, encoding="utf-8") as f:
+                data = json.load(f)
+
+            with self._data_lock:
+                self._metadata = {
+                    serial: DeviceMetadata.from_dict(meta_dict)
+                    for serial, meta_dict in data.items()
+                }
+
+            logger.info(f"Loaded metadata for {len(self._metadata)} device(s)")
+        except Exception as e:
+            logger.error(f"Failed to load device metadata: {e}")
+            backup_path = self.metadata_file.with_suffix(".json.bak")
+            if self.metadata_file.exists():
+                try:
+                    self.metadata_file.rename(backup_path)
+                    logger.warning(
+                        f"Corrupted metadata file moved to {backup_path.name}"
+                    )
+                except Exception as backup_error:
+                    logger.error(f"Failed to create backup: {backup_error}")
+            self._metadata = {}
+
+    def _save_metadata(self) -> None:
+        """Save metadata to disk atomically."""
+        temp_path = self.metadata_file.with_suffix(".json.tmp")
+        try:
+            with self._data_lock:
+                data = {
+                    serial: meta.to_dict() for serial, meta in self._metadata.items()
+                }
+
+            with open(temp_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+
+            temp_path.replace(self.metadata_file)
+
+            logger.debug(f"Saved metadata for {len(self._metadata)} device(s)")
+        except Exception as e:
+            logger.error(f"Failed to save device metadata: {e}")
+            if temp_path.exists():
+                temp_path.unlink()
+            raise
+
+    def get_display_name(self, serial: str) -> Optional[str]:
+        """Get device display name by serial."""
+        with self._data_lock:
+            metadata = self._metadata.get(serial)
+            return metadata.display_name if metadata else None
+
+    def set_display_name(self, serial: str, display_name: Optional[str]) -> None:
+        """Set device display name. Empty string will be treated as None."""
+        normalized_name = display_name.strip() if display_name else None
+        normalized_name = normalized_name if normalized_name else None
+
+        if normalized_name and len(normalized_name) > DISPLAY_NAME_MAX_LENGTH:
+            raise ValueError(
+                f"Display name too long: {len(normalized_name)} > {DISPLAY_NAME_MAX_LENGTH}"
+            )
+
+        with self._data_lock:
+            if serial not in self._metadata:
+                self._metadata[serial] = DeviceMetadata(serial=serial)
+
+            current_name = self._metadata[serial].display_name
+            if current_name == normalized_name:
+                return
+
+            self._metadata[serial].display_name = normalized_name
+            self._metadata[serial].last_updated = datetime.now()
+
+            self._save_metadata()
+
+        logger.info(f"Updated display name for device {serial}: {normalized_name}")
+
+    def get_metadata(self, serial: str) -> Optional[DeviceMetadata]:
+        """Get full device metadata."""
+        with self._data_lock:
+            return self._metadata.get(serial)
+
+    def list_all_metadata(self) -> dict[str, DeviceMetadata]:
+        """List all stored device metadata."""
+        with self._data_lock:
+            return dict(self._metadata)

AutoGLM_GUI/devices/mock_device.py

@@ -66,17 +66,24 @@ class MockDevice(DeviceProtocol):
 
     # === Input Operations ===
     def tap(self, x: int, y: int, delay: float | None = None) -> None:
-        """Handle tap action through state machine."""
+        """Handle tap action through state machine.
+
+        Passes pixel coordinates directly to state machine (no conversion).
+        The click_region in scenario.yaml is in pixel coordinates.
+        """
+        # Pass pixel coordinates directly to state machine (no conversion)
         self._state_machine.handle_tap(x, y)
 
     def double_tap(self, x: int, y: int, delay: float | None = None) -> None:
         """Handle double tap (treated as single tap)."""
+        # Pass pixel coordinates directly to state machine (no conversion)
         self._state_machine.handle_tap(x, y)
 
     def long_press(
         self, x: int, y: int, duration_ms: int = 3000, delay: float | None = None
     ) -> None:
         """Handle long press (treated as tap for testing)."""
+        # Pass pixel coordinates directly to state machine (no conversion)
         self._state_machine.handle_tap(x, y)
 
     def swipe(

AutoGLM_GUI/phone_agent_manager.py

@@ -2,14 +2,15 @@
 
 from __future__ import annotations
 
+import asyncio
 import threading
 import time
 from contextlib import contextmanager
 from dataclasses import dataclass
 from enum import Enum
-from typing import Callable, Optional
+from typing import Awaitable, Callable, Optional
 
-from AutoGLM_GUI.agents.protocols import BaseAgent
+from AutoGLM_GUI.agents.protocols import AsyncAgent, BaseAgent
 from AutoGLM_GUI.config import AgentConfig, ModelConfig
 from AutoGLM_GUI.exceptions import (
     AgentInitializationError,
@@ -96,10 +97,13 @@ class PhoneAgentManager:
         self._streaming_contexts: dict[str, StreamingAgentContext] = {}
         self._streaming_contexts_lock = threading.Lock()
 
-        self._abort_events: dict[str, threading.Event | Callable[[], None]] = {}
+        self._abort_events: dict[
+            str, threading.Event | Callable[[], None] | Callable[[], Awaitable[None]]
+        ] = {}
 
         # Agent storage (transition from global state to instance state)
-        self._agents: dict[str, BaseAgent] = {}
+        # Agents can be either AsyncAgent or BaseAgent depending on agent_type
+        self._agents: dict[str, AsyncAgent | BaseAgent] = {}
         self._agent_configs: dict[str, tuple[ModelConfig, AgentConfig]] = {}
 
     @classmethod
@@ -124,7 +128,7 @@ class PhoneAgentManager:
         takeover_callback: Optional[Callable] = None,
         confirmation_callback: Optional[Callable] = None,
         force: bool = False,
-    ) -> "BaseAgent":
+    ) -> AsyncAgent | BaseAgent:
         from AutoGLM_GUI.agents import create_agent
 
         with self._manager_lock:
@@ -152,12 +156,19 @@ class PhoneAgentManager:
                 from AutoGLM_GUI.device_manager import DeviceManager
 
                 device_manager = DeviceManager.get_instance()
+                # Use agent_config.device_id (actual device ID) instead of device_id (storage key)
+                # to get device protocol, as device_id may be a composite key like "device_id:context"
+                actual_device_id = agent_config.device_id
+                if not actual_device_id:
+                    raise AgentInitializationError(
+                        "agent_config.device_id is required but was None"
+                    )
                 try:
-                    device = device_manager.get_device_protocol(device_id)
+                    device = device_manager.get_device_protocol(actual_device_id)
                 except ValueError:
                     # Ensure cold starts refresh device cache before failing.
                     device_manager.force_refresh()
-                    device = device_manager.get_device_protocol(device_id)
+                    device = device_manager.get_device_protocol(actual_device_id)
 
                 agent = create_agent(
                     agent_type=agent_type,
@@ -190,14 +201,18 @@ class PhoneAgentManager:
                     f"Failed to initialize agent: {str(e)}"
                 ) from e
 
-    def _auto_initialize_agent(self, device_id: str) -> None:
+    def _auto_initialize_agent(
+        self, agent_key: str, actual_device_id: str, agent_type: str | None = None
+    ) -> None:
         """
         使用全局配置自动初始化 agent（内部方法，需在 manager_lock 内调用）.
 
         使用 factory 模式创建 agent，避免直接依赖 phone_agent.PhoneAgent。
 
         Args:
-            device_id: 设备标识符
+            agent_key: Agent 存储键（可能是 device_id 或 device_id:context）
+            actual_device_id: 实际设备标识符（用于设备操作）
+            agent_type: 可选的 agent 类型覆盖
 
         Raises:
             AgentInitializationError: 如果配置不完整或初始化失败
@@ -208,7 +223,9 @@ class PhoneAgentManager:
         from AutoGLM_GUI.config_manager import config_manager
         from AutoGLM_GUI.types import AgentSpecificConfig
 
-        logger.info(f"Auto-initializing agent for device {device_id}...")
+        logger.info(
+            f"Auto-initializing agent for key {agent_key} (device: {actual_device_id})..."
+        )
 
         # 热重载配置
         config_manager.load_file_config()
@@ -218,7 +235,7 @@ class PhoneAgentManager:
 
         if not effective_config.base_url:
             raise AgentInitializationError(
-                f"Cannot auto-initialize agent for {device_id}: base_url not configured. "
+                f"Cannot auto-initialize agent for {agent_key}: base_url not configured. "
                 f"Please configure base_url via /api/config or call /api/init explicitly."
             )
 
@@ -229,28 +246,54 @@ class PhoneAgentManager:
             model_name=effective_config.model_name,
         )
 
-        agent_config = AgentConfig(device_id=device_id)
+        # 使用实际的 device_id 创建 AgentConfig
+        agent_config = AgentConfig(device_id=actual_device_id)
 
         # 调用 factory 方法创建 agent（避免直接依赖 phone_agent）
         agent_specific_config = cast(
             AgentSpecificConfig, effective_config.agent_config_params or {}
         )
+        # 使用提供的 agent_type 或从配置中获取
+        effective_agent_type = agent_type or effective_config.agent_type
         self.initialize_agent_with_factory(
-            device_id=device_id,
-            agent_type=effective_config.agent_type,
+            device_id=agent_key,
+            agent_type=effective_agent_type,
             model_config=model_config,
             agent_config=agent_config,
             agent_specific_config=agent_specific_config,
         )
-        logger.info(f"Agent auto-initialized for device {device_id}")
+        logger.info(f"Agent auto-initialized for key {agent_key}")
+
+    def get_agent(self, device_id: str) -> AsyncAgent | BaseAgent:
+        """Get agent using default context (backward compatible)."""
+        return self.get_agent_with_context(device_id, context="default")
+
+    def get_agent_with_context(
+        self,
+        device_id: str,
+        context: str = "default",
+        agent_type: str | None = None,
+    ) -> AsyncAgent | BaseAgent:
+        """Get or create agent for specific context.
 
-    def get_agent(self, device_id: str) -> BaseAgent:
+        Args:
+            device_id: Device identifier
+            context: Context identifier (e.g., "chat", "default")
+            agent_type: Optional agent type override
+
+        Returns:
+            Agent instance for this device+context combination
+        """
         with self._manager_lock:
-            if device_id not in self._agents:
-                self._auto_initialize_agent(device_id)
-            return self._agents[device_id]
+            # Use composite key for context isolation (except for default)
+            agent_key = device_id if context == "default" else f"{device_id}:{context}"
 
-    def get_agent_safe(self, device_id: str) -> Optional[BaseAgent]:
+            if agent_key not in self._agents:
+                self._auto_initialize_agent(agent_key, device_id, agent_type=agent_type)
+
+            return self._agents[agent_key]
+
+    def get_agent_safe(self, device_id: str) -> AsyncAgent | BaseAgent | None:
         with self._manager_lock:
             return self._agents.get(device_id)
 
@@ -363,7 +406,7 @@ class PhoneAgentManager:
                 # Double-check locking pattern for thread safety
                 with self._manager_lock:
                     if not self.is_initialized(device_id):
-                        self._auto_initialize_agent(device_id)
+                        self._auto_initialize_agent(device_id, device_id)
             else:
                 raise AgentNotInitializedError(
                     f"Agent not initialized for device {device_id}. "
@@ -512,18 +555,62 @@ class PhoneAgentManager:
             return self._metadata.get(device_id)
 
     def register_abort_handler(
-        self, device_id: str, abort_handler: threading.Event | Callable[[], None]
+        self,
+        device_id: str,
+        abort_handler: threading.Event
+        | Callable[[], None]
+        | Callable[[], Awaitable[None]],
     ) -> None:
+        """注册取消处理器 (支持同步和异步处理器)。
+
+        Args:
+            device_id: 设备标识符
+            abort_handler: 取消处理器 (Event / 同步函数 / 异步函数)
+        """
         with self._streaming_contexts_lock:
             self._abort_events[device_id] = abort_handler
 
     def unregister_abort_handler(self, device_id: str) -> None:
+        """注销取消处理器。
+
+        Args:
+            device_id: 设备标识符
+        """
         with self._streaming_contexts_lock:
             self._abort_events.pop(device_id, None)
 
-    def abort_streaming_chat(self, device_id: str) -> bool:
+    async def abort_streaming_chat_async(self, device_id: str) -> bool:
+        """异步中止流式对话 (支持 AsyncAgent)。
+
+        Args:
+            device_id: 设备标识符
+
+        Returns:
+            bool: True 表示发送了中止信号，False 表示没有活跃会话
         """
-        中止正在进行的流式对话.
+        with self._streaming_contexts_lock:
+            if device_id not in self._abort_events:
+                logger.warning(f"No active streaming chat for device {device_id}")
+                return False
+
+            logger.info(f"Aborting async streaming chat for device {device_id}")
+            handler = self._abort_events[device_id]
+
+        # 执行取消 (根据类型选择方式)
+        if isinstance(handler, threading.Event):
+            handler.set()
+        elif asyncio.iscoroutinefunction(handler):
+            await handler()
+        elif callable(handler):
+            handler()
+        else:
+            logger.warning(f"Unknown abort handler type: {type(handler)}")
+            return False
+
+        return True
+
+    def abort_streaming_chat(self, device_id: str) -> bool:
+        """同步中止流式对话 (向后兼容)。
 
         Args:
             device_id: 设备标识符
@@ -532,16 +619,42 @@ class PhoneAgentManager:
             bool: True 表示发送了中止信号，False 表示没有活跃会话
         """
         with self._streaming_contexts_lock:
-            if device_id in self._abort_events:
-                logger.info(f"Aborting streaming chat for device {device_id}")
-                handler = self._abort_events[device_id]
-                if isinstance(handler, threading.Event):
-                    handler.set()
-                elif callable(handler):
-                    handler()
+            if device_id not in self._abort_events:
+                logger.warning(f"No active streaming chat for device {device_id}")
+                return False
+
+            logger.info(f"Aborting streaming chat for device {device_id}")
+            handler = self._abort_events[device_id]
+
+            if isinstance(handler, threading.Event):
+                handler.set()
+                return True
+            elif asyncio.iscoroutinefunction(handler):
+                logger.warning(
+                    f"Detected async handler for {device_id}, "
+                    f"but called sync abort. Use abort_streaming_chat_async instead."
+                )
+                # 尝试在当前线程的 event loop 中运行
+                try:
+                    loop = asyncio.get_event_loop()
+                    if loop.is_running():
+                        # 不能在运行中的 loop 中调用 run_until_complete
+                        # 创建一个 task
+                        asyncio.create_task(self.abort_streaming_chat_async(device_id))
+                        return True
+                    else:
+                        loop.run_until_complete(
+                            self.abort_streaming_chat_async(device_id)
+                        )
+                        return True
+                except RuntimeError:
+                    logger.error("Cannot abort async agent from sync context")
+                    return False
+            elif callable(handler):
+                handler()
                 return True
             else:
-                logger.warning(f"No active streaming chat for device {device_id}")
+                logger.warning(f"Unknown abort handler type: {type(handler)}")
                 return False
 
     def is_streaming_active(self, device_id: str) -> bool:

AutoGLM_GUI/scheduler_manager.py

@@ -231,7 +231,7 @@ class SchedulerManager:
             task_success = False
 
             while agent.step_count < agent.agent_config.max_steps:
-                step_result = agent.step(workflow["text"] if is_first else None)
+                step_result = agent.step(workflow["text"] if is_first else None)  # type: ignore[misc]
                 is_first = False
 
                 # 收集每个 step 的消息
@@ -240,15 +240,15 @@ class SchedulerManager:
                         role="assistant",
                         content="",
                         timestamp=datetime.now(),
-                        thinking=step_result.thinking,
-                        action=step_result.action,
+                        thinking=step_result.thinking,  # type: ignore[union-attr]
+                        action=step_result.action,  # type: ignore[union-attr]
                         step=agent.step_count,
                     )
                 )
 
-                if step_result.finished:
-                    result_message = step_result.message or "Task completed"
-                    task_success = step_result.success
+                if step_result.finished:  # type: ignore[union-attr]
+                    result_message = step_result.message or "Task completed"  # type: ignore[union-attr]
+                    task_success = step_result.success  # type: ignore[union-attr]
                     break
             else:
                 result_message = "Max steps reached"

AutoGLM_GUI/schemas.py

@@ -4,6 +4,8 @@ import re
 
 from pydantic import BaseModel, field_validator
 
+from AutoGLM_GUI.device_metadata_manager import DISPLAY_NAME_MAX_LENGTH
+
 
 class InitRequest(BaseModel):
     device_id: str  # Device ID (required)
@@ -274,6 +276,7 @@ class DeviceResponse(BaseModel):
     connection_type: str
     state: str
     is_available_only: bool
+    display_name: str | None = None
     agent: AgentStatusResponse | None = None
 
 
@@ -296,6 +299,9 @@ class ConfigResponse(BaseModel):
     # Agent 执行配置
     default_max_steps: int = 100  # 单次任务最大执行步数
 
+    # 分层代理配置
+    layered_max_turns: int = 50  # 分层代理模式的最大轮次
+
     # 决策模型配置（用于分层代理）
     decision_base_url: str | None = None
     decision_model_name: str | None = None
@@ -318,6 +324,9 @@ class ConfigSaveRequest(BaseModel):
     # Agent 执行配置
     default_max_steps: int | None = None  # 单次任务最大执行步数
 
+    # 分层代理配置
+    layered_max_turns: int | None = None  # 分层代理模式的最大轮次
+
     # 决策模型配置（用于分层代理）
     decision_base_url: str | None = None
     decision_model_name: str | None = None
@@ -335,6 +344,15 @@ class ConfigSaveRequest(BaseModel):
             raise ValueError("default_max_steps must be <= 1000")
         return v
 
+    @field_validator("layered_max_turns")
+    @classmethod
+    def validate_layered_max_turns(cls, v: int | None) -> int | None:
+        if v is None:
+            return v
+        if v < 1:
+            raise ValueError("layered_max_turns must be >= 1")
+        return v
+
     @field_validator("base_url")
     @classmethod
     def validate_base_url(cls, v: str) -> str:
@@ -816,3 +834,74 @@ class ScheduledTaskListResponse(BaseModel):
     """定时任务列表响应."""
 
     tasks: list[ScheduledTaskResponse]
+
+
+class DeleteResponse(BaseModel):
+    success: bool
+    message: str
+
+
+class ResetResponse(BaseModel):
+    success: bool
+    message: str
+    device_id: str
+
+
+class ConfigSaveResponse(BaseModel):
+    success: bool
+    message: str
+    warnings: list[str] | None = None
+    destroyed_agents: int
+
+
+class InitResponse(BaseModel):
+    success: bool
+    message: str
+    device_id: str
+    agent_type: str
+
+
+class StreamResetResponse(BaseModel):
+    success: bool
+    message: str
+    device_id: str | None = None
+
+
+class EnableDisableResponse(BaseModel):
+    success: bool
+    message: str
+    task_id: str
+    enabled: bool
+
+
+# Device Name Models
+
+
+class DeviceNameUpdateRequest(BaseModel):
+    """更新设备显示名称请求."""
+
+    display_name: str | None
+
+    @field_validator("display_name")
+    @classmethod
+    def validate_display_name(cls, v: str | None) -> str | None:
+        """验证 display_name."""
+        if v is None:
+            return v
+        v = v.strip()
+        if not v:
+            return None
+        if len(v) > DISPLAY_NAME_MAX_LENGTH:
+            raise ValueError(
+                f"display_name too long (max {DISPLAY_NAME_MAX_LENGTH} characters)"
+            )
+        return v
+
+
+class DeviceNameResponse(BaseModel):
+    """设备显示名称响应."""
+
+    success: bool
+    serial: str
+    display_name: str | None = None
+    error: str | None = None

AutoGLM_GUI/scrcpy_stream.py

@@ -9,6 +9,7 @@ import time
 from dataclasses import dataclass
 from pathlib import Path
 from asyncio.subprocess import Process as AsyncProcess
+from typing import AsyncGenerator
 
 from AutoGLM_GUI.adb_plus import check_device_available
 from AutoGLM_GUI.logger import logger
@@ -535,7 +536,7 @@ class ScrcpyStreamer:
             pts=pts,
         )
 
-    async def iter_packets(self):
+    async def iter_packets(self) -> AsyncGenerator[ScrcpyMediaStreamPacket, None]:
         """Yield packets continuously from the scrcpy stream."""
         while True:
             yield await self.read_media_packet()

AutoGLM_GUI/static/assets/{about-CfwX1Cmc.js → about-DTrVqEQH.js}

@@ -1 +1 @@
-import{j as o}from"./index-CTHbFvKl.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};
+import{j as o}from"./index-BzP-Te33.js";function t(){return o.jsx("div",{className:"p-2",children:o.jsx("h3",{children:"About"})})}export{t as component};