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

AutoGLM_GUI/devices/mock_device.py

@@ -8,6 +8,8 @@ from typing import TYPE_CHECKING
 
 from AutoGLM_GUI.device_protocol import (
     DeviceInfo,
+    DeviceManagerProtocol,
+    DeviceProtocol,
     Screenshot,
 )
 
@@ -15,7 +17,7 @@ if TYPE_CHECKING:
     from tests.integration.state_machine import StateMachine
 
 
-class MockDevice:
+class MockDevice(DeviceProtocol):
     """
     Mock device implementation driven by a state machine.
 
@@ -125,7 +127,7 @@ class MockDevice:
         pass
 
 
-class MockDeviceManager:
+class MockDeviceManager(DeviceManagerProtocol):
     """
     Mock device manager for testing.
 

AutoGLM_GUI/devices/remote_device.py

@@ -6,10 +6,15 @@ via HTTP, allowing remote control of devices.
 
 import httpx
 
-from AutoGLM_GUI.device_protocol import DeviceInfo, Screenshot
+from AutoGLM_GUI.device_protocol import (
+    DeviceInfo,
+    DeviceManagerProtocol,
+    DeviceProtocol,
+    Screenshot,
+)
 
 
-class RemoteDevice:
+class RemoteDevice(DeviceProtocol):
     """
     Remote device implementation using HTTP.
 
@@ -126,7 +131,7 @@ class RemoteDevice:
         self.close()
 
 
-class RemoteDeviceManager:
+class RemoteDeviceManager(DeviceManagerProtocol):
     """
     Remote device manager using HTTP.
 

AutoGLM_GUI/history_manager.py

