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

AutoGLM_GUI/prompts/__init__.py

@@ -0,0 +1,32 @@
+"""Prompt templates for agents."""
+
+from pathlib import Path
+
+# Import MAI prompt from new location
+from AutoGLM_GUI.agents.mai.prompts import MAI_MOBILE_SYSTEM_PROMPT
+
+# Import from parent-level prompts.py file
+# When prompts/ directory exists, Python prioritizes it over prompts.py
+# We need to import from sibling prompts.py file
+parent_dir = Path(__file__).parent.parent
+prompts_file = parent_dir / "prompts.py"
+
+if prompts_file.exists():
+    import importlib.util
+
+    spec = importlib.util.spec_from_file_location("_prompts_legacy", prompts_file)
+    if spec and spec.loader:
+        _prompts_legacy = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(_prompts_legacy)
+        MCP_SYSTEM_PROMPT_ZH = getattr(_prompts_legacy, "MCP_SYSTEM_PROMPT_ZH", "")
+        MCP_SYSTEM_PROMPT_EN = getattr(_prompts_legacy, "MCP_SYSTEM_PROMPT_EN", "")
+else:
+    # Fallback if file doesn't exist
+    MCP_SYSTEM_PROMPT_ZH = ""
+    MCP_SYSTEM_PROMPT_EN = ""
+
+__all__ = [
+    "MAI_MOBILE_SYSTEM_PROMPT",
+    "MCP_SYSTEM_PROMPT_ZH",
+    "MCP_SYSTEM_PROMPT_EN",
+]

AutoGLM_GUI/scheduler_manager.py

