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

AutoGLM_GUI/config_manager.py

@@ -23,6 +23,10 @@ from pydantic import BaseModel, field_validator
 from AutoGLM_GUI.logger import logger
 
 
+LAYERED_MAX_TURNS_DEFAULT = 50
+LAYERED_MAX_TURNS_MIN = 1
+
+
 # ==================== 配置源枚举 ====================
 
 
@@ -53,12 +57,14 @@ class ConfigModel(BaseModel):
     api_key: str = "EMPTY"
 
     # Agent 类型配置
-    agent_type: str = "glm"  # Agent type (e.g., "glm", "mai")
+    agent_type: str = "glm"  # Agent type (e.g., "glm", "mai", "glm-sync")
     agent_config_params: dict | None = None  # Agent-specific configuration
 
     # Agent 执行配置
     default_max_steps: int = 100  # 单次任务最大执行步数
 
+    layered_max_turns: int = LAYERED_MAX_TURNS_DEFAULT
+
     # 决策模型配置（用于分层代理）
     decision_base_url: str | None = None
     decision_model_name: str | None = None
@@ -110,6 +116,13 @@ class ConfigModel(BaseModel):
             raise ValueError("decision_model_name cannot be empty string")
         return v.strip() if v else v
 
+    @field_validator("layered_max_turns")
+    @classmethod
+    def validate_layered_max_turns(cls, v: int) -> int:
+        if v < LAYERED_MAX_TURNS_MIN:
+            raise ValueError(f"layered_max_turns must be >= {LAYERED_MAX_TURNS_MIN}")
+        return v
+
 
 # ==================== 配置层数据类 ====================
 
@@ -126,6 +139,7 @@ class ConfigLayer:
     agent_config_params: Optional[dict] = None
     # Agent 执行配置
     default_max_steps: Optional[int] = None
+    layered_max_turns: Optional[int] = None
     # 决策模型配置
     decision_base_url: Optional[str] = None
     decision_model_name: Optional[str] = None
@@ -160,6 +174,7 @@ class ConfigLayer:
                 "agent_type": self.agent_type,
                 "agent_config_params": self.agent_config_params,
                 "default_max_steps": self.default_max_steps,
+                "layered_max_turns": self.layered_max_turns,
                 "decision_base_url": self.decision_base_url,
                 "decision_model_name": self.decision_model_name,
                 "decision_api_key": self.decision_api_key,
@@ -225,6 +240,7 @@ class UnifiedConfigManager:
             agent_type="glm",
             agent_config_params=None,
             default_max_steps=100,
+            layered_max_turns=LAYERED_MAX_TURNS_DEFAULT,
             decision_base_url=None,
             decision_model_name=None,
             decision_api_key=None,
@@ -248,6 +264,7 @@ class UnifiedConfigManager:
         base_url: Optional[str] = None,
         model_name: Optional[str] = None,
         api_key: Optional[str] = None,
+        layered_max_turns: Optional[int] = None,
     ) -> None:
         """
         设置 CLI 参数配置（最高优先级）.
@@ -256,11 +273,13 @@ class UnifiedConfigManager:
             base_url: 从 --base-url 获取的值
             model_name: 从 --model 获取的值
             api_key: 从 --apikey 获取的值
+            layered_max_turns: 从 --layered-max-turns 获取的值
         """
         self._cli_layer = ConfigLayer(
             base_url=base_url,
             model_name=model_name,
             api_key=api_key,
+            layered_max_turns=layered_max_turns,
             source=ConfigSource.CLI,
         )
         self._effective_config = None  # 清除缓存
@@ -277,6 +296,7 @@ class UnifiedConfigManager:
         - AUTOGLM_DECISION_BASE_URL
         - AUTOGLM_DECISION_MODEL_NAME
         - AUTOGLM_DECISION_API_KEY