@@ -0,0 +1,164 @@
+"""Conversation history manager with JSON file persistence."""
+
+import hashlib
+import json
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.models.history import ConversationRecord, DeviceHistory
+
+# ADB serialno 合法字符：字母数字、下划线、破折号、冒号、点
+# USB: ABC123DEF456
+# WiFi: 192.168.1.100:5555
+# mDNS: adb-243a09b7._adb-tls-connect._tcp
+_SERIALNO_PATTERN = re.compile(r"^[a-zA-Z0-9_\-:\.]+$")
+
+
+class HistoryManager:
+    """对话历史管理器（单例模式）."""
+
+    _instance: Optional["HistoryManager"] = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if hasattr(self, "_initialized"):
+            return
+        self._initialized = True
+        self._history_dir = Path.home() / ".config" / "autoglm" / "history"
+        self._file_cache: dict[str, DeviceHistory] = {}
+        self._file_mtime: dict[str, float] = {}
+
+    def _sanitize_serialno(self, serialno: str) -> str:
+        """将 serialno 转换为安全的文件名.
+
+        如果 serialno 包含合法字符，直接使用；否则使用 SHA1 哈希作为文件名。
+        这样可以防止路径遍历攻击，同时保证功能正常。
+        """
+        if not serialno:
+            return hashlib.sha1(b"empty").hexdigest()
+
+        # 检查是否包含路径遍历字符或不合法字符
+        if ".." in serialno or not _SERIALNO_PATTERN.match(serialno):
+            # 使用 SHA1 哈希作为安全的文件名
+            hashed = hashlib.sha1(serialno.encode("utf-8")).hexdigest()
+            logger.warning(
+                f"Unsafe serialno detected, using hash: {serialno!r} -> {hashed}"
+            )
+            return hashed
+
+        return serialno
+
+    def _get_history_path(self, serialno: str) -> Path:
+        """获取历史记录文件路径（带路径遍历防护）."""
+        safe_name = self._sanitize_serialno(serialno)
+        path = (self._history_dir / f"{safe_name}.json").resolve()
+
+        # 防御深度：确保解析后的路径仍在 history_dir 内
+        history_dir_resolved = self._history_dir.resolve()
+        if not path.is_relative_to(history_dir_resolved):
+            # 理论上不应该到这里，但作为最后防线
+            hashed = hashlib.sha1(serialno.encode("utf-8")).hexdigest()
+            logger.error(f"Path escape detected for {serialno!r}, using hash: {hashed}")
+            path = history_dir_resolved / f"{hashed}.json"
+
+        return path
+
+    def _load_history(self, serialno: str) -> DeviceHistory:
+        path = self._get_history_path(serialno)
+
+        if not path.exists():
+            return DeviceHistory(serialno=serialno)
+
+        current_mtime = path.stat().st_mtime
+        if (
+            serialno in self._file_mtime
+            and self._file_mtime[serialno] == current_mtime
+            and serialno in self._file_cache
+        ):
+            return self._file_cache[serialno]
+
+        try:
+            with open(path, encoding="utf-8") as f:
+                data = json.load(f)
+            history = DeviceHistory.from_dict(data)
+            self._file_cache[serialno] = history
+            self._file_mtime[serialno] = current_mtime
+            logger.debug(f"Loaded {len(history.records)} records for {serialno}")
+            return history
+        except (json.JSONDecodeError, FileNotFoundError) as e:
+            logger.warning(f"Failed to load history for {serialno}: {e}")
+            return DeviceHistory(serialno=serialno)
+
+    def _save_history(self, history: DeviceHistory) -> bool:
+        self._history_dir.mkdir(parents=True, exist_ok=True)
+        path = self._get_history_path(history.serialno)
+        temp_path = path.with_suffix(".tmp")
+
+        try:
+            history.last_updated = datetime.now()
+            with open(temp_path, "w", encoding="utf-8") as f:
+                json.dump(history.to_dict(), f, indent=2, ensure_ascii=False)
+            temp_path.replace(path)
+
+            self._file_cache[history.serialno] = history
+            self._file_mtime[history.serialno] = path.stat().st_mtime
+            logger.debug(f"Saved {len(history.records)} records for {history.serialno}")
+            return True
+        except Exception as e:
+            logger.error(f"Failed to save history for {history.serialno}: {e}")
+            if temp_path.exists():
+                temp_path.unlink()
+            return False
+
+    def add_record(self, serialno: str, record: ConversationRecord) -> None:
+        history = self._load_history(serialno)
+        history.records.insert(0, record)
+        self._save_history(history)
+        logger.info(f"Added history record for {serialno}: {record.id}")
+
+    def list_records(
+        self, serialno: str, limit: int = 50, offset: int = 0
+    ) -> list[ConversationRecord]:
+        history = self._load_history(serialno)
+        return history.records[offset : offset + limit]
+
+    def get_record(self, serialno: str, record_id: str) -> Optional[ConversationRecord]:
+        history = self._load_history(serialno)
+        return next((r for r in history.records if r.id == record_id), None)
+
+    def delete_record(self, serialno: str, record_id: str) -> bool:
+        history = self._load_history(serialno)
+        original_len = len(history.records)
+        history.records = [r for r in history.records if r.id != record_id]
+
+        if len(history.records) < original_len:
+            self._save_history(history)
+            logger.info(f"Deleted history record {record_id} for {serialno}")
+            return True
+
+        logger.warning(f"Record {record_id} not found for {serialno}")
+        return False
+
+    def clear_device_history(self, serialno: str) -> bool:
+        path = self._get_history_path(serialno)
+        if path.exists():
+            path.unlink()
+            self._file_cache.pop(serialno, None)
+            self._file_mtime.pop(serialno, None)
+            logger.info(f"Cleared all history for {serialno}")
+            return True
+        return False
+
+    def get_total_count(self, serialno: str) -> int:
+        history = self._load_history(serialno)
+        return len(history.records)
+
+
+history_manager = HistoryManager()

AutoGLM_GUI/model/__init__.py

@@ -0,0 +1,5 @@
+"""Model utilities for building messages."""
+
+from .message_builder import MessageBuilder
+
+__all__ = ["MessageBuilder"]

AutoGLM_GUI/model/message_builder.py