@@ -0,0 +1,304 @@
+"""Scheduled task manager with APScheduler."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from apscheduler.schedulers.background import BackgroundScheduler
+from apscheduler.triggers.cron import CronTrigger
+
+from AutoGLM_GUI.logger import logger
+from AutoGLM_GUI.models.scheduled_task import ScheduledTask
+
+
+class SchedulerManager:
+    _instance: Optional["SchedulerManager"] = 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._tasks_path = Path.home() / ".config" / "autoglm" / "scheduled_tasks.json"
+        self._scheduler = BackgroundScheduler()
+        self._tasks: dict[str, ScheduledTask] = {}
+        self._file_mtime: Optional[float] = None
+
+    def start(self) -> None:
+        self._load_tasks()
+        for task in self._tasks.values():
+            if task.enabled:
+                self._add_job(task)
+        self._scheduler.start()
+        logger.info(f"SchedulerManager started with {len(self._tasks)} task(s)")
+
+    def shutdown(self) -> None:
+        self._scheduler.shutdown(wait=False)
+        logger.info("SchedulerManager shutdown")
+
+    def create_task(
+        self,
+        name: str,
+        workflow_uuid: str,
+        device_serialno: str,
+        cron_expression: str,
+        enabled: bool = True,
+    ) -> ScheduledTask:
+        task = ScheduledTask(
+            name=name,
+            workflow_uuid=workflow_uuid,
+            device_serialno=device_serialno,
+            cron_expression=cron_expression,
+            enabled=enabled,
+        )
+        self._tasks[task.id] = task
+        self._save_tasks()
+
+        if enabled:
+            self._add_job(task)
+
+        logger.info(f"Created scheduled task: {name} (id={task.id})")
+        return task
+
+    def update_task(self, task_id: str, **kwargs) -> Optional[ScheduledTask]:
+        task = self._tasks.get(task_id)
+        if not task:
+            return None
+
+        old_enabled = task.enabled
+        old_cron = task.cron_expression
+
+        for key, value in kwargs.items():
+            if value is not None and hasattr(task, key):
+                setattr(task, key, value)
+
+        task.updated_at = datetime.now()
+        self._save_tasks()
+
+        if old_enabled and not task.enabled:
+            self._remove_job(task_id)
+        elif not old_enabled and task.enabled:
+            self._add_job(task)
+        elif task.enabled and old_cron != task.cron_expression:
+            self._remove_job(task_id)
+            self._add_job(task)
+
+        logger.info(f"Updated scheduled task: {task.name} (id={task_id})")
+        return task
+
+    def delete_task(self, task_id: str) -> bool:
+        task = self._tasks.pop(task_id, None)
+        if not task:
+            return False
+
+        self._remove_job(task_id)
+        self._save_tasks()
+        logger.info(f"Deleted scheduled task: {task.name} (id={task_id})")
+        return True
+
+    def list_tasks(self) -> list[ScheduledTask]:
+        return list(self._tasks.values())
+
+    def get_task(self, task_id: str) -> Optional[ScheduledTask]:
+        return self._tasks.get(task_id)
+
+    def set_enabled(self, task_id: str, enabled: bool) -> bool:
+        task = self._tasks.get(task_id)
+        if not task:
+            return False
+
+        if task.enabled == enabled:
+            return True
+
+        task.enabled = enabled
+        task.updated_at = datetime.now()
+        self._save_tasks()
+
+        if enabled:
+            self._add_job(task)
+        else:
+            self._remove_job(task_id)
+
+        logger.info(f"{'Enabled' if enabled else 'Disabled'} task: {task.name}")
+        return True
+
+    def get_next_run_time(self, task_id: str) -> Optional[datetime]:
+        job = self._scheduler.get_job(task_id)
+        if job and job.next_run_time:
+            return job.next_run_time.replace(tzinfo=None)
+        return None
+
+    def _add_job(self, task: ScheduledTask) -> None:
+        try:
+            parts = task.cron_expression.split()
+            if len(parts) != 5:
+                logger.error(f"Invalid cron expression: {task.cron_expression}")
+                return
+
+            trigger = CronTrigger(
+                minute=parts[0],
+                hour=parts[1],
+                day=parts[2],
+                month=parts[3],
+                day_of_week=parts[4],
+            )
+
+            self._scheduler.add_job(
+                self._execute_task,
+                trigger=trigger,
+                id=task.id,
+                args=[task.id],
+                replace_existing=True,
+            )
+            logger.debug(f"Added job for task: {task.name}")
+        except Exception as e:
+            logger.error(f"Failed to add job for task {task.name}: {e}")
+
+    def _remove_job(self, task_id: str) -> None:
+        try:
+            if self._scheduler.get_job(task_id):
+                self._scheduler.remove_job(task_id)
+                logger.debug(f"Removed job: {task_id}")
+        except Exception as e:
+            logger.warning(f"Failed to remove job {task_id}: {e}")
+
+    def _execute_task(self, task_id: str) -> None:
+        task = self._tasks.get(task_id)
+        if not task:
+            logger.warning(f"Task {task_id} not found for execution")
+            return
+
+        logger.info(f"Executing scheduled task: {task.name}")
+
+        from AutoGLM_GUI.device_manager import DeviceManager
+        from AutoGLM_GUI.history_manager import history_manager
+        from AutoGLM_GUI.models.history import ConversationRecord
+        from AutoGLM_GUI.phone_agent_manager import PhoneAgentManager
+        from AutoGLM_GUI.workflow_manager import workflow_manager
+
+        workflow = workflow_manager.get_workflow(task.workflow_uuid)
+        if not workflow:
+            self._record_failure(task, "Workflow not found")
+            return
+
+        device_manager = DeviceManager.get_instance()
+        device = None
+        for d in device_manager.get_devices():
+            if d.serial == task.device_serialno and d.state.value == "online":
+                device = d
+                break
+
+        if not device:
+            self._record_failure(task, "Device offline")
+            return
+
+        manager = PhoneAgentManager.get_instance()
+        acquired = manager.acquire_device(
+            device.primary_device_id,
+            timeout=0,
+            raise_on_timeout=False,
+            auto_initialize=True,
+        )
+
+        if not acquired:
+            self._record_failure(task, "Device busy")
+            return
+
+        start_time = datetime.now()
+        try:
+            agent = manager.get_agent(device.primary_device_id)
+            agent.reset()
+            result = agent.run(workflow["text"])
+            steps = agent.step_count
+
+            end_time = datetime.now()
+            record = ConversationRecord(
+                task_text=workflow["text"],
+                final_message=result,
+                success=True,
+                steps=steps,
+                start_time=start_time,
+                end_time=end_time,
+                duration_ms=int((end_time - start_time).total_seconds() * 1000),
+                source="scheduled",
+                source_detail=task.name,
+            )
+            history_manager.add_record(task.device_serialno, record)
+
+            self._record_success(task, result)
+
+        except Exception as e:
+            end_time = datetime.now()
+            error_msg = str(e)
+            logger.error(f"Scheduled task failed: {task.name} - {error_msg}")
+
+            record = ConversationRecord(
+                task_text=workflow["text"],
+                final_message=error_msg,
+                success=False,
+                steps=0,
+                start_time=start_time,
+                end_time=end_time,
+                duration_ms=int((end_time - start_time).total_seconds() * 1000),
+                source="scheduled",
+                source_detail=task.name,
+                error_message=error_msg,
+            )
+            history_manager.add_record(task.device_serialno, record)
+
+            self._record_failure(task, error_msg)
+
+        finally:
+            manager.release_device(device.primary_device_id)
+
+    def _record_success(self, task: ScheduledTask, message: str) -> None:
+        task.last_run_time = datetime.now()
+        task.last_run_success = True
+        task.last_run_message = message[:500] if message else ""
+        self._save_tasks()
+        logger.info(f"Scheduled task completed: {task.name}")
+
+    def _record_failure(self, task: ScheduledTask, error: str) -> None:
+        task.last_run_time = datetime.now()
+        task.last_run_success = False
+        task.last_run_message = error[:500] if error else ""
+        self._save_tasks()
+        logger.warning(f"Scheduled task failed: {task.name} - {error}")
+
+    def _load_tasks(self) -> None:
+        if not self._tasks_path.exists():
+            return
+
+        try:
+            with open(self._tasks_path, encoding="utf-8") as f:
+                data = json.load(f)
+            tasks_data = data.get("tasks", [])
+            self._tasks = {t["id"]: ScheduledTask.from_dict(t) for t in tasks_data}
+            self._file_mtime = self._tasks_path.stat().st_mtime
+            logger.debug(f"Loaded {len(self._tasks)} scheduled tasks")
+        except Exception as e:
+            logger.warning(f"Failed to load scheduled tasks: {e}")
+
+    def _save_tasks(self) -> None:
+        self._tasks_path.parent.mkdir(parents=True, exist_ok=True)
+        temp_path = self._tasks_path.with_suffix(".tmp")
+
+        try:
+            data = {"tasks": [t.to_dict() for t in self._tasks.values()]}
+            with open(temp_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            temp_path.replace(self._tasks_path)
+            self._file_mtime = self._tasks_path.stat().st_mtime
+            logger.debug(f"Saved {len(self._tasks)} scheduled tasks")
+        except Exception as e:
+            logger.error(f"Failed to save scheduled tasks: {e}")
+            if temp_path.exists():
+                temp_path.unlink()
+
+
+scheduler_manager = SchedulerManager()

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,210 @@ 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 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
+
+
+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]