openclaw-agent-dashboard 1.0.4

package/src/backend/api/debug_paths.py

@@ -0,0 +1,39 @@
+"""
+诊断接口 - 路径解析与关键文件检查
+用于 Windows 等跨机器环境排查协作流程、模型配置等问题
+"""
+from fastapi import APIRouter
+
+router = APIRouter()
+
+
+@router.get("/debug/paths")
+async def get_debug_paths():
+    """
+    返回后端当前解析出的 OpenClaw 根目录及关键文件/目录存在性。
+    用于跨机器环境（如 Windows）排查协作流程、时序视图、模型列表等问题。
+    """
+    try:
+        from data.config_reader import get_openclaw_root
+        root = get_openclaw_root()
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "openclawRoot": None,
+            "openclawJsonExists": False,
+            "agentsDirExists": False,
+            "subagentsRunsExists": False,
+        }
+
+    openclaw_json = root / "openclaw.json"
+    agents_dir = root / "agents"
+    subagents_runs = root / "subagents" / "runs.json"
+
+    return {
+        "success": True,
+        "openclawRoot": str(root),
+        "openclawJsonExists": openclaw_json.exists(),
+        "agentsDirExists": agents_dir.exists() and agents_dir.is_dir(),
+        "subagentsRunsExists": subagents_runs.exists(),
+    }

package/src/backend/api/error_analysis.py