@@ -0,0 +1,69 @@
+"""Builder for constructing multimodal chat messages."""
+
+from typing import Any
+
+
+class MessageBuilder:
+    @staticmethod
+    def create_system_message(content: str) -> dict[str, Any]:
+        return {"role": "system", "content": content}
+
+    @staticmethod
+    def create_user_message(
+        text: str, image_base64: str | None = None
+    ) -> dict[str, Any]:
+        if image_base64 is None:
+            return {"role": "user", "content": text}
+
+        return {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": text},
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{image_base64}"},
+                },
+            ],
+        }
+
+    @staticmethod
+    def create_multi_image_user_message(
+        text: str, image_base64_list: list[str]
+    ) -> dict[str, Any]:
+        if not image_base64_list:
+            return {"role": "user", "content": text}
+
+        content_parts: list[dict[str, Any]] = [{"type": "text", "text": text}]
+
+        for image_base64 in image_base64_list:
+            content_parts.append(
+                {
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{image_base64}"},
+                }
+            )
+
+        return {"role": "user", "content": content_parts}
+
+    @staticmethod
+    def create_assistant_message(content: str) -> dict[str, Any]:
+        return {"role": "assistant", "content": content}
+
+    @staticmethod
+    def remove_images_from_message(message: dict[str, Any]) -> dict[str, Any]:
+        if message["role"] != "user":
+            return message
+
+        content = message["content"]
+        if isinstance(content, str):
+            return message
+
+        text_parts = [part for part in content if part["type"] == "text"]
+        if len(text_parts) == 1:
+            return {"role": "user", "content": text_parts[0]["text"]}
+
+        return {"role": "user", "content": text_parts}
+
+    @staticmethod
+    def build_screen_info(current_app: str) -> str:
+        return f"** Screen Info **\n\nCurrent App: {current_app}"

AutoGLM_GUI/model/types.py

