openclaw-agent-dashboard 1.0.4

package/src/backend/status_calculator.py

@@ -0,0 +1,121 @@
+"""
+状态计算器 - 计算 Agent 状态
+"""
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).parent.parent))
+
+import time
+from typing import Literal
+from data.config_reader import get_agents_list, get_agent_config
+from data.subagent_reader import is_agent_working, get_agent_runs
+from data.session_reader import (
+    has_recent_errors,
+    get_last_error,
+    has_recent_session_activity,
+)
+
+
+AgentStatus = Literal['idle', 'working', 'down']
+
+
+def calculate_agent_status(agent_id: str) -> AgentStatus:
+    """
+    计算 Agent 状态（基于 runs.json + sessions.json）
+    
+    优先级:
+    1. 异常 (down) - 最近5分钟有 stopReason=error
+    2. 工作中 (working) - 有活跃 subagent run 或 session 正在处理（最近5分钟有活动）
+    3. 空闲 (idle) - 无活跃 run 且最近5分钟无 session 活动
+    """
+    # 检查异常
+    if has_recent_errors(agent_id, minutes=5):
+        return 'down'
+    
+    # 检查工作中：subagent run 未结束，或 session 最近有活动
+    if is_agent_working(agent_id):
+        return 'working'
+    if has_recent_session_activity(agent_id, minutes=2):
+        return 'working'
+    
+    # 默认空闲
+    return 'idle'
+
+
+def get_agents_with_status() -> list:
+    """获取所有 Agent 及其状态"""
+    agents = get_agents_list()
+    result = []
+    
+    for agent in agents:
+        agent_id = agent.get('id')
+        status = calculate_agent_status(agent_id)
+        
+        # 获取当前任务
+        current_task = get_current_task(agent_id)
+        
+        # 获取最后活跃时间
+        last_active = get_last_active_time(agent_id)
+        
+        # 获取错误信息
+        last_error = get_last_error(agent_id) if status == 'down' else None
+        
+        result.append({
+            'id': agent_id,
+            'name': agent.get('name'),
+            'role': agent.get('name'),
+            'status': status,
+            'currentTask': current_task,
+            'lastActiveAt': last_active,
+            'error': last_error
+        })
+    
+    return result
+
+
+def get_current_task(agent_id: str) -> str:
+    """获取 Agent 当前任务"""
+    runs = get_agent_runs(agent_id, limit=1)
+    if not runs:
+        return ''
+    
+    run = runs[0]
+    task = run.get('task', '')
+
+    # 截取前60个字符（统一长度）
+    if len(task) > 60:
+        task = task[:57] + '...'
+
+    return task
+
+
+def get_last_active_time(agent_id: str) -> int:
+    """获取 Agent 最后活跃时间（runs 或 sessions.json updatedAt）"""
+    from data.session_reader import get_session_updated_at
+    
+    runs = get_agent_runs(agent_id, limit=1)
+    run_ts = 0
+    if runs:
+        run = runs[0]
+        run_ts = run.get('endedAt') or run.get('startedAt', 0)
+    
+    session_ts = get_session_updated_at(agent_id)
+    return max(run_ts, session_ts)
+
+
+def format_last_active(timestamp: int) -> str:
+    """格式化最后活跃时间为相对时间"""
+    if not timestamp:
+        return '未知'
+    
+    now = int(time.time() * 1000)
+    diff_seconds = (now - timestamp) / 1000
+    
+    if diff_seconds < 60:
+        return f"{int(diff_seconds)}秒前"
+    elif diff_seconds < 3600:
+        return f"{int(diff_seconds / 60)}分钟前"
+    elif diff_seconds < 86400:
+        return f"{int(diff_seconds / 3600)}小时前"
+    else:
+        return f"{int(diff_seconds / 86400)}天前"

package/src/backend/subagent_reader.py

