openclaw-agent-dashboard 1.0.38 → 1.0.40

package/dashboard/api/agent_config_api.py

@@ -2,13 +2,21 @@
 Agent 配置 API - 提供配置读取和修改接口
 """
 from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+from typing import List, Optional
+try:
+    from pydantic import field_validator
+except ImportError:
+    from pydantic import validator as field_validator
 from typing import List, Optional
 import sys
 from pathlib import Path
 
 sys.path.append(str(Path(__file__).parent.parent))
 
+from api.input_safety import require_safe_agent_id
+from core.error_handler import record_error
+from core.safe_api_error import safe_api_error_detail, safe_client_string
 from data.agent_config_manager import (
     get_agent_full_info,
     get_all_agents_info,
@@ -21,8 +29,15 @@ router = APIRouter()
 
 
 class UpdateModelRequest(BaseModel):
-    primary: Optional[str] = None
-    fallbacks: Optional[List[str]] = None
+    primary: Optional[str] = Field(None, max_length=256)
+    fallbacks: Optional[List[str]] = Field(None, max_length=32)
+
+    @field_validator("fallbacks")
+    @classmethod
+    def _fallback_items_len(cls, v: Optional[List[str]]) -> Optional[List[str]]:
+        if v and any(len(str(x)) > 256 for x in v):
+            raise ValueError("fallback model id too long")
+        return v
 
 
 @router.get("/agent-config")
@@ -35,12 +50,14 @@ async def list_agent_configs():
             'total': len(agents),
         }
     except Exception as e:
-        return {'agents': [], 'total': 0, 'error': str(e)}
+        record_error("unknown", str(e), "api:agent_config:list", exc=e)
+        return {'agents': [], 'total': 0, 'error': safe_client_string(str(e))}
 
 
 @router.get("/agent-config/{agent_id}")
 async def get_agent_config(agent_id: str):
     """获取单个 Agent 的详细配置"""
+    require_safe_agent_id(agent_id)
     try:
         info = get_agent_full_info(agent_id)
         if not info.get('found'):
@@ -49,12 +66,14 @@ async def get_agent_config(agent_id: str):
     except HTTPException:
         raise
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        record_error("unknown", str(e), "api:agent_config:get_one", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e))
 
 
 @router.put("/agent-config/{agent_id}/model")
 async def update_agent_model_config(agent_id: str, request: UpdateModelRequest):
     """更新 Agent 的模型配置"""
+    require_safe_agent_id(agent_id)
     try:
         result = update_agent_model(
             agent_id,
@@ -74,7 +93,8 @@ async def update_agent_model_config(agent_id: str, request: UpdateModelRequest):
     except HTTPException:
         raise
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        record_error("unknown", str(e), "api:agent_config:put_model", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e))
 
 
 @router.get("/available-models")
@@ -87,4 +107,5 @@ async def list_available_models():
             'total': len(models),
         }
     except Exception as e:
-        return {'models': [], 'total': 0, 'error': str(e)}
+        record_error("unknown", str(e), "api:agent_config:models", exc=e)
+        return {'models': [], 'total': 0, 'error': safe_client_string(str(e))}

package/dashboard/api/agents.py

@@ -1,13 +1,18 @@
 """
 Agent API 路由
 """
-from fastapi import APIRouter
-from pydantic import BaseModel
-from typing import List, Optional
+import asyncio
 import sys
 from pathlib import Path
+from typing import List, Optional
+
 sys.path.append(str(Path(__file__).parent.parent))
 
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel
+
+from api.input_safety import require_safe_agent_id
+
 from status.status_calculator import (
     get_agents_with_status,
     format_last_active
@@ -30,7 +35,17 @@ class AgentStatus(BaseModel):
 @router.get("/agents", response_model=List[AgentStatus])
 async def get_agents():
     """获取所有 Agent 列表及状态"""
-    agents = get_agents_with_status()
+    from core.error_handler import ErrorHandler
+
+    def _load():
+        h = ErrorHandler(max_retry=2, base_delay=0.5)
+        return h.run_with_retry(
+            lambda: get_agents_with_status(),
+            operation="get_agents_with_status",
+            error_type="io-error",
+        )
+
+    agents = await asyncio.to_thread(_load)
     
     # 格式化最后活跃时间
     for agent in agents:
@@ -43,7 +58,18 @@ async def get_agents():
 @router.get("/agents/{agent_id}", response_model=AgentStatus)
 async def get_agent(agent_id: str):
     """获取单个 Agent 详情"""
-    agents = get_agents_with_status()
+    require_safe_agent_id(agent_id)
+    from core.error_handler import ErrorHandler
+
+    def _load():
+        h = ErrorHandler(max_retry=2, base_delay=0.5)
+        return h.run_with_retry(
+            lambda: get_agents_with_status(),
+            operation="get_agents_with_status",
+            error_type="io-error",
+        )
+
+    agents = await asyncio.to_thread(_load)
     
     from data.config_reader import agent_ids_equal
 
@@ -53,22 +79,34 @@ async def get_agent(agent_id: str):
                 agent['lastActiveFormatted'] = format_last_active(agent['lastActiveAt'])
             return agent
     
-    from fastapi import HTTPException
     raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
 
 
 @router.get("/agents/{agent_id}/output")
-async def get_agent_output(agent_id: str, limit: int = 50):
+async def get_agent_output(
+    agent_id: str,
+    limit: int = Query(50, ge=1, le=500, description="返回最近轮次数上限"),
+):
     """
     获取 Agent 最近会话详情：每轮 user/assistant/toolResult 及 usage
     用于调试视图展示
     """
+    require_safe_agent_id(agent_id)
     from data.session_reader import get_session_turns
     from data.config_reader import get_agent_config
 
     if not get_agent_config(agent_id):
-        from fastapi import HTTPException
         raise HTTPException(status_code=404, detail=f"Agent {agent_id} not found")
-    
-    turns = get_session_turns(agent_id, limit=limit)
+
+    from core.error_handler import ErrorHandler
+
+    def _load_turns():
+        h = ErrorHandler(max_retry=2, base_delay=0.5)
+        return h.run_with_retry(
+            lambda: get_session_turns(agent_id, limit=limit),
+            operation="get_session_turns",
+            error_type="io-error",
+        )
+
+    turns = await asyncio.to_thread(_load_turns)
     return {"agentId": agent_id, "turns": turns}

package/dashboard/api/agents_config.py

@@ -5,6 +5,9 @@ Agent 配置 API - 直接从 openclaw.json 读取
 from fastapi import APIRouter
 from typing import List, Dict, Any
 
+from core.error_handler import record_error
+from core.safe_api_error import safe_client_string
+
 router = APIRouter()
 
 
@@ -62,6 +65,7 @@ async def get_agents_config():
             'lastUpdate': int(__import__('time').time() * 1000),
         }
     except Exception as e:
+        record_error("unknown", str(e), "api:agents_config:get", exc=e)
         return {
             'nodes': [],
             'edges': [],
@@ -71,5 +75,5 @@ async def get_agents_config():
             'models': [],
             'recentCalls': [],
             'lastUpdate': 0,
-            '_error': str(e),
+            '_error': safe_client_string(str(e)),
         }

package/dashboard/api/chains.py

@@ -8,6 +8,9 @@ import sys
 from pathlib import Path
 sys.path.append(str(Path(__file__).parent.parent))
 
+from api.input_safety import require_safe_run_or_chain_id
+from core.error_handler import record_error
+from core.safe_api_error import safe_api_error_detail
 from data.chain_reader import (
     build_task_chains,
     get_task_chain,
@@ -79,8 +82,12 @@ async def list_chains(
     - 节点间的派发关系
     - 各节点的状态和进度
     """
