openclaw-agent-dashboard 1.0.39 → 1.0.41

package/dashboard/session_reader.py

@@ -1,240 +0,0 @@
-"""
-会话读取器 - 读取 sessions/*.jsonl 和 sessions.json
-"""
-import json
-import os
-from pathlib import Path
-from typing import List, Dict, Any, Optional
-
-
-from data.config_reader import get_openclaw_root, normalize_openclaw_agent_id
-
-
-def get_agent_sessions_path(agent_id: str) -> Optional[Path]:
-    """获取 Agent 的 sessions 目录"""
-    sessions_path = get_openclaw_root() / "agents" / normalize_openclaw_agent_id(agent_id) / "sessions"
-    if not sessions_path.exists():
-        return None
-    return sessions_path
-
-
-def get_latest_session_file(agent_id: str) -> Optional[Path]:
-    """获取最新的 session 文件"""
-    sessions_path = get_agent_sessions_path(agent_id)
-    if not sessions_path:
-        return None
-    
-    jsonl_files = list(sessions_path.glob("*.jsonl"))
-    if not jsonl_files:
-        return None
-    
-    # 按修改时间排序，取最新的
-    jsonl_files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
-    return jsonl_files[0]
-
-
-def get_recent_messages(agent_id: str, limit: int = 10) -> List[Dict[str, Any]]:
-    """获取最近的会话消息"""
-    session_file = get_latest_session_file(agent_id)
-    if not session_file:
-        return []
-    
-    messages = []
-    with open(session_file, 'r', encoding='utf-8') as f:
-        for line in f:
-            try:
-                data = json.loads(line.strip())
-                if data.get('type') == 'message':
-                    messages.append(data.get('message', {}))
-            except json.JSONDecodeError:
-                continue
-    
-    # 只取最后 N 条
-    return messages[-limit:]
-
-
-def has_recent_errors(agent_id: str, minutes: int = 5) -> bool:
-    """检查最近是否有错误"""
-    messages = get_recent_messages(agent_id, limit=50)
-    
-    import time
-    cutoff_time = int(time.time() * 1000) - (minutes * 60 * 1000)
-    
-    for msg in messages:
-        if msg.get('stopReason') == 'error':
-            timestamp = msg.get('timestamp', 0)
-            if timestamp > cutoff_time:
-                return True
-    
-    return False
-
-
-def get_last_error(agent_id: str) -> Optional[Dict[str, Any]]:
-    """获取最近的错误信息"""
-    messages = get_recent_messages(agent_id, limit=100)
-    
-    for msg in reversed(messages):
-        if msg.get('stopReason') == 'error':
-            return {
-                'type': detect_error_type(msg.get('errorMessage', '')),
-                'message': msg.get('errorMessage', ''),
-                'timestamp': msg.get('timestamp', 0)
-            }
-    
-    return None
-
-
-def detect_error_type(error_msg: str) -> str:
-    """检测错误类型"""
-    error_msg_lower = (error_msg or '').lower()
-    
-    if '429' in error_msg or 'rate limit' in error_msg_lower:
-        return 'rate-limit'
-    elif 'token' in error_msg_lower or 'context' in error_msg_lower:
-        return 'token-limit'
-    elif 'timeout' in error_msg_lower or '超时' in error_msg_lower:
-        return 'timeout'
-    elif '余额不足' in (error_msg or ''):
-        return 'quota'
-    else:
-        return 'unknown'
-
-
-def get_session_updated_at(agent_id: str) -> int:
-    """
-    获取 Agent 会话的最后更新时间（sessions.json 中 updatedAt 的最大值）
-    用于判断「最近 5 分钟是否有 session 活动」
-    """
-    aid = normalize_openclaw_agent_id(agent_id)
-    sessions_index = get_openclaw_root() / "agents" / aid / "sessions" / "sessions.json"
-    if not sessions_index.exists():
-        return 0
-    
-    try:
-        with open(sessions_index, 'r', encoding='utf-8') as f:
-            data = json.load(f)
-        if not isinstance(data, dict):
-            return 0
-        max_ts = 0
-        for entry in data.values():
-            if isinstance(entry, dict):
-                ts = entry.get('updatedAt', 0)
-                if isinstance(ts, (int, float)) and ts > max_ts:
-                    max_ts = int(ts)
-        return max_ts
-    except (json.JSONDecodeError, IOError):
-        return 0
-
-
-def has_recent_session_activity(agent_id: str, minutes: int = 5) -> bool:
-    """检查 Agent 最近 N 分钟内是否有 session 活动"""
-    import time
-    updated_at = get_session_updated_at(agent_id)
-    if not updated_at:
-        return False
-    cutoff = int(time.time() * 1000) - (minutes * 60 * 1000)
-    return updated_at > cutoff
-
-
-def get_session_turns(agent_id: str, session_key: Optional[str] = None, limit: int = 50) -> List[Dict[str, Any]]:
-    """
-    解析 jsonl 获取会话轮次，每轮包含 user/assistant/toolResult 及 usage
-    返回格式: [{ turnIndex, role, content, usage?, toolCalls?, stopReason?, timestamp }]
-    """
-    aid = normalize_openclaw_agent_id(agent_id)
-    sessions_index = get_openclaw_root() / "agents" / aid / "sessions" / "sessions.json"
-    if not sessions_index.exists():
-        return []
-    
-    session_file: Optional[Path] = None
-    if session_key:
-        try:
-            with open(sessions_index, 'r', encoding='utf-8') as f:
-                index_data = json.load(f)
-            entry = index_data.get(session_key) if isinstance(index_data, dict) else None
-            if entry and isinstance(entry, dict):
-                sf = entry.get('sessionFile')
-                sid = entry.get('sessionId')
-                if sf:
-                    session_file = Path(sf)
-                elif sid:
-                    session_file = get_openclaw_root() / "agents" / aid / "sessions" / f"{sid}.jsonl"
-        except (json.JSONDecodeError, IOError):
-            pass
-    
-    if not session_file or not session_file.exists():
-        session_file = get_latest_session_file(agent_id)
-    
-    if not session_file:
-        return []
-    
-    turns: List[Dict[str, Any]] = []
-    turn_index = 0
-    
-    with open(session_file, 'r', encoding='utf-8') as f:
-        for line in f:
-            try:
-                data = json.loads(line.strip())
-                if data.get('type') != 'message':
-                    continue
-                msg = data.get('message', {})
-                role = msg.get('role')
-                if not role:
-                    continue
-                
-                turn: Dict[str, Any] = {
-                    'turnIndex': turn_index,
-                    'role': role,
-                    'timestamp': msg.get('timestamp') or data.get('timestamp'),
-                    'content': [],
-                    'usage': msg.get('usage'),
-                    'stopReason': msg.get('stopReason'),
-                    'toolCalls': [],
-                    'toolName': None,
-                }
-                
-                content = msg.get('content', [])
-                if isinstance(content, str):
-                    content = [{'type': 'text', 'text': content}]
-                
-                for c in content:
-                    if not isinstance(c, dict):
-                        continue
-                    ct = c.get('type')
-                    if ct == 'text':
-                        if role == 'toolResult':
-                            turn['content'].append({
-                                'type': 'toolResult',
-                                'content': c.get('text', ''),
-                                'status': msg.get('details', {}).get('status'),
-                                'error': msg.get('details', {}).get('error'),
-                            })
-                        else:
-                            turn['content'].append({'type': 'text', 'text': c.get('text', '')})
-                    elif ct == 'thinking':
-                        turn['content'].append({'type': 'thinking', 'text': c.get('thinking', '')})
-                    elif ct == 'toolCall':
-                        turn['toolCalls'].append({
-                            'name': c.get('name'),
-                            'arguments': c.get('arguments'),
-                            'id': c.get('id'),
-                        })
-                        turn['toolName'] = c.get('name')
-                
-                if role == 'toolResult':
-                    turn['toolName'] = msg.get('toolName')
-                    if not turn['content']:
-                        details = msg.get('details', {})
-                        turn['content'].append({
-                            'type': 'toolResult',
-                            'status': details.get('status'),
-                            'error': details.get('error'),
-                        })
-                
-                turns.append(turn)
-                turn_index += 1
-                
-            except (json.JSONDecodeError, KeyError):
-                continue
-    
-    return turns[-limit:] if len(turns) > limit else turns

package/dashboard/status_calculator.py

@@ -1,121 +0,0 @@
-"""
-状态计算器 - 计算 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/dashboard/subagent_reader.py

@@ -1,232 +0,0 @@
-"""
-子代理运行读取器 - 读取 subagents/runs.json
-"""
-import json
-import os
-from pathlib import Path
-from typing import List, Dict, Any, Optional
-
-from data.config_reader import normalize_openclaw_agent_id
-
-
-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 = []
-    prefix = f"agent:{normalize_openclaw_agent_id(agent_id)}:"
-    for run in runs:
-        child_key = run.get('childSessionKey', '')
-        if prefix 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()
-    prefix = f"agent:{normalize_openclaw_agent_id(agent_id)}:"
-    for run in active_runs:
-        child_key = run.get('childSessionKey', '')
-        requester_key = run.get('requesterSessionKey', '')
-        if prefix in child_key:
-            return True
-        if prefix 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 = normalize_openclaw_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 = normalize_openclaw_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 []