+        - AUTOGLM_LAYERED_MAX_TURNS
         """
         base_url = os.getenv("AUTOGLM_BASE_URL")
         model_name = os.getenv("AUTOGLM_MODEL_NAME")
@@ -287,10 +307,19 @@ class UnifiedConfigManager:
         decision_model_name = os.getenv("AUTOGLM_DECISION_MODEL_NAME")
         decision_api_key = os.getenv("AUTOGLM_DECISION_API_KEY")
 
+        layered_max_turns_str = os.getenv("AUTOGLM_LAYERED_MAX_TURNS")
+        layered_max_turns = None
+        if layered_max_turns_str:
+            try:
+                layered_max_turns = int(layered_max_turns_str)
+            except ValueError:
+                logger.warning("AUTOGLM_LAYERED_MAX_TURNS must be an integer")
+
         self._env_layer = ConfigLayer(
             base_url=base_url if base_url else None,
             model_name=model_name if model_name else None,
             api_key=api_key if api_key else None,
+            layered_max_turns=layered_max_turns,
             decision_base_url=decision_base_url if decision_base_url else None,
             decision_model_name=decision_model_name if decision_model_name else None,
             decision_api_key=decision_api_key if decision_api_key else None,
@@ -352,6 +381,7 @@ class UnifiedConfigManager:
                 ),  # 默认 'glm'，兼容旧配置
                 agent_config_params=config_data.get("agent_config_params"),
                 default_max_steps=config_data.get("default_max_steps"),
+                layered_max_turns=config_data.get("layered_max_turns"),
                 decision_base_url=config_data.get("decision_base_url"),
                 decision_model_name=config_data.get("decision_model_name"),
                 decision_api_key=config_data.get("decision_api_key"),
@@ -385,6 +415,7 @@ class UnifiedConfigManager:
         agent_type: Optional[str] = None,
         agent_config_params: Optional[dict] = None,
         default_max_steps: Optional[int] = None,
+        layered_max_turns: Optional[int] = None,
         decision_base_url: Optional[str] = None,
         decision_model_name: Optional[str] = None,
         decision_api_key: Optional[str] = None,
@@ -400,6 +431,7 @@ class UnifiedConfigManager:
             agent_type: Agent 类型（可选，如 "glm", "mai"）
             agent_config_params: Agent 特定配置参数（可选）
             default_max_steps: 默认最大执行步数（可选）
+            layered_max_turns: 分层代理最大轮数（可选）
             decision_base_url: 决策模型 Base URL（可选）
             decision_model_name: 决策模型名称（可选）
             decision_api_key: 决策模型 API Key（可选）
@@ -426,6 +458,8 @@ class UnifiedConfigManager:
                 new_config["agent_config_params"] = agent_config_params
             if default_max_steps is not None:
                 new_config["default_max_steps"] = default_max_steps
+            if layered_max_turns is not None:
+                new_config["layered_max_turns"] = layered_max_turns
 
             # 决策模型配置
             if decision_base_url is not None:
@@ -447,6 +481,7 @@ class UnifiedConfigManager:
                         "agent_type",
                         "agent_config_params",
                         "default_max_steps",
+                        "layered_max_turns",
                         "decision_base_url",
                         "decision_model_name",
                         "decision_api_key",
@@ -540,6 +575,7 @@ class UnifiedConfigManager:
             "decision_base_url",
             "decision_model_name",
             "decision_api_key",
+            "layered_max_turns",
         ]
 
         for key in config_keys:
@@ -708,6 +744,7 @@ class UnifiedConfigManager:
             "decision_base_url": config.decision_base_url,
             "decision_model_name": config.decision_model_name,
             "decision_api_key": config.decision_api_key,
+            "layered_max_turns": config.layered_max_turns,
         }
 
 

AutoGLM_GUI/device_manager.py

@@ -89,6 +89,7 @@ class ManagedDevice:
 
     # Device metadata
     model: Optional[str] = None
+    display_name: Optional[str] = None  # User-defined custom name
 
     # Device-level state
     state: DeviceState = DeviceState.ONLINE
@@ -144,6 +145,7 @@ class ManagedDevice:
             "id": self.primary_device_id,
             "serial": self.serial,
             "model": self.model or "Unknown",
+            "display_name": self.display_name,
             "status": self.status,
             "connection_type": self.connection_type.value,
             "state": self.state.value,
@@ -178,24 +180,20 @@ def _create_managed_device(
         for d in device_infos
     ]
 
-    # Extract model (prefer device with model info)
     model = None
     for device_info in device_infos:
         if device_info.model:
             model = device_info.model
             break
 
-    # Create managed device
     managed = ManagedDevice(
         serial=serial,
         connections=connections,
         model=model,
     )
 
-    # Select primary connection
     managed.select_primary_connection()
 
-    # Set state
     managed.state = (
         DeviceState.ONLINE if managed.status == "device" else DeviceState.OFFLINE
     )
@@ -249,6 +247,10 @@ class DeviceManager:
         self._remote_devices: dict[str, "DeviceProtocol"] = {}
         self._remote_device_configs: dict[str, dict] = {}
 
+        from AutoGLM_GUI.device_metadata_manager import DeviceMetadataManager
+
+        self._metadata_manager = DeviceMetadataManager.get_instance()
+
     @classmethod
     def get_instance(cls, adb_path: str = "adb") -> DeviceManager:
         """Get singleton instance (thread-safe)."""
@@ -449,6 +451,11 @@ class DeviceManager:
             for serial in added_serials:
                 device_infos = grouped_by_serial[serial]
                 managed = _create_managed_device(serial, device_infos)
+
+                display_name = self._metadata_manager.get_display_name(serial)
+                if display_name:
+                    managed.display_name = display_name
+
                 self._devices[serial] = managed
 
                 # Update reverse mapping
@@ -977,3 +984,20 @@ class DeviceManager:
                 from AutoGLM_GUI.devices.adb_device import ADBDevice
 
                 return ADBDevice(managed.primary_device_id)
+
+    def set_device_display_name(self, serial: str, display_name: Optional[str]) -> None:
+        """Set custom display name for device."""
+        self._metadata_manager.set_display_name(serial, display_name)
+
+        with self._devices_lock:
+            if serial in self._devices:
+                self._devices[serial].display_name = display_name
+                logger.debug(f"Updated display name in memory for {serial}")
+
+    def get_device_display_name(self, serial: str) -> Optional[str]:
+        """Get custom display name for device."""
+        with self._devices_lock:
+            if serial in self._devices and self._devices[serial].display_name:
+                return self._devices[serial].display_name
+
+        return self._metadata_manager.get_display_name(serial)

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/models/history.py

@@ -2,10 +2,49 @@
 
 from dataclasses import dataclass, field
 from datetime import datetime
-from typing import Literal
+from typing import Any, Literal
 from uuid import uuid4
 
 
+@dataclass
+class MessageRecord:
+    """对话中的单条消息记录."""
+
+    role: Literal["user", "assistant"]
+    content: str
+    timestamp: datetime = field(default_factory=datetime.now)
+
+    # assistant 消息特有字段
+    thinking: str | None = None
+    action: dict[str, Any] | None = None
+    step: int | None = None
+
+    def to_dict(self) -> dict:
+        """转换为可序列化的字典."""
+        return {
+            "role": self.role,
+            "content": self.content,
+            "timestamp": self.timestamp.isoformat(),
+            "thinking": self.thinking,
+            "action": self.action,
+            "step": self.step,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "MessageRecord":
+        """从字典创建实例."""
+        return cls(
+            role=data.get("role", "user"),
+            content=data.get("content", ""),
+            timestamp=datetime.fromisoformat(data["timestamp"])
+            if data.get("timestamp")
+            else datetime.now(),
+            thinking=data.get("thinking"),
+            action=data.get("action"),
+            step=data.get("step"),
+        )
+
+
 @dataclass
 class ConversationRecord:
     """单条对话记录."""
@@ -30,6 +69,9 @@ class ConversationRecord:
     # 错误信息
     error_message: str | None = None
 
+    # 完整对话消息列表
+    messages: list[MessageRecord] = field(default_factory=list)
+
     def to_dict(self) -> dict:
         """转换为可序列化的字典."""
         return {
@@ -44,6 +86,7 @@ class ConversationRecord:
             "source": self.source,
             "source_detail": self.source_detail,
             "error_message": self.error_message,
+            "messages": [m.to_dict() for m in self.messages],
         }
 
     @classmethod
@@ -65,6 +108,7 @@ class ConversationRecord:
             source=data.get("source", "chat"),
             source_detail=data.get("source_detail", ""),
             error_message=data.get("error_message"),
+            messages=[MessageRecord.from_dict(m) for m in data.get("messages", [])],
         )