@@ -0,0 +1,229 @@
+"""
+子代理运行读取器 - 读取 subagents/runs.json
+"""
+import json
+import os
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+
+
+def _openclaw_home() -> Path:
+    """OpenClaw 根目录，优先使用 OPENCLAW_HOME 环境变量"""
+    env = os.environ.get("OPENCLAW_HOME")
+    if env:
+        p = Path(env).expanduser()
+        if p.exists():
+            return p
+    return Path.home() / ".openclaw"
+
+
+SUBAGENTS_RUNS_PATH = _openclaw_home() / "subagents" / "runs.json"
+
+
+def load_subagent_runs() -> List[Dict[str, Any]]:
+    """加载子代理运行记录
+    
+    OpenClaw runs.json 格式: {"version": 2, "runs": { runId: record }}
+    """
+    if not SUBAGENTS_RUNS_PATH.exists():
+        return []
+    
+    with open(SUBAGENTS_RUNS_PATH, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    runs = data.get('runs', {})
+    if isinstance(runs, dict):
+        return list(runs.values())
+    return runs if isinstance(runs, list) else []
+
+
+def get_active_runs() -> List[Dict[str, Any]]:
+    """获取活跃的运行（未结束）"""
+    runs = load_subagent_runs()
+    return [run for run in runs if run.get('endedAt') is None]
+
+
+def get_agent_runs(agent_id: str, limit: int = 10) -> List[Dict[str, Any]]:
+    """获取指定 Agent 的运行记录"""
+    runs = load_subagent_runs()
+    agent_runs = []
+    
+    for run in runs:
+        child_key = run.get('childSessionKey', '')
+        if f'agent:{agent_id}:' in child_key:
+            agent_runs.append(run)
+    
+    # 按开始时间倒序
+    agent_runs.sort(key=lambda x: x.get('startedAt', 0), reverse=True)
+    return agent_runs[:limit]
+
+
+def is_agent_working(agent_id: str) -> bool:
+    """
+    判断 Agent 是否在工作中
+    - 作为执行者：childSessionKey 包含 agent:{agent_id}:
+    - 作为派发者：requesterSessionKey 包含 agent:{agent_id}:（主 Agent 等待子 Agent 完成）
+    """
+    active_runs = get_active_runs()
+    for run in active_runs:
+        child_key = run.get('childSessionKey', '')
+        requester_key = run.get('requesterSessionKey', '')
+        if f'agent:{agent_id}:' in child_key:
+            return True
+        if f'agent:{agent_id}:' in requester_key:
+            return True
+    return False
+
+
+def get_agent_output_for_run(child_session_key: str, max_chars: int = 10000) -> Optional[str]:
+    """
+    从子 Agent 的 session 文件中提取最后一次 assistant 消息的文本输出。
+    用于任务成功时展示 Agent 的执行结果。
+    
+    Args:
+        child_session_key: 格式 agent:<agentId>:subagent:<uuid>
+        max_chars: 最大返回字符数，超出则截断
+    
+    Returns:
+        Agent 的文本输出，若无法获取则返回 None
+    """
+    if not child_session_key or ':' not in child_session_key:
+        return None
+    parts = child_session_key.split(':')
+    if len(parts) < 2 or parts[0] != 'agent':
+        return None
+    agent_id = parts[1]
+    
+    openclaw_path = _openclaw_home()
+    sessions_index = openclaw_path / "agents" / agent_id / "sessions" / "sessions.json"
+    if not sessions_index.exists():
+        return None
+    
+    try:
+        with open(sessions_index, 'r', encoding='utf-8') as f:
+            index_data = json.load(f)
+        entry = index_data.get(child_session_key)
+        if not entry:
+            return None
+        session_file = entry.get('sessionFile')
+        session_id = entry.get('sessionId')
+        if not session_file and not session_id:
+            return None
+        if not session_file:
+            sessions_dir = openclaw_path / "agents" / agent_id / "sessions"
+            session_file = str(sessions_dir / f"{session_id}.jsonl")
+        
+        session_path = Path(session_file)
+        if not session_path.exists():
+            return None
+        
+        last_text = None
+        with open(session_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                try:
+                    data = json.loads(line)
+                    if data.get('type') != 'message':
+                        continue
+                    msg = data.get('message', {})
+                    if msg.get('role') != 'assistant':
+                        continue
+                    content = msg.get('content', [])
+                    for c in content:
+                        if isinstance(c, dict) and c.get('type') == 'text':
+                            text = c.get('text', '')
+                            if text and text.strip():
+                                last_text = text
+                            break
+                except (json.JSONDecodeError, KeyError):
+                    continue
+        
+        if not last_text or not last_text.strip():
+            return None
+        if len(last_text) > max_chars:
+            return last_text[:max_chars] + '\n\n...(输出已截断)'
+        return last_text
+    except Exception as e:
+        print(f"get_agent_output_for_run 失败: {e}")
+        return None
+
+
+def get_agent_files_for_run(child_session_key: str) -> List[str]:
+    """
+    从子 Agent 的 session 中提取本次任务生成/修改的文件路径。
+    解析 write、edit 等工具调用中的 path 参数。
+    
+    Returns:
+        去重后的文件路径列表
+    """
+    if not child_session_key or ':' not in child_session_key:
+        return []
+    parts = child_session_key.split(':')
+    if len(parts) < 2 or parts[0] != 'agent':
+        return []
+    agent_id = parts[1]
+    
+    openclaw_path = _openclaw_home()
+    sessions_index = openclaw_path / "agents" / agent_id / "sessions" / "sessions.json"
+    if not sessions_index.exists():
+        return []
+    
+    try:
+        with open(sessions_index, 'r', encoding='utf-8') as f:
+            index_data = json.load(f)
+        entry = index_data.get(child_session_key)
+        if not entry:
+            return []
+        session_file = entry.get('sessionFile')
+        session_id = entry.get('sessionId')
+        if not session_file and not session_id:
+            return []
+        if not session_file:
+            sessions_dir = openclaw_path / "agents" / agent_id / "sessions"
+            session_file = str(sessions_dir / f"{session_id}.jsonl")
+        
+        session_path = Path(session_file)
+        if not session_path.exists():
+            return []
+        
+        file_paths: List[str] = []
+        file_tools = ('write', 'edit')
+        
+        with open(session_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                try:
+                    data = json.loads(line)
+                    if data.get('type') != 'message':
+                        continue
+                    msg = data.get('message', {})
+                    if msg.get('role') != 'assistant':
+                        continue
+                    content = msg.get('content', [])
+                    for c in content:
+                        if not isinstance(c, dict) or c.get('type') != 'toolCall':
+                            continue
+                        name = c.get('name', '')
+                        if name not in file_tools:
+                            continue
+                        args = c.get('arguments', {})
+                        if isinstance(args, str):
+                            try:
+                                args = json.loads(args)
+                            except json.JSONDecodeError:
+                                continue
+                        path = args.get('path') or args.get('file_path')
+                        if path and isinstance(path, str) and path.strip():
+                            file_paths.append(path.strip())
+                except (json.JSONDecodeError, KeyError):
+                    continue
+        
+        # 去重并保持顺序
+        seen = set()
+        result = []
+        for p in file_paths:
+            if p not in seen:
+                seen.add(p)
+                result.append(p)
+        return result
+    except Exception as e:
+        print(f"get_agent_files_for_run 失败: {e}")
+        return []

package/src/backend/watchers/__init__.py

@@ -0,0 +1,4 @@
+"""文件监听与实时推送"""
+from .file_watcher import start_file_watcher, stop_file_watcher
+
+__all__ = ["start_file_watcher", "stop_file_watcher"]

package/src/backend/watchers/file_watcher.py

@@ -0,0 +1,159 @@
+"""
+文件变更监听 - 关键文件变更时触发 WebSocket 推送
+使用 watchdog 监听 runs.json、sessions/*.jsonl、task_history.json、model-failures.log
+"""
+import threading
+import time
+from pathlib import Path
+from typing import Callable, Optional
+
+
+def _get_openclaw_dir() -> Path:
+    from data.config_reader import get_openclaw_root
+    return get_openclaw_root()
+DEBOUNCE_SECONDS = 0.3  # 同一文件短时间多次变更只触发一次
+
+
+def _get_watch_dirs() -> list[tuple[Path, bool]]:
+    """获取需要监听的目录列表 (path, recursive)"""
+    dirs: list[tuple[Path, bool]] = []
+    openclaw_dir = _get_openclaw_dir()
+    subagents = openclaw_dir / "subagents"
+    if subagents.exists():
+        dirs.append((subagents, False))
+    try:
+        from data.task_history import get_dashboard_data_dir
+        dashboard_data = get_dashboard_data_dir()
+        if dashboard_data.exists():
+            dirs.append((dashboard_data, False))
+    except Exception:
+        pass
+    # workspace/*/memory: 从配置读取，或回退到 workspace-main
+    try:
+        from data.config_reader import get_workspace_paths
+        for ws in get_workspace_paths():
+            memory = ws / "memory"
+            if memory.exists():
+                dirs.append((memory, False))
+    except Exception:
+        memory = openclaw_dir / "workspace-main" / "memory"
+        if memory.exists():
+            dirs.append((memory, False))
+    agents_dir = openclaw_dir / "agents"
+    if agents_dir.exists():
+        for agent_dir in agents_dir.iterdir():
+            if agent_dir.is_dir():
+                sessions_dir = agent_dir / "sessions"
+                if sessions_dir.exists():
+                    dirs.append((sessions_dir, True))
+    return dirs
+
+
+class DebouncedHandler:
+    """防抖：短时间多次变更只触发一次回调"""
+
+    def __init__(self, callback: Callable[[], None], debounce_sec: float = DEBOUNCE_SECONDS):
+        self.callback = callback
+        self.debounce_sec = debounce_sec
+        self._last_trigger: float = 0
+        self._lock = threading.Lock()
+        self._timer: Optional[threading.Timer] = None
+
+    def trigger(self) -> None:
+        with self._lock:
+            now = time.monotonic()
+            if self._timer:
+                self._timer.cancel()
+                self._timer = None
+
+            def do_callback() -> None:
+                with self._lock:
+                    self._last_trigger = time.monotonic()
+                    self._timer = None
+                try:
+                    self.callback()
+                except Exception as e:
+                    print(f"[FileWatcher] 回调异常: {e}")
+
+            if now - self._last_trigger < self.debounce_sec:
+                self._timer = threading.Timer(self.debounce_sec - (now - self._last_trigger), do_callback)
+                self._timer.daemon = True
+                self._timer.start()
+            else:
+                do_callback()
+
+
+_observer = None
+_handler = None
+
+
+def _on_file_changed() -> None:
+    """文件变更时触发 WebSocket 推送"""
+    try:
+        from api.websocket import broadcast_full_state
+        import asyncio
+
+        loop = _event_loop
+        if loop and broadcast_full_state:
+            future = asyncio.run_coroutine_threadsafe(broadcast_full_state(), loop)
+            future.result(timeout=10)
+    except Exception as e:
+        print(f"[FileWatcher] 推送失败: {e}")
+
+
+_event_loop = None
+
+
+def start_file_watcher(loop) -> None:
+    """启动文件监听（在 FastAPI 启动时调用）"""
+    global _observer, _handler, _event_loop
+    _event_loop = loop
+
+    try:
+        from watchdog.observers import Observer
+        from watchdog.events import FileSystemEventHandler, FileModifiedEvent, FileCreatedEvent
+    except ImportError:
+        print("[FileWatcher] watchdog 未安装，跳过文件监听。请执行: pip install watchdog")
+        return
+
+    RELEVANT_SUFFIXES = (".json", ".jsonl", ".log")
+
+    class Handler(FileSystemEventHandler):
+        def _should_trigger(self, src_path: str) -> bool:
+            return any(src_path.endswith(s) for s in RELEVANT_SUFFIXES)
+
+        def on_modified(self, event):
+            if event.is_directory:
+                return
+            if self._should_trigger(event.src_path):
+                _handler.trigger()
+
+        def on_created(self, event):
+            if event.is_directory:
+                return
+            if self._should_trigger(event.src_path):
+                _handler.trigger()
+
+    watch_dirs = _get_watch_dirs()
+    if not watch_dirs:
+        print("[FileWatcher] 无有效监听路径，跳过")
+        return
+
+    _handler = DebouncedHandler(_on_file_changed)
+    _observer = Observer()
+
+    for watch_dir, recursive in watch_dirs:
+        _observer.schedule(Handler(), str(watch_dir), recursive=recursive)
+
+    _observer.start()
+    print(f"[FileWatcher] 已启动，监听 {len(watch_dirs)} 个目录")
+
+
+def stop_file_watcher() -> None:
+    """停止文件监听"""
+    global _observer
+    if _observer:
+        _observer.stop()
+        _observer.join(timeout=2)
+        _observer = None
+        print("[FileWatcher] 已停止")