-    chains = build_task_chains(limit=limit)
-    active = get_active_chain()
+    try:
+        chains = build_task_chains(limit=limit)
+        active = get_active_chain()
+    except Exception as e:
+        record_error("unknown", str(e), "api:chains:list", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
 
     return {
         "chains": chains,
@@ -95,7 +102,11 @@ async def get_summary():
 
     快速查看所有链路的状态分布
     """
-    return get_chains_summary()
+    try:
+        return get_chains_summary()
+    except Exception as e:
+        record_error("unknown", str(e), "api:chains:summary", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
 
 
 @router.get("/chains/active")
@@ -105,7 +116,11 @@ async def get_active():
 
     返回正在执行的任务链
     """
-    chain = get_active_chain()
+    try:
+        chain = get_active_chain()
+    except Exception as e:
+        record_error("unknown", str(e), "api:chains:active", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
     if not chain:
         return {"activeChain": None, "message": "当前没有正在执行的任务链"}
 
@@ -119,7 +134,12 @@ async def get_chain(chain_id: str):
 
     返回完整的链路信息，包括所有节点和边
     """
-    chain = get_task_chain(chain_id)
+    require_safe_run_or_chain_id(chain_id, name="chain_id")
+    try:
+        chain = get_task_chain(chain_id)
+    except Exception as e:
+        record_error("unknown", str(e), "api:chains:detail", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
     if not chain:
         raise HTTPException(status_code=404, detail=f"Chain {chain_id} not found")
 

package/dashboard/api/collaboration.py

@@ -17,6 +17,8 @@ TZ_DISPLAY = ZoneInfo('Asia/Shanghai')
 
 sys.path.append(str(Path(__file__).parent.parent))
 
+from core.error_handler import record_error
+
 router = APIRouter()
 logger = logging.getLogger(__name__)
 
@@ -261,7 +263,7 @@ def _get_model_mapping() -> Dict[str, str]:
                 if base != short:
                     _model_mapping_cache[base] = model_id
         except Exception as e:
-            logger.warning(f"Failed to build model mapping: {e}")
+            record_error("unknown", str(e), "collaboration:model_mapping", exc=e)
             _model_mapping_cache = {}
     return _model_mapping_cache
 
@@ -372,7 +374,7 @@ def _enrich_main_agent_active_tasks_if_needed(
 
 def _get_agent_error_info(agent_id: str) -> Optional[Dict[str, Any]]:
     """获取 agent 的错误/异常信息"""
-    from session_reader import get_last_error, has_recent_errors
+    from data.session_reader import get_last_error, has_recent_errors
 
     if has_recent_errors(agent_id, minutes=10):
         error = get_last_error(agent_id)
@@ -389,7 +391,7 @@ def _get_agent_error_info(agent_id: str) -> Optional[Dict[str, Any]]:
 def _check_agent_stuck(agent_id: str) -> Optional[Dict[str, Any]]:
     """检查 agent 是否卡顿（长时间无响应但有活跃任务）"""
     import time
-    from session_reader import get_session_updated_at
+    from data.session_reader import get_session_updated_at
     from data.subagent_reader import is_agent_working, get_active_runs
 
     if not is_agent_working(agent_id):
@@ -763,14 +765,13 @@ async def get_collaboration():
             active_path.extend([main_agent_id, agent_id_canon, task_id])
 
     except Exception as e:
-        print(f"Error building collaboration data: {e}")
-        import traceback
-        traceback.print_exc()
+        record_error("unknown", str(e), "collaboration:build_flow", exc=e)
 
     if not nodes:
         try:
             main_agent_id = get_main_agent_id()
-        except Exception:
+        except Exception as e:
+            record_error("unknown", str(e), "collaboration:fallback_main_id", exc=e)
             main_agent_id = 'main'
         nodes = [
             CollaborationNode(id=main_agent_id, type="agent", name="主 Agent", status="idle"),
@@ -905,7 +906,7 @@ async def get_collaboration_dynamic():
                     alert=dyn_status['alert']
                 )
             except Exception as e:
-                logger.warning(f"Failed to get display status for {aid}: {e}")
+                record_error("unknown", str(e), f"collaboration:display_status:{aid}", exc=e)
 
         # PM：覆盖为与连线同源的状态；并修正 dynamic 文案，避免 calculate_agent_status 的 solo 与卡片矛盾
         main_collab = _main_agent_status_for_collaboration(main_agent_id)
@@ -933,7 +934,7 @@ async def get_collaboration_dynamic():
             if requester_id and requester_id != agent_id:
                 active_path.extend([requester_id])
     except Exception as e:
-        logger.error(f"Error building collaboration dynamic: {e}")
+        record_error("unknown", str(e), "collaboration:dynamic", exc=e)
 
     recent_calls_raw = _get_recent_model_calls(30)
     model_calls = [

package/dashboard/api/debug_paths.py

@@ -4,6 +4,9 @@
 """
 from fastapi import APIRouter
 
+from core.error_handler import record_error
+from core.safe_api_error import safe_client_string
+
 router = APIRouter()
 
 
@@ -17,9 +20,10 @@ async def get_debug_paths():
         from data.config_reader import get_openclaw_root
         root = get_openclaw_root()
     except Exception as e:
+        record_error("unknown", str(e), "api:debug_paths", exc=e)
         return {
             "success": False,
-            "error": str(e),
+            "error": safe_client_string(str(e)),
             "openclawRoot": None,
             "openclawJsonExists": False,
             "agentsDirExists": False,

package/dashboard/api/error_analysis.py

@@ -1,13 +1,20 @@
 """
 错误分析 API - 提供错误根因分析接口
 """
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, Query
+from pydantic import BaseModel, Field
 from typing import Optional
 import sys
 from pathlib import Path
 
 sys.path.append(str(Path(__file__).parent.parent))
 
+from api.input_safety import (
+    require_safe_agent_id,
+    require_safe_session_file_segment,
+)
+from core.error_handler import record_error
+from core.safe_api_error import safe_api_error_detail, safe_client_string
 from data.error_analyzer import (
     analyze_agent_errors,
     analyze_all_agents_errors,
@@ -19,6 +26,10 @@ from data.error_analyzer import (
 router = APIRouter()
 
 
+class ClassifyErrorRequest(BaseModel):
+    message: str = Field(..., min_length=1, max_length=16_000)
+
+
 def format_error_for_display(error: dict) -> dict:
     """格式化错误信息用于前端展示"""
     severity_colors = {
@@ -77,23 +88,26 @@ async def get_global_error_analysis():
 
         return result
     except Exception as e:
-        import traceback
-        traceback.print_exc()
+        record_error("unknown", str(e), "api:error_analysis:global", exc=e)
         return {
             'agents': [],
             'globalSummary': {},
-            'error': str(e),
+            'error': safe_client_string(str(e)),
         }
 
 
 @router.get("/error-analysis/{agent_id}")
-async def get_agent_error_analysis(agent_id: str, session_limit: int = 5):
+async def get_agent_error_analysis(
+    agent_id: str,
+    session_limit: int = Query(5, ge=1, le=50, description="分析的 session 数量上限"),
+):
     """
     获取单个 Agent 的错误分析
 
     - agent_id: Agent ID
     - session_limit: 分析最近的 N 个 session
     """
+    require_safe_agent_id(agent_id)
     try:
         result = analyze_agent_errors(agent_id, session_limit)
         result['errors'] = [
@@ -102,9 +116,8 @@ async def get_agent_error_analysis(agent_id: str, session_limit: int = 5):
         ]
         return result
     except Exception as e:
-        import traceback
-        traceback.print_exc()
-        raise HTTPException(status_code=500, detail=str(e))
+        record_error("unknown", str(e), "api:error_analysis:agent", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e))
 
 
 @router.get("/error-analysis/{agent_id}/{session_file}/{turn_index}")
@@ -114,6 +127,8 @@ async def get_error_detail_api(agent_id: str, session_file: str, turn_index: int
 
     包括错误发生前的工具调用链
     """
+    require_safe_agent_id(agent_id)
+    session_file = require_safe_session_file_segment(session_file)
     try:
         error = get_error_detail(agent_id, session_file, turn_index)
         if not error:
@@ -122,17 +137,19 @@ async def get_error_detail_api(agent_id: str, session_file: str, turn_index: int
     except HTTPException:
         raise
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        record_error("unknown", str(e), "api:error_analysis:detail", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e))
 
 
 @router.post("/error-analysis/classify")
-async def classify_error_message(message: str):
+async def classify_error_message(req: ClassifyErrorRequest):
     """
     对给定的错误消息进行分类
 
     返回错误类型、严重程度和修复建议
     """
     try:
+        message = req.message
         error_type, severity = classify_error(message)
         suggestions = get_error_suggestions(error_type, message)
 
@@ -143,4 +160,5 @@ async def classify_error_message(message: str):
             'suggestions': suggestions,
         }
     except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
+        record_error("unknown", str(e), "api:error_analysis:classify", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e))

package/dashboard/api/errors.py

@@ -2,7 +2,7 @@
 错误中心 API - 聚合 Session 错误、Model Failures、API 状态
 支持统计、筛选、趋势分析
 """
-from fastapi import APIRouter, Query
+from fastapi import APIRouter, HTTPException, Query
 from typing import List, Dict, Any, Optional
 from datetime import datetime, timedelta
 import sys
@@ -12,6 +12,9 @@ from collections import defaultdict
 
 sys.path.append(str(Path(__file__).parent.parent))
 
+from core.error_handler import get_framework_error_stats_for_client, record_error
+from core.safe_api_error import safe_api_error_detail
+
 router = APIRouter()
 
 
@@ -232,8 +235,12 @@ async def get_errors(
     获取错误中心数据
     支持按 Agent、类型、模型筛选
     """
-    session_errors = get_session_errors(limit, agent, type)
-    model_failures = get_model_failures(limit, model, type)
+    try:
+        session_errors = get_session_errors(limit, agent, type)
+        model_failures = get_model_failures(limit, model, type)
+    except Exception as e:
+        record_error("unknown", str(e), "api:errors:list", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
 
     return {
         "sessionErrors": session_errors,
@@ -247,10 +254,15 @@ 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)
+    try:
+        session_errors = get_session_errors(200)
+        model_failures = get_model_failures(200)
+        out = get_error_stats(session_errors, model_failures)
+        out["framework"] = get_framework_error_stats_for_client()
+        return out
+    except Exception as e:
+        record_error("unknown", str(e), "api:errors:stats", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
 
 
 @router.get("/errors/api-status")
@@ -268,10 +280,14 @@ 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)
+    try:
+        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)
+    except Exception as e:
+        record_error("unknown", str(e), "api:errors:summary", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e
 
     return {
         "sessionErrors": session_errors,

package/dashboard/api/fortify_routes.py

@@ -0,0 +1,80 @@
+"""TECHDEBT_FORTIFY: health, cache stats, data validation endpoints."""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException, Query
+
+sys.path.append(str(Path(__file__).parent.parent))
+
+from api.input_safety import require_safe_agent_id, require_safe_session_file_segment
+from core.error_handler import record_error
+from core.safe_api_error import safe_api_error_detail
+
+router = APIRouter()
+
+
+@router.get("/health/watcher")
+async def watcher_health() -> Any:
+    from watchers.file_watcher import get_watcher_health
+
+    return get_watcher_health()
+
+
+@router.get("/cache/stats")
+async def cache_stats() -> Any:
+    from status.status_cache import get_cache
+
+    c = get_cache()
+    s = c.get_stats()
+    from datetime import datetime, timezone
+
+    s["last_update"] = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+    return {
+        "cache_size": s["size"],
+        "max_size": s["max_size"],
+        "memory_usage_mb": s.get("memory_usage_mb"),
+        "max_memory_mb": s["max_memory_mb"],
+        "hit_rate": s["hit_rate"],
+        "ttl_seconds": s["ttl_seconds"],
+        "preload_enabled": s["preload_enabled"],
+        "cache_double_check": s.get("cache_double_check"),
+        "fp_probe_interval_sec": s.get("fp_probe_interval_sec"),
+        "last_update": s["last_update"],
+        "stats": s["stats"],
+        "process_rss_mb": s.get("process_rss_mb"),
+    }
+
+
+@router.get("/data/validate")
+async def validate_session_data(
+    agent_id: str = Query(..., description="Agent ID"),
+    session_file: Optional[str] = Query(
+        None,
+        description="可选：相对于 agents/{agent_id}/sessions 的 .jsonl 路径（如 foo.jsonl）",
+    ),
+    auto_repair: bool = Query(True),
+    include_details: bool = Query(False),
+    max_lines: int = Query(1000, ge=1, le=50_000),
+) -> Any:
+    from data.session_reader import get_session_validation_report
+
+    if not agent_id.strip():
+        raise HTTPException(status_code=400, detail="agent_id required")
+    aid = require_safe_agent_id(agent_id.strip())
+    rel = session_file.strip() if session_file and session_file.strip() else None
+    if rel:
+        rel = require_safe_session_file_segment(rel)
+    try:
+        return get_session_validation_report(
+            aid,
+            relative_session_file=rel,
+            auto_repair=auto_repair,
+            include_details=include_details,
+            max_lines=max_lines,
+        )
+    except Exception as e:
+        record_error("unknown", str(e), "api:fortify:validate", exc=e)
+        raise HTTPException(status_code=500, detail=safe_api_error_detail(e)) from e