Claude Code: add robust /health endpoint with brain, persistence, and frontend checks

- Explicit status keys: brain, persistence, frontend, agent_router
- Returns 503 for critical brain import failures
- Detailed checks dictionary for debugging
- Frontend and persistence issues return degraded status

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app.py

@@ -353,81 +353,124 @@ async def health():
     """
     Health check endpoint with proper HTTP status codes.
     Returns 200 if healthy, 503 if unhealthy with descriptive error.
+
+    Checks:
+    1. Brain import status
+    2. Data persistence files (JSON-based storage)
+    3. Frontend asset availability (static/index.html)
     """
     from fastapi import status as http_status
 
-    details = {"checks": {}}
-    brain_available = False
-    brain_error = None
+    checks = {}
+    is_healthy = True
+    error_message = None
 
     # 1. Check brain_minimal can be imported
+    brain_ok = False
     try:
         from openclaw.agents.brain_minimal import BrainMinimal
         brain = BrainMinimal(agent_name="cain", legacy_mode=True)
-        brain_available = True
-        details["checks"]["brain_minimal"] = "ok"
+        brain_ok = True
+        checks["brain_import"] = "ok"
     except ImportError as e:
-        brain_error = f"ImportError: {str(e)}"
-        details["checks"]["brain_minimal"] = f"failed: {brain_error}"
+        checks["brain_import"] = f"failed: ImportError: {str(e)}"
+        is_healthy = False
+        error_message = f"Brain import failed: {str(e)}"
     except Exception as e:
-        brain_error = f"{type(e).__name__}: {str(e)}"
-        details["checks"]["brain_minimal"] = f"failed: {brain_error}"
-
-    # If brain import fails, return 503 immediately
-    if not brain_available:
-        return JSONResponse(
-            status_code=http_status.HTTP_503_SERVICE_UNAVAILABLE,
-            content={
-                "status": "error",
-                "error": brain_error or "brain_minimal import failed",
-                "details": details
-            }
-        )
+        checks["brain_import"] = f"failed: {type(e).__name__}: {str(e)}"
+        is_healthy = False
+        error_message = f"Brain import failed: {type(e).__name__}: {str(e)}"
 
-    # 2. Check cain_status.json is accessible and valid
+    # 2. Check data persistence files (JSON-based)
+    persistence_ok = True
     cain_status_path = "/app/openclaw/.openclaw/agents/cain_status.json"
-    status_file_ok = True
-    status_error = None
+    registry_path = "/app/openclaw/.openclaw/agents/registry.json"
+
+    # Check cain_status.json
     try:
         with open(cain_status_path, "r") as f:
             status_data = json.load(f)
             current_state = status_data.get("current_state", "unknown")
-            details["cain_status_state"] = current_state
+            checks["persistence_cain_status"] = "ok"
             if current_state == "error":
-                status_error = "cain_status.json reports error state"
-                status_file_ok = False
-            elif current_state == "unknown":
-                details["cain_status"] = "ok (unknown state)"
+                checks["persistence_cain_status"] = "ok (error state)"
+    except FileNotFoundError:
+        checks["persistence_cain_status"] = "failed: file not found"
+        persistence_ok = False
+    except json.JSONDecodeError as e:
+        checks["persistence_cain_status"] = f"failed: invalid JSON: {str(e)}"
+        persistence_ok = False
+    except Exception as e:
+        checks["persistence_cain_status"] = f"failed: {type(e).__name__}: {str(e)}"
+        persistence_ok = False
+
+    # Check registry.json
+    try:
+        with open(registry_path, "r") as f:
+            json.load(f)
+            checks["persistence_registry"] = "ok"
     except FileNotFoundError:
-        status_error = "cain_status.json not found"
-        status_file_ok = False
+        checks["persistence_registry"] = "failed: file not found"
+        persistence_ok = False
     except json.JSONDecodeError as e:
-        status_error = f"cain_status.json invalid JSON: {str(e)}"
-        status_file_ok = False
+        checks["persistence_registry"] = f"failed: invalid JSON: {str(e)}"
+        persistence_ok = False
     except Exception as e:
-        status_error = f"cain_status.json read error: {type(e).__name__}: {str(e)}"
-        status_file_ok = False
+        checks["persistence_registry"] = f"failed: {type(e).__name__}: {str(e)}"
+        persistence_ok = False
 
-    details["checks"]["cain_status"] = "ok" if status_file_ok else f"failed: {status_error}"
+    checks["persistence"] = "ok" if persistence_ok else "degraded"
 
-    # 3. Check agent router heartbeat
+    # 3. Check frontend asset availability
+    frontend_ok = False
+    index_path = f"{static_dir}/index.html"
+    fallback_path = "/app/index.html"
+
+    if os.path.exists(index_path):
+        checks["frontend_assets"] = "ok"
+        frontend_ok = True
+    elif os.path.exists(fallback_path):
+        checks["frontend_assets"] = "ok (fallback)"
+        frontend_ok = True
+    else:
+        checks["frontend_assets"] = "failed: index.html not found"
+        # Frontend missing is degraded, not critical failure
+
+    # 4. Check agent router heartbeat
     now = time.time()
     cain_state = agent_router.get_state(AgentRole.CAIN)
     heartbeat_age = now - cain_state.last_heartbeat
     router_ok = heartbeat_age < 30
-    details["checks"]["agent_router"] = "ok" if router_ok else f"stale ({heartbeat_age:.1f}s)"
+    checks["agent_router"] = "ok" if router_ok else f"degraded: stale ({heartbeat_age:.1f}s)"
 
-    # Return healthy response if brain is available
-    response = {
-        "status": "healthy",
-        "agent": "cain",
+    # Determine overall status
+    # Critical failure: brain not available
+    if not brain_ok:
+        return JSONResponse(
+            status_code=http_status.HTTP_503_SERVICE_UNAVAILABLE,
+            content={
+                "status": "critical",
+                "brain": "unavailable",
+                "persistence": "ok" if persistence_ok else "error",
+                "frontend": "available" if frontend_ok else "unavailable",
+                "checks": checks,
+                "error": error_message,
+                "timestamp": datetime.utcnow().isoformat() + "+00:00"
+            }
+        )
+
+    # Healthy response
+    return {
+        "status": "healthy" if is_healthy else "degraded",
+        "brain": "available",
+        "persistence": "ok" if persistence_ok else "error",
+        "frontend": "available" if frontend_ok else "unavailable",
+        "agent_router": "ok" if router_ok else "stale",
         "uptime_seconds": round(time.time() - START_TIME, 2),
-        "details": details,
+        "checks": checks,
         "timestamp": datetime.utcnow().isoformat() + "+00:00"
     }
 
-    return response
-
 
 @app.get("/debug/health")
 async def debug_health():