@@ -0,0 +1,24 @@
+"""Type definitions for model interactions."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class ModelResponse:
+    """Response from the vision-language model.
+
+    Attributes:
+        thinking: The model's reasoning process (from <think> tag)
+        action: The action to execute (from <answer> tag)
+        raw_content: Full response text from the model
+        time_to_first_token: Time until first token received (seconds)
+        time_to_thinking_end: Time until thinking phase completed (seconds)
+        total_time: Total inference time (seconds)
+    """
+
+    thinking: str
+    action: str
+    raw_content: str
+    time_to_first_token: float | None = None
+    time_to_thinking_end: float | None = None
+    total_time: float | None = None

AutoGLM_GUI/models/__init__.py

@@ -0,0 +1,10 @@
+"""Data models for AutoGLM-GUI."""
+
+from AutoGLM_GUI.models.history import ConversationRecord, DeviceHistory
+from AutoGLM_GUI.models.scheduled_task import ScheduledTask
+
+__all__ = [
+    "ConversationRecord",
+    "DeviceHistory",
+    "ScheduledTask",
+]

AutoGLM_GUI/models/history.py

@@ -0,0 +1,140 @@
+"""Conversation history data models."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+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:
+    """单条对话记录."""
+
+    id: str = field(default_factory=lambda: str(uuid4()))
+
+    # 任务信息
+    task_text: str = ""  # 用户输入的任务
+    final_message: str = ""  # 最终结果消息
+
+    # 执行信息
+    success: bool = False
+    steps: int = 0
+    start_time: datetime = field(default_factory=datetime.now)
+    end_time: datetime | None = None
+    duration_ms: int = 0  # 执行时长（毫秒）
+
+    # 来源标记
+    source: Literal["chat", "layered", "scheduled"] = "chat"
+    source_detail: str = ""  # 定时任务名称 or session_id
+
+    # 错误信息
+    error_message: str | None = None
+
+    # 完整对话消息列表
+    messages: list[MessageRecord] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        """转换为可序列化的字典."""
+        return {
+            "id": self.id,
+            "task_text": self.task_text,
+            "final_message": self.final_message,
+            "success": self.success,
+            "steps": self.steps,
+            "start_time": self.start_time.isoformat(),
+            "end_time": self.end_time.isoformat() if self.end_time else None,
+            "duration_ms": self.duration_ms,
+            "source": self.source,
+            "source_detail": self.source_detail,
+            "error_message": self.error_message,
+            "messages": [m.to_dict() for m in self.messages],
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ConversationRecord":
+        """从字典创建实例."""
+        return cls(
+            id=data.get("id", str(uuid4())),
+            task_text=data.get("task_text", ""),
+            final_message=data.get("final_message", ""),
+            success=data.get("success", False),
+            steps=data.get("steps", 0),
+            start_time=datetime.fromisoformat(data["start_time"])
+            if data.get("start_time")
+            else datetime.now(),
+            end_time=datetime.fromisoformat(data["end_time"])
+            if data.get("end_time")
+            else None,
+            duration_ms=data.get("duration_ms", 0),
+            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", [])],
+        )
+
+
+@dataclass
+class DeviceHistory:
+    """设备对话历史（一个设备一个文件）."""
+
+    serialno: str
+    records: list[ConversationRecord] = field(default_factory=list)
+    last_updated: datetime = field(default_factory=datetime.now)
+
+    def to_dict(self) -> dict:
+        """转换为可序列化的字典."""
+        return {
+            "serialno": self.serialno,
+            "records": [r.to_dict() for r in self.records],
+            "last_updated": self.last_updated.isoformat(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "DeviceHistory":
+        """从字典创建实例."""
+        return cls(
+            serialno=data.get("serialno", ""),
+            records=[ConversationRecord.from_dict(r) for r in data.get("records", [])],
+            last_updated=datetime.fromisoformat(data["last_updated"])
+            if data.get("last_updated")
+            else datetime.now(),
+        )

AutoGLM_GUI/models/scheduled_task.py

@@ -0,0 +1,71 @@
+"""Scheduled task data models."""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from uuid import uuid4
+
+
+@dataclass
+class ScheduledTask:
+    """定时任务定义."""
+
+    id: str = field(default_factory=lambda: str(uuid4()))
+
+    # 基础信息
+    name: str = ""  # 任务名称
+    workflow_uuid: str = ""  # 关联的 Workflow UUID
+    device_serialno: str = ""  # 绑定的设备 serialno
+
+    # 调度配置
+    cron_expression: str = ""  # Cron 表达式 (如 "0 8 * * *")
+    enabled: bool = True  # 是否启用
+
+    # 元数据
+    created_at: datetime = field(default_factory=datetime.now)
+    updated_at: datetime = field(default_factory=datetime.now)
+
+    # 最近执行信息（只记录最后一次）
+    last_run_time: datetime | None = None
+    last_run_success: bool | None = None
+    last_run_message: str | None = None
+
+    def to_dict(self) -> dict:
+        """转换为可序列化的字典."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "workflow_uuid": self.workflow_uuid,
+            "device_serialno": self.device_serialno,
+            "cron_expression": self.cron_expression,
+            "enabled": self.enabled,
+            "created_at": self.created_at.isoformat(),
+            "updated_at": self.updated_at.isoformat(),
+            "last_run_time": self.last_run_time.isoformat()
+            if self.last_run_time
+            else None,
+            "last_run_success": self.last_run_success,
+            "last_run_message": self.last_run_message,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ScheduledTask":
+        """从字典创建实例."""
+        return cls(
+            id=data.get("id", str(uuid4())),
+            name=data.get("name", ""),
+            workflow_uuid=data.get("workflow_uuid", ""),
+            device_serialno=data.get("device_serialno", ""),
+            cron_expression=data.get("cron_expression", ""),
+            enabled=data.get("enabled", True),
+            created_at=datetime.fromisoformat(data["created_at"])
+            if data.get("created_at")
+            else datetime.now(),
+            updated_at=datetime.fromisoformat(data["updated_at"])
+            if data.get("updated_at")
+            else datetime.now(),
+            last_run_time=datetime.fromisoformat(data["last_run_time"])
+            if data.get("last_run_time")
+            else None,
+            last_run_success=data.get("last_run_success"),
+            last_run_message=data.get("last_run_message"),
+        )

AutoGLM_GUI/parsers/__init__.py

@@ -0,0 +1,22 @@
+"""Action parsers for different agent types.
+
+This module provides parser implementations for converting model outputs
+into standardized action dictionaries that can be executed by ActionHandler.
+
+Each agent type has its own parser implementation:
+- GLMParser: For GLM-based agents (enhanced AST parsing)
+- PhoneAgentParser: For standard PhoneAgent (basic AST parsing)
+- MAIParser: For MAI agent (XML + JSON parsing)
+"""
+
+from .base import ActionParser
+from AutoGLM_GUI.agents.glm.parser import GLMParser
+from AutoGLM_GUI.agents.mai.parser import MAIParser
+from .phone_parser import PhoneAgentParser
+
+__all__ = [
+    "ActionParser",
+    "GLMParser",
+    "MAIParser",
+    "PhoneAgentParser",
+]

AutoGLM_GUI/parsers/base.py

@@ -0,0 +1,50 @@
+"""Base protocol for action parsers.
+
+This module defines the interface that all action parsers must implement.
+"""
+
+from typing import Any, Protocol
+
+
+class ActionParser(Protocol):
+    """Protocol for parsing model outputs into action dictionaries.
+
+    All parser implementations must provide:
+    1. parse() method to convert raw model output into standardized action dict
+    2. coordinate_scale property to specify the coordinate normalization range
+
+    The standardized action dictionary format:
+    {
+        "_metadata": "do" | "finish",
+        "action": "Tap" | "Swipe" | "Type" | ...,  # Only when _metadata="do"
+        "coordinate": [x, y],  # Normalized to 0-1000 range
+        "text": "...",  # For Type action
+        ... # Other action-specific parameters
+    }
+    """
+
+    def parse(self, raw_response: str) -> dict[str, Any]:
+        """Parse raw model output into standardized action dictionary.
+
+        Args:
+            raw_response: Raw text output from the model.
+
+        Returns:
+            Standardized action dictionary with:
+            - "_metadata": "do" or "finish"
+            - "action": Action type (Tap, Swipe, etc.) when _metadata="do"
+            - Additional parameters based on action type
+
+        Raises:
+            ValueError: If the response cannot be parsed.
+        """
+        ...
+
+    @property
+    def coordinate_scale(self) -> int:
+        """Get the coordinate normalization scale used by this parser.
+
+        Returns:
+            999 for MAI parser, 1000 for GLM/PhoneAgent parsers.
+        """
+        ...

AutoGLM_GUI/parsers/phone_parser.py

@@ -0,0 +1,58 @@
+"""PhoneAgent parser using standard AST parsing."""
+
+import ast
+from typing import Any
+
+
+class PhoneAgentParser:
+    """Parse PhoneAgent function-call style outputs using ast.parse.
+
+    Handles the same format as GLM but with simpler AST-based parsing.
+    Includes special handling for Type action to avoid parsing issues.
+    Coordinate scale: 0-1000
+    """
+
+    @property
+    def coordinate_scale(self) -> int:
+        return 1000
+
+    def parse(self, raw_response: str) -> dict[str, Any]:
+        response = raw_response.strip()
+
+        if response.startswith('do(action="Type"') or response.startswith(
+            'do(action="Type_Name"'
+        ):
+            text = response.split("text=", 1)[1][1:-2]
+            action = {"_metadata": "do", "action": "Type", "text": text}
+            return action
+        elif response.startswith("do"):
+            try:
+                response = response.replace("\n", "\\n")
+                response = response.replace("\r", "\\r")
+                response = response.replace("\t", "\\t")
+
+                tree = ast.parse(response, mode="eval")
+                if not isinstance(tree.body, ast.Call):
+                    raise ValueError("Expected a function call")
+
+                call = tree.body
+                action = {"_metadata": "do"}
+                for keyword in call.keywords:
+                    key = keyword.arg
+                    if key is None:
+                        raise ValueError("Keyword argument name missing")
+                    value = ast.literal_eval(keyword.value)
+                    action[key] = value
+
+                return action
+            except (SyntaxError, ValueError) as e:
+                raise ValueError(f"Failed to parse do() action: {e}") from e
+
+        elif response.startswith("finish"):
+            action = {
+                "_metadata": "finish",
+                "message": response.replace("finish(message=", "")[1:-2],
+            }
+            return action
+        else:
+            raise ValueError(f"Failed to parse action: {response}")