@@ -0,0 +1,146 @@
+"""
+错误分析 API - 提供错误根因分析接口
+"""
+from fastapi import APIRouter, HTTPException
+from typing import Optional
+import sys
+from pathlib import Path
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+from data.error_analyzer import (
+    analyze_agent_errors,
+    analyze_all_agents_errors,
+    get_error_detail,
+    classify_error,
+    get_error_suggestions,
+)
+
+router = APIRouter()
+
+
+def format_error_for_display(error: dict) -> dict:
+    """格式化错误信息用于前端展示"""
+    severity_colors = {
+        'critical': '#dc2626',
+        'high': '#f97316',
+        'medium': '#fbbf24',
+        'low': '#6b7280',
+    }
+
+    severity_labels = {
+        'critical': '严重',
+        'high': '高',
+        'medium': '中',
+        'low': '低',
+    }
+
+    type_labels = {
+        'api_auth': 'API 认证错误',
+        'api_rate_limit': 'API 限流',
+        'api_model': '模型错误',
+        'timeout': '超时',
+        'permission': '权限错误',
+        'tool_error': '工具错误',
+        'subagent': '子任务错误',
+        'network': '网络错误',
+        'unknown': '未知错误',
+    }
+
+    error_type = error.get('errorType', 'unknown')
+    severity = error.get('severity', 'medium')
+
+    return {
+        **error,
+        'errorTypeLabel': type_labels.get(error_type, error_type),
+        'severityLabel': severity_labels.get(severity, severity),
+        'severityColor': severity_colors.get(severity, '#6b7280'),
+    }
+
+
+@router.get("/error-analysis")
+async def get_global_error_analysis():
+    """
+    获取所有 Agent 的错误分析概览
+
+    返回全局错误统计和每个 Agent 的错误摘要
+    """
+    try:
+        result = analyze_all_agents_errors()
+
+        # 格式化错误信息
+        for agent_result in result.get('agents', []):
+            agent_result['errors'] = [
+                format_error_for_display(e)
+                for e in agent_result.get('errors', [])
+            ]
+
+        return result
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        return {
+            'agents': [],
+            'globalSummary': {},
+            'error': str(e),
+        }
+
+
+@router.get("/error-analysis/{agent_id}")
+async def get_agent_error_analysis(agent_id: str, session_limit: int = 5):
+    """
+    获取单个 Agent 的错误分析
+
+    - agent_id: Agent ID
+    - session_limit: 分析最近的 N 个 session
+    """
+    try:
+        result = analyze_agent_errors(agent_id, session_limit)
+        result['errors'] = [
+            format_error_for_display(e)
+            for e in result.get('errors', [])
+        ]
+        return result
+    except Exception as e:
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/error-analysis/{agent_id}/{session_file}/{turn_index}")
+async def get_error_detail_api(agent_id: str, session_file: str, turn_index: int):
+    """
+    获取单个错误的详细信息
+
+    包括错误发生前的工具调用链
+    """
+    try:
+        error = get_error_detail(agent_id, session_file, turn_index)
+        if not error:
+            raise HTTPException(status_code=404, detail="Error not found")
+        return format_error_for_display(error)
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/error-analysis/classify")
+async def classify_error_message(message: str):
+    """
+    对给定的错误消息进行分类
+
+    返回错误类型、严重程度和修复建议
+    """
+    try:
+        error_type, severity = classify_error(message)
+        suggestions = get_error_suggestions(error_type, message)
+
+        return {
+            'message': message,
+            'errorType': error_type.value,
+            'severity': severity.value,
+            'suggestions': suggestions,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

package/src/backend/api/errors.py

@@ -0,0 +1,281 @@
+"""
+错误中心 API - 聚合 Session 错误、Model Failures、API 状态
+支持统计、筛选、趋势分析
+"""
+from fastapi import APIRouter, Query
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timedelta
+import sys
+from pathlib import Path
+import time
+from collections import defaultdict
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+router = APIRouter()
+
+
+# 错误类型映射
+ERROR_TYPE_MAP = {
+    'rate-limit': {'label': 'Rate Limit', 'color': '#f59e0b', 'severity': 'warning'},
+    'token-limit': {'label': 'Token 超限', 'color': '#8b5cf6', 'severity': 'warning'},
+    'timeout': {'label': '超时', 'color': '#ef4444', 'severity': 'error'},
+    'auth': {'label': '认证失败', 'color': '#dc2626', 'severity': 'critical'},
+    'unknown': {'label': '未知错误', 'color': '#6b7280', 'severity': 'error'},
+}
+
+
+def classify_error(err_msg: str) -> str:
+    """更精细的错误分类"""
+    err_lower = err_msg.lower()
+
+    if '429' in err_msg or 'rate limit' in err_lower or 'too many requests' in err_lower:
+        return 'rate-limit'
+    elif 'token' in err_lower or 'context' in err_lower or 'length' in err_lower:
+        return 'token-limit'
+    elif 'timeout' in err_lower or '超时' in err_msg or 'timed out' in err_lower:
+        return 'timeout'
+    elif '401' in err_msg or '403' in err_msg or 'auth' in err_lower or 'unauthorized' in err_lower:
+        return 'auth'
+    else:
+        return 'unknown'
+
+
+def get_session_errors(limit: int = 100, agent_filter: str = None, type_filter: str = None) -> List[Dict]:
+    """获取 Session 错误"""
+    from data.session_reader import get_recent_messages
+    from data.config_reader import get_agents_list
+
+    errors = []
+    agents = get_agents_list()
+
+    for agent in agents:
+        agent_id = agent.get('id', '')
+        if not agent_id:
+            continue
+        if agent_filter and agent_id != agent_filter:
+            continue
+
+        messages = get_recent_messages(agent_id, limit=200)
+        for msg in messages:
+            if msg.get('stopReason') != 'error':
+                continue
+
+            err_msg = msg.get('errorMessage', '') or ''
+            err_type = classify_error(err_msg)
+
+            if type_filter and err_type != type_filter:
+                continue
+
+            errors.append({
+                "id": f"session-{agent_id}-{msg.get('timestamp', 0)}",
+                "source": "session",
+                "agentId": agent_id,
+                "type": err_type,
+                "typeLabel": ERROR_TYPE_MAP.get(err_type, {}).get('label', err_type),
+                "severity": ERROR_TYPE_MAP.get(err_type, {}).get('severity', 'error'),
+                "message": err_msg[:300] if err_msg else "(无详情)",
+                "fullMessage": err_msg,
+                "timestamp": msg.get('timestamp', 0),
+                "datetime": datetime.fromtimestamp(msg.get('timestamp', 0) / 1000).strftime('%Y-%m-%d %H:%M:%S') if msg.get('timestamp') else '-',
+            })
+
+    errors.sort(key=lambda x: x["timestamp"], reverse=True)
+    return errors[:limit]
+
+
+def get_model_failures(limit: int = 100, model_filter: str = None, type_filter: str = None) -> List[Dict]:
+    """获取 Model Failures"""
+    from status.error_detector import parse_failure_log
+
+    errors = []
+    failures = parse_failure_log()
+
+    for f in failures:
+        model = f.get("model", "")
+        if model_filter and model != model_filter:
+            continue
+
+        err_type = f.get("error_type", "unknown")
+        if type_filter and err_type != type_filter:
+            continue
+
+        timestamp = f.get("timestamp", 0)
+        errors.append({
+            "id": f"model-{timestamp}-{model}",
+            "source": "model",
+            "model": model,
+            "type": err_type,
+            "typeLabel": ERROR_TYPE_MAP.get(err_type, {}).get('label', err_type),
+            "severity": ERROR_TYPE_MAP.get(err_type, {}).get('severity', 'error'),
+            "message": (f.get("message", "") or "")[:300],
+            "fullMessage": f.get("message", "") or "",
+            "timestamp": timestamp,
+            "datetime": datetime.fromtimestamp(timestamp / 1000).strftime('%Y-%m-%d %H:%M:%S') if timestamp else '-',
+        })
+
+    return errors[:limit]
+
+
+def get_api_status() -> List[Dict]:
+    """获取 API 状态（整合自原 api_status 模块）"""
+    from status.error_detector import parse_failure_log
+
+    failures = parse_failure_log()
+    status_map = {}
+    now = int(time.time() * 1000)
+
+    for failure in failures:
+        model = failure.get('model', '')
+        if not model:
+            continue
+
+        if model not in status_map:
+            status_map[model] = {
+                'model': model,
+                'provider': parse_provider(model),
+                'status': 'healthy',
+                'errorCount': 0,
+                'lastError': None,
+            }
+
+        status_map[model]['errorCount'] += 1
+
+        # 最近 10 分钟内有错误
+        if failure['timestamp'] > now - 600000:
+            if failure['timestamp'] > now - 120000:  # 2分钟内
+                status_map[model]['status'] = 'down'
+            else:
+                status_map[model]['status'] = 'degraded'
+
+            if not status_map[model]['lastError']:
+                status_map[model]['lastError'] = {
+                    'type': failure.get('error_type', 'unknown'),
+                    'message': (failure.get('message', '') or '')[:100],
+                    'timestamp': failure['timestamp'],
+                }
+
+    return list(status_map.values())
+
+
+def parse_provider(model: str) -> str:
+    """从模型名解析服务商"""
+    if model.startswith('glm'):
+        return 'zhipu'
+    elif model.startswith('qwen'):
+        return 'qwen'
+    elif model.startswith('kimi'):
+        return 'moonshot'
+    elif model.startswith('claude'):
+        return 'anthropic'
+    elif model.startswith('gpt'):
+        return 'openai'
+    else:
+        return 'unknown'
+
+
+def get_error_stats(session_errors: List, model_failures: List) -> Dict:
+    """计算错误统计"""
+    # 按类型统计
+    type_stats = defaultdict(lambda: {'count': 0, 'label': '', 'color': ''})
+    for e in session_errors + model_failures:
+        err_type = e.get('type', 'unknown')
+        type_stats[err_type]['count'] += 1
+        type_stats[err_type]['label'] = ERROR_TYPE_MAP.get(err_type, {}).get('label', err_type)
+        type_stats[err_type]['color'] = ERROR_TYPE_MAP.get(err_type, {}).get('color', '#6b7280')
+
+    # 按 Agent 统计
+    agent_stats = defaultdict(lambda: {'count': 0, 'agentId': ''})
+    for e in session_errors:
+        agent_id = e.get('agentId', 'unknown')
+        agent_stats[agent_id]['count'] += 1
+        agent_stats[agent_id]['agentId'] = agent_id
+
+    # 按小时统计（最近 24 小时）
+    hourly_stats = defaultdict(int)
+    now = datetime.now()
+    for e in session_errors + model_failures:
+        ts = e.get('timestamp', 0)
+        if ts:
+            dt = datetime.fromtimestamp(ts / 1000)
+            if dt > now - timedelta(hours=24):
+                hour_key = dt.strftime('%Y-%m-%d %H:00')
+                hourly_stats[hour_key] += 1
+
+    # 生成完整的小时序列
+    hourly_list = []
+    for i in range(24):
+        hour = (now - timedelta(hours=23-i)).strftime('%Y-%m-%d %H:00')
+        hourly_list.append({
+            'hour': hour,
+            'count': hourly_stats.get(hour, 0)
+        })
+
+    return {
+        'totalCount': len(session_errors) + len(model_failures),
+        'sessionErrorCount': len(session_errors),
+        'modelFailureCount': len(model_failures),
+        'byType': dict(type_stats),
+        'byAgent': dict(agent_stats),
+        'hourlyTrend': hourly_list,
+    }
+
+
+@router.get("/errors")
+async def get_errors(
+    limit: int = Query(50, ge=1, le=500),
+    agent: Optional[str] = Query(None, description="按 Agent ID 筛选"),
+    type: Optional[str] = Query(None, description="按错误类型筛选"),
+    model: Optional[str] = Query(None, description="按模型筛选"),
+):
+    """
+    获取错误中心数据
+    支持按 Agent、类型、模型筛选
+    """
+    session_errors = get_session_errors(limit, agent, type)
+    model_failures = get_model_failures(limit, model, type)
+
+    return {
+        "sessionErrors": session_errors,
+        "modelFailures": model_failures,
+    }
+
+
+@router.get("/errors/stats")
+async def get_errors_stats():
+    """
+    获取错误统计数据
+    包括：总数、按类型分布、按 Agent 分布、时间趋势
+    """
+    session_errors = get_session_errors(200)
+    model_failures = get_model_failures(200)
+
+    return get_error_stats(session_errors, model_failures)
+
+
+@router.get("/errors/api-status")
+async def get_errors_api_status():
+    """
+    获取 API 状态
+    整合自原 api_status 模块
+    """
+    return get_api_status()
+
+
+@router.get("/errors/summary")
+async def get_errors_summary():
+    """
+    获取错误中心完整数据（一次请求获取所有）
+    包括：错误列表、统计、API 状态
+    """
+    session_errors = get_session_errors(100)
+    model_failures = get_model_failures(100)
+    api_status = get_api_status()
+    stats = get_error_stats(session_errors, model_failures)
+
+    return {
+        "sessionErrors": session_errors,
+        "modelFailures": model_failures,
+        "apiStatus": api_status,
+        "stats": stats,
+    }