@baimingtao/lbs-agent 1.0.0

package/runtime/orchestration/auto_cycle/__init__.py

@@ -0,0 +1,486 @@
+"""
+Cron 定时任务系统 — job 管理 + schedule 解析 + 执行引擎。
+
+对标 LBS cron 模块，精简实现核心能力：
+  1. Job 定义：agent_name + task + schedule + context
+  2. Schedule 解析：crontab 格式 + 简单间隔（30m / every 2h / daily）
+  3. next_run 计算：根据 schedule 计算下次执行时间
+  4. 持久化：JSON 文件存储
+  5. tick() 执行：检查 due jobs → 通过 Orchestrator 执行
+  6. 输出存储：保存最近一次执行结果
+
+用法：
+  from runtime.orchestration.auto_cycle import CronSystem
+  cron = CronSystem()
+  cron.create(name="daily_audit", schedule="0 9 * * *",
+              agent="audit", task="审计项目测试")
+  cron.tick()  # 检查并执行到期的 job
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import time
+import threading
+from dataclasses import dataclass, field, asdict
+from datetime import datetime, timedelta
+from typing import Any, Optional, Callable
+
+logger = logging.getLogger(__name__)
+
+
+# ── Schedule 解析 ──────────────────────────────────
+
+def parse_schedule(schedule: str) -> dict[str, Any]:
+    """解析 schedule 字符串。
+
+    支持格式：
+      1. Crontab: "0 9 * * *" / "*/30 * * * *"
+      2. 间隔: "30m" / "2h" / "daily" / "every 2h"
+      3. ISO 时间: "2025-01-01T09:00:00" (一次性)
+    """
+    s = schedule.strip().lower()
+
+    # 间隔格式: 30m / 2h / 10s
+    m = re.match(r"^(\d+)([smhd])$", s)
+    if m:
+        value = int(m.group(1))
+        unit = m.group(2)
+        mult = {"s": 1, "m": 60, "h": 3600, "d": 86400}[unit]
+        return {"type": "interval", "seconds": value * mult, "raw": schedule}
+
+    # "every Xh" 格式
+    m = re.match(r"^every\s+(\d+)([smhd]?)$", s)
+    if m:
+        value = int(m.group(1))
+        unit = m.group(2) or "m"
+        mult = {"s": 1, "m": 60, "h": 3600, "d": 86400}[unit]
+        return {"type": "interval", "seconds": value * mult, "raw": schedule}
+
+    # "daily" / "hourly" / "weekly"
+    if s == "daily":
+        return {"type": "interval", "seconds": 86400, "raw": schedule}
+    if s == "hourly":
+        return {"type": "interval", "seconds": 3600, "raw": schedule}
+    if s == "weekly":
+        return {"type": "interval", "seconds": 604800, "raw": schedule}
+
+    # Crontab 格式: "min hour day month weekday"
+    parts = schedule.strip().split()
+    if len(parts) == 5:
+        return {"type": "crontab", "raw": schedule,
+                "minute": parts[0], "hour": parts[1],
+                "day": parts[2], "month": parts[3], "weekday": parts[4]}
+
+    # ISO 时间 (一次性)
+    try:
+        dt = datetime.fromisoformat(schedule)
+        return {"type": "oneshot", "datetime": dt.isoformat(), "raw": schedule}
+    except ValueError:
+        pass
+
+    raise ValueError(f"无法解析 schedule: {schedule}")
+
+
+def compute_next_run(schedule: dict[str, Any], last_run: str = "") -> Optional[str]:
+    """根据 schedule 计算下次执行时间。
+
+    返回 ISO 格式字符串。
+    """
+    now = datetime.now()
+
+    if schedule["type"] == "interval":
+        seconds = schedule["seconds"]
+        if last_run:
+            try:
+                last_dt = datetime.fromisoformat(last_run)
+                next_dt = last_dt + timedelta(seconds=seconds)
+                if next_dt < now:
+                    next_dt = now + timedelta(seconds=seconds)
+                return next_dt.isoformat()
+            except ValueError:
+                pass
+        return (now + timedelta(seconds=seconds)).isoformat()
+
+    if schedule["type"] == "oneshot":
+        return schedule.get("datetime")
+
+    if schedule["type"] == "crontab":
+        # 简化版 crontab：只支持数字和 *
+        # 完整版需要 croniter 库，这里做近似计算
+        return _compute_crontab_next(schedule, now)
+
+    return None
+
+
+def _compute_crontab_next(schedule: dict[str, Any], now: datetime) -> str:
+    """简化版 crontab next_run 计算。
+
+    支持数字、*、*/N 格式。不支持范围(1-5)和列表(1,3,5)。
+    """
+    minute = schedule.get("minute", "*")
+    hour = schedule.get("hour", "*")
+    day = schedule.get("day", "*")
+    weekday = schedule.get("weekday", "*")
+
+    # 从下一分钟开始搜索
+    candidate = now.replace(second=0, microsecond=0) + timedelta(minutes=1)
+
+    for _ in range(525600):  # 最多搜一年
+        if not _crontab_match(minute, candidate.minute):
+            candidate += timedelta(minutes=1)
+            continue
+        if not _crontab_match(hour, candidate.hour):
+            candidate += timedelta(hours=1)
+            continue
+        if not _crontab_match(day, candidate.day):
+            candidate += timedelta(days=1)
+            continue
+        if not _crontab_match(weekday, candidate.weekday()):
+            candidate += timedelta(days=1)
+            continue
+        return candidate.isoformat()
+
+    return (now + timedelta(hours=1)).isoformat()
+
+
+def _crontab_match(pattern: str, value: int) -> bool:
+    """检查 value 是否匹配 crontab pattern。"""
+    if pattern == "*":
+        return True
+    if pattern.startswith("*/"):
+        divisor = int(pattern[2:])
+        return value % divisor == 0
+    try:
+        return value == int(pattern)
+    except ValueError:
+        return True
+
+
+# ── Job 定义 ───────────────────────────────────────
+
+@dataclass
+class CronJob:
+    """一个定时任务。"""
+    job_id: str = ""
+    name: str = ""
+    schedule: str = ""          # 原始 schedule 字符串
+    agent_name: str = ""        # 用哪个 agent 执行
+    task: str = ""              # 任务描述
+    context: str = ""           # 上下文
+    enabled: bool = True
+    next_run_at: str = ""       # ISO 时间
+    last_run_at: str = ""       # ISO 时间
+    last_result: str = ""       # 最近一次结果
+    last_success: bool = False
+    run_count: int = 0
+    fail_count: int = 0
+    created_at: str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "CronJob":
+        return cls(**{k: d.get(k, "") for k in
+                      ["job_id", "name", "schedule", "agent_name", "task", "context",
+                       "enabled", "next_run_at", "last_run_at", "last_result",
+                       "last_success", "run_count", "fail_count", "created_at"]
+                      if isinstance(d.get(k), (str, int, bool))})
+
+
+# ── Cron 系统 ──────────────────────────────────────
+
+
+# ── Cron Prompt Injection 扫描 ──────────────────────
+
+_CRON_THREAT_PATTERNS = [
+    (r'ignore\s+(?:\w+\s+)*(?:previous|all|above|prior)\s+(?:\w+\s+)*instructions', "prompt_injection"),
+    (r'do\s+not\s+tell\s+the\s+user', "deception_hide"),
+    (r'system\s+prompt\s+override', "sys_prompt_override"),
+    (r'disregard\s+(your|all|any)\s+(instructions|rules|guidelines)', "disregard_rules"),
+    (r'cat\s+[^\n]*(\.env|credentials|\.netrc|\.pgpass)', "read_secrets"),
+    (r'/etc/sudoers|visudo', "sudoers_mod"),
+    (r'rm\s+-rf\s+/', "destructive_root_rm"),
+]
+
+
+def scan_cron_prompt(text: str) -> list[str]:
+    """扫描 cron task 文本中的 prompt injection 威胁。
+
+    返回检测到的威胁类型列表；空列表表示安全。
+    """
+    import re
+    threats = []
+    for pattern, threat_type in _CRON_THREAT_PATTERNS:
+        if re.search(pattern, text, re.IGNORECASE):
+            threats.append(threat_type)
+    return threats
+
+
+class CronSystem:
+    """定时任务管理系统。
+
+    持久化到 .lbs-agent/cron_jobs.json
+    """
+
+    def __init__(
+        self,
+        project_root: str = "",
+        jobs_file: str = "",
+        runner: Optional[Callable[[CronJob], tuple[bool, str]]] = None,
+        job_timeout_seconds: int = 180,
+    ):
+        self.job_timeout_seconds = job_timeout_seconds
+        self.project_root = project_root or os.path.dirname(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        )
+        self._jobs_file = jobs_file or os.path.join(self.project_root, ".lbs-agent", "cron_jobs.json")
+        self._runner = runner
+        self._lock = threading.Lock()
+        self._jobs: dict[str, CronJob] = {}
+        self._load()
+
+    # ── 持久化 ───────────────────────────────────────
+
+    def _load(self):
+        if os.path.exists(self._jobs_file):
+            try:
+                with open(self._jobs_file, encoding="utf-8") as f:
+                    data = json.loads(f.read())
+                for job_data in data.get("jobs", []):
+                    job = CronJob.from_dict(job_data)
+                    if job.job_id:
+                        self._jobs[job.job_id] = job
+                logger.info("[cron] loaded %d jobs", len(self._jobs))
+            except Exception as e:
+                logger.warning("[cron] failed to load jobs: %s", e)
+
+    def _save(self):
+        os.makedirs(os.path.dirname(self._jobs_file), exist_ok=True)
+        data = {"jobs": [j.to_dict() for j in self._jobs.values()]}
+        with open(self._jobs_file, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+    # ── CRUD ─────────────────────────────────────────
+
+    def create(
+        self,
+        name: str,
+        schedule: str,
+        agent: str,
+        task: str,
+        context: str = "",
+    ) -> CronJob:
+        """创建定时任务。"""
+        import uuid
+        parsed = parse_schedule(schedule)
+        next_run = compute_next_run(parsed) or ""
+
+        job = CronJob(
+            job_id=f"cron-{uuid.uuid4().hex[:8]}",
+            name=name,
+            schedule=schedule,
+            agent_name=agent,
+            task=task,
+            context=context,
+            next_run_at=next_run,
+            created_at=datetime.now().isoformat(),
+        )
+
+        with self._lock:
+            self._jobs[job.job_id] = job
+            self._save()
+
+        logger.info("[cron] created job %s: %s every %s", job.job_id, name, schedule)
+        return job
+
+    def remove(self, job_id: str) -> bool:
+        with self._lock:
+            if job_id in self._jobs:
+                del self._jobs[job_id]
+                self._save()
+                return True
+            return False
+
+    def pause(self, job_id: str) -> bool:
+        with self._lock:
+            job = self._jobs.get(job_id)
+            if job:
+                job.enabled = False
+                self._save()
+                return True
+            return False
+
+    def resume(self, job_id: str) -> bool:
+        with self._lock:
+            job = self._jobs.get(job_id)
+            if job and not job.enabled:
+                job.enabled = True
+                parsed = parse_schedule(job.schedule)
+                job.next_run_at = compute_next_run(parsed) or ""
+                self._save()
+                return True
+            return False
+
+    def trigger(self, job_id: str) -> bool:
+        """手动触发一次执行（不影响 schedule）。"""
+        with self._lock:
+            job = self._jobs.get(job_id)
+            if job:
+                job.next_run_at = datetime.now().isoformat()
+                self._save()
+                return True
+            return False
+
+    def list_jobs(self, include_disabled: bool = False) -> list[CronJob]:
+        return [j for j in self._jobs.values() if j.enabled or include_disabled]
+
+    def get_job(self, job_id: str) -> Optional[CronJob]:
+        return self._jobs.get(job_id)
+
+    # ── 执行 ─────────────────────────────────────────
+
+    def get_due_jobs(self) -> list[CronJob]:
+        """获取所有到期需要执行的 job。"""
+        now = datetime.now()
+        due = []
+        for job in self._jobs.values():
+            if not job.enabled:
+                continue
+            if not job.next_run_at:
+                continue
+            try:
+                next_dt = datetime.fromisoformat(job.next_run_at)
+                if next_dt <= now:
+                    due.append(job)
+            except ValueError:
+                continue
+        return due
+
+    def tick(self, runner: Optional[Callable[[CronJob], tuple[bool, str]]] = None) -> list[dict]:
+        """执行一次 tick：检查到期 job 并执行。
+
+        Args:
+            runner: 自定义执行函数 (job) → (success, output)
+                    如果不提供，使用默认的 Orchestrator 执行。
+
+        Returns: 执行结果列表
+        """
+        due = self.get_due_jobs()
+        if not due:
+            return []
+
+        results = []
+        for job in due:
+            try:
+                effective_runner = runner or self._runner
+                if effective_runner:
+                    success, output = self._run_with_timeout(effective_runner, job)
+                else:
+                    success, output = self._default_runner(job)
+
+                with self._lock:
+                    job.last_run_at = datetime.now().isoformat()
+                    job.last_result = output[:500]
+                    job.last_success = success
+                    job.run_count += 1
+                    if not success:
+                        job.fail_count += 1
+
+                    # 计算下次执行
+                    parsed = parse_schedule(job.schedule)
+                    if parsed["type"] == "oneshot":
+                        job.enabled = False  # 一次性任务执行后禁用
+                    else:
+                        job.next_run_at = compute_next_run(parsed, job.last_run_at) or ""
+
+                    self._save()
+
+                results.append({
+                    "job_id": job.job_id,
+                    "name": job.name,
+                    "success": success,
+                    "output": output[:200],
+                    "next_run": job.next_run_at,
+                })
+
+                logger.info("[cron] job %s executed: success=%s", job.job_id, success)
+
+            except Exception as e:
+                logger.exception("[cron] job %s failed", job.job_id)
+                with self._lock:
+                    job.last_run_at = datetime.now().isoformat()
+                    job.last_result = str(e)[:500]
+                    job.last_success = False
+                    job.fail_count += 1
+                    parsed = parse_schedule(job.schedule)
+                    job.next_run_at = compute_next_run(parsed, job.last_run_at) or ""
+                    self._save()
+
+                results.append({
+                    "job_id": job.job_id,
+                    "name": job.name,
+                    "success": False,
+                    "error": str(e)[:200],
+                })
+
+        return results
+
+    def _default_runner(self, job: CronJob) -> tuple[bool, str]:
+        """Fail closed when the application composition root did not inject a runner."""
+        return False, "Cron runner is not configured; construct CronSystem through AgentSystemContainer"
+
+    def _run_with_timeout(self, runner, job: CronJob) -> tuple[bool, str]:
+        """执行 cron job，带超时保护。
+
+        对标 Hermes 的 3 分钟硬中断：如果 runner 在 job_timeout_seconds 内
+        没有返回，强制终止并标记失败。
+        """
+        from concurrent.futures import ThreadPoolExecutor, TimeoutError as FuturesTimeoutError
+        result_box: dict = {}
+
+        def _do_run():
+            try:
+                result_box["value"] = runner(job)
+            except Exception as e:
+                result_box["error"] = e
+
+        with ThreadPoolExecutor(max_workers=1) as pool:
+            future = pool.submit(_do_run)
+            try:
+                future.result(timeout=self.job_timeout_seconds)
+            except FuturesTimeoutError:
+                return False, f"Job timed out after {self.job_timeout_seconds}s"
+
+        if "error" in result_box:
+            return False, str(result_box["error"])
+        return result_box.get("value", (False, "no result"))
+
+    # ── 状态 ─────────────────────────────────────────
+
+    def status(self) -> dict[str, Any]:
+        return {
+            "total_jobs": len(self._jobs),
+            "enabled": sum(1 for j in self._jobs.values() if j.enabled),
+            "due_now": len(self.get_due_jobs()),
+            "total_runs": sum(j.run_count for j in self._jobs.values()),
+            "total_failures": sum(j.fail_count for j in self._jobs.values()),
+            "jobs": [
+                {
+                    "job_id": j.job_id,
+                    "name": j.name,
+                    "schedule": j.schedule,
+                    "agent": j.agent_name,
+                    "enabled": j.enabled,
+                    "next_run": j.next_run_at,
+                    "last_run": j.last_run_at,
+                    "last_success": j.last_success,
+                    "run_count": j.run_count,
+                }
+                for j in self._jobs.values()
+            ],
+        }

package/runtime/orchestration/auto_cycle/trigger.py

@@ -0,0 +1,8 @@
+"""Auto-cycle trigger boundary."""
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class AutoCycleTrigger:
+    name: str
+    enabled: bool = True