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

AutoGLM_GUI/devices/remote_device.py

@@ -0,0 +1,177 @@
+"""Remote Device implementation using HTTP.
+
+This module provides a RemoteDevice that connects to a Device Agent
+via HTTP, allowing remote control of devices.
+"""
+
+import httpx
+
+from AutoGLM_GUI.device_protocol import (
+    DeviceInfo,
+    DeviceManagerProtocol,
+    DeviceProtocol,
+    Screenshot,
+)
+
+
+class RemoteDevice(DeviceProtocol):
+    """
+    Remote device implementation using HTTP.
+
+    Connects to a Device Agent server that handles actual device operations.
+    The server decides the implementation (ADB, Accessibility, Mock, etc.).
+
+    Example:
+        >>> device = RemoteDevice("phone_001", "http://localhost:8001")
+        >>> screenshot = device.get_screenshot()
+        >>> device.tap(100, 200)
+    """
+
+    def __init__(self, device_id: str, base_url: str, timeout: float = 30.0):
+        self._device_id = device_id
+        self._base_url = base_url.rstrip("/")
+        self._client = httpx.Client(timeout=timeout)
+
+    @property
+    def device_id(self) -> str:
+        return self._device_id
+
+    def _post(self, endpoint: str, json: dict | None = None) -> dict:
+        """POST request helper."""
+        url = f"{self._base_url}/device/{self._device_id}{endpoint}"
+        resp = self._client.post(url, json=json or {})
+        resp.raise_for_status()
+        return resp.json()
+
+    def _get(self, endpoint: str) -> dict:
+        """GET request helper."""
+        url = f"{self._base_url}/device/{self._device_id}{endpoint}"
+        resp = self._client.get(url)
+        resp.raise_for_status()
+        return resp.json()
+
+    def get_screenshot(self, timeout: int = 10) -> Screenshot:
+        data = self._post("/screenshot", {"timeout": timeout})
+        return Screenshot(
+            base64_data=data["base64_data"],
+            width=data["width"],
+            height=data["height"],
+            is_sensitive=data.get("is_sensitive", False),
+        )
+
+    def tap(self, x: int, y: int, delay: float | None = None) -> None:
+        self._post("/tap", {"x": x, "y": y, "delay": delay})
+
+    def double_tap(self, x: int, y: int, delay: float | None = None) -> None:
+        self._post("/double_tap", {"x": x, "y": y, "delay": delay})
+
+    def long_press(
+        self, x: int, y: int, duration_ms: int = 3000, delay: float | None = None
+    ) -> None:
+        self._post(
+            "/long_press", {"x": x, "y": y, "duration_ms": duration_ms, "delay": delay}
+        )
+
+    def swipe(
+        self,
+        start_x: int,
+        start_y: int,
+        end_x: int,
+        end_y: int,
+        duration_ms: int | None = None,
+        delay: float | None = None,
+    ) -> None:
+        self._post(
+            "/swipe",
+            {
+                "start_x": start_x,
+                "start_y": start_y,
+                "end_x": end_x,
+                "end_y": end_y,
+                "duration_ms": duration_ms,
+                "delay": delay,
+            },
+        )
+
+    def type_text(self, text: str) -> None:
+        self._post("/type_text", {"text": text})
+
+    def clear_text(self) -> None:
+        self._post("/clear_text")
+
+    def back(self, delay: float | None = None) -> None:
+        self._post("/back", {"delay": delay})
+
+    def home(self, delay: float | None = None) -> None:
+        self._post("/home", {"delay": delay})
+
+    def launch_app(self, app_name: str, delay: float | None = None) -> bool:
+        data = self._post("/launch_app", {"app_name": app_name, "delay": delay})
+        return data.get("success", True)
+
+    def get_current_app(self) -> str:
+        data = self._get("/current_app")
+        return data["app_name"]
+
+    def detect_and_set_adb_keyboard(self) -> str:
+        data = self._post("/detect_keyboard")
+        return data.get("original_ime", "")
+
+    def restore_keyboard(self, ime: str) -> None:
+        self._post("/restore_keyboard", {"ime": ime})
+
+    def close(self) -> None:
+        """Close the HTTP client."""
+        self._client.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+
+class RemoteDeviceManager(DeviceManagerProtocol):
+    """
+    Remote device manager using HTTP.
+
+    Manages connections to a Device Agent server.
+    """
+
+    def __init__(self, base_url: str, timeout: float = 30.0):
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._client = httpx.Client(timeout=timeout)
+        self._devices: dict[str, RemoteDevice] = {}
+
+    def list_devices(self) -> list[DeviceInfo]:
+        resp = self._client.get(f"{self._base_url}/devices")
+        resp.raise_for_status()
+        return [DeviceInfo(**d) for d in resp.json()]
+
+    def get_device(self, device_id: str) -> RemoteDevice:
+        if device_id not in self._devices:
+            self._devices[device_id] = RemoteDevice(
+                device_id, self._base_url, self._timeout
+            )
+        return self._devices[device_id]
+
+    def connect(self, address: str, timeout: int = 10) -> tuple[bool, str]:
+        resp = self._client.post(
+            f"{self._base_url}/connect", json={"address": address, "timeout": timeout}
+        )
+        data = resp.json()
+        return data.get("success", False), data.get("message", "")
+
+    def disconnect(self, device_id: str) -> tuple[bool, str]:
+        self._devices.pop(device_id, None)
+        resp = self._client.post(
+            f"{self._base_url}/disconnect", json={"device_id": device_id}
+        )
+        data = resp.json()
+        return data.get("success", True), data.get("message", "Disconnected")
+
+    def close(self) -> None:
+        for device in self._devices.values():
+            device.close()
+        self._client.close()

AutoGLM_GUI/exceptions.py

@@ -79,9 +79,9 @@ class AgentInitializationError(Exception):
     How to fix:
         1. Check configuration:
             >>> from AutoGLM_GUI.config_manager import config_manager
-            >>> config = config_manager.get_effective_config()
-            >>> print(f"base_url: {config.base_url}")
-            >>> print(f"model_name: {config.model_name}")
+            >>> effective_config = config_manager.get_effective_config()
+            >>> print(f"base_url: {effective_config.base_url}")
+            >>> print(f"model_name: {effective_config.model_name}")
 
         2. Set configuration:
             >>> via API: POST /api/config {"base_url": "...", "model_name": "...", "api_key": "..."}

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/i18n.py

@@ -0,0 +1,81 @@
+"""Internationalization (i18n) module for Phone Agent UI messages."""
+
+# Chinese messages
+MESSAGES_ZH = {
+    "thinking": "思考过程",
+    "action": "执行动作",
+    "task_completed": "任务完成",
+    "done": "完成",
+    "starting_task": "开始执行任务",
+    "final_result": "最终结果",
+    "task_result": "任务结果",
+    "confirmation_required": "需要确认",
+    "continue_prompt": "是否继续？(y/n)",
+    "manual_operation_required": "需要人工操作",
+    "manual_operation_hint": "请手动完成操作...",
+    "press_enter_when_done": "完成后按回车继续",
+    "connection_failed": "连接失败",
+    "connection_successful": "连接成功",
+    "step": "步骤",
+    "task": "任务",
+    "result": "结果",
+    "performance_metrics": "性能指标",
+    "time_to_first_token": "首 Token 延迟 (TTFT)",
+    "time_to_thinking_end": "思考完成延迟",
+    "total_inference_time": "总推理时间",
+}
+
+# English messages
+MESSAGES_EN = {
+    "thinking": "Thinking",
+    "action": "Action",
+    "task_completed": "Task Completed",
+    "done": "Done",
+    "starting_task": "Starting task",
+    "final_result": "Final Result",
+    "task_result": "Task Result",
+    "confirmation_required": "Confirmation Required",
+    "continue_prompt": "Continue? (y/n)",
+    "manual_operation_required": "Manual Operation Required",
+    "manual_operation_hint": "Please complete the operation manually...",
+    "press_enter_when_done": "Press Enter when done",
+    "connection_failed": "Connection Failed",
+    "connection_successful": "Connection Successful",
+    "step": "Step",
+    "task": "Task",
+    "result": "Result",
+    "performance_metrics": "Performance Metrics",
+    "time_to_first_token": "Time to First Token (TTFT)",
+    "time_to_thinking_end": "Time to Thinking End",
+    "total_inference_time": "Total Inference Time",
+}
+
+
+def get_messages(lang: str = "cn") -> dict:
+    """
+    Get UI messages dictionary by language.
+
+    Args:
+        lang: Language code, 'cn' for Chinese, 'en' for English.
+
+    Returns:
+        Dictionary of UI messages.
+    """
+    if lang == "en":
+        return MESSAGES_EN
+    return MESSAGES_ZH
+
+
+def get_message(key: str, lang: str = "cn") -> str:
+    """
+    Get a single UI message by key and language.
+
+    Args:
+        key: Message key.
+        lang: Language code, 'cn' for Chinese, 'en' for English.
+
+    Returns:
+        Message string.
+    """
+    messages = get_messages(lang)
+    return messages.get(key, key)

AutoGLM_GUI/metrics.py

@@ -87,14 +87,12 @@ class AutoGLMMetricsCollector(Collector):
         busy_count = 0
 
         with manager._manager_lock:
-            # Get snapshots (shallow copy to minimize lock time)
+            # Get snapshot (shallow copy to minimize lock time)
             metadata_snapshot = dict(manager._metadata)
-            states_snapshot = dict(manager._states)
 
-        # Iterate over _states (not _metadata) to capture failed agents
-        for device_id, state in states_snapshot.items():
-            # Get metadata if exists (will be None for failed initialization)
-            metadata = metadata_snapshot.get(device_id)
+        # Iterate over _metadata (state is stored in AgentMetadata.state)
+        for device_id, metadata in metadata_snapshot.items():
+            state = metadata.state
 
             # Get serial from DeviceManager
             with device_manager._devices_lock:
@@ -113,20 +111,15 @@ class AutoGLMMetricsCollector(Collector):
             if state == AgentState.BUSY:
                 busy_count += 1
 
-            # Timestamps (0 if metadata doesn't exist, e.g., failed init)
-            if metadata:
-                last_used_gauge.add_metric(
-                    [device_id, serial],
-                    metadata.last_used,
-                )
-                created_gauge.add_metric(
-                    [device_id, serial],
-                    metadata.created_at,
-                )
-            else:
-                # Failed initialization: report 0 timestamps
-                last_used_gauge.add_metric([device_id, serial], 0)
-                created_gauge.add_metric([device_id, serial], 0)
+            # Timestamps from metadata
+            last_used_gauge.add_metric(
+                [device_id, serial],
+                metadata.last_used,
+            )
+            created_gauge.add_metric(
+                [device_id, serial],
+                metadata.created_at,
+            )
 
         metrics.extend([agents_gauge, last_used_gauge, created_gauge])
 

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",
+]