Claude Code: Refactor to use FastAPI as the backend instead of standard Grad

Dockerfile

@@ -13,7 +13,7 @@ RUN echo "[build] Installing system deps..." && START=$(date +%s) \
   && apt-get update \
   && apt-get install -y --no-install-recommends git ca-certificates curl python3 python3-pip \
   && rm -rf /var/lib/apt/lists/* \
-  && pip3 install --no-cache-dir --break-system-packages huggingface_hub requests gradio psutil \
+  && pip3 install --no-cache-dir --break-system-packages huggingface_hub requests gradio psutil fastapi uvicorn[standard] \
   && corepack enable \
   && mkdir -p /app/openclaw \
   && chown -R node:node /app \
@@ -54,6 +54,7 @@ COPY --chown=node:node frontend /home/node/frontend
 COPY --chown=node:node workspace-templates /home/node/workspace-templates
 COPY --chown=node:node openclaw.json /home/node/scripts/openclaw.json.default
 COPY --chown=node:node gradio_dashboard.py /home/node/gradio_dashboard.py
+COPY --chown=node:node app.py /home/node/app.py
 RUN chmod +x /home/node/scripts/entrypoint.sh /home/node/scripts/sync_hf.py \
   && VERSION_TS=$(date +%s) \
   && sed "s/{{VERSION_TIMESTAMP}}/${VERSION_TS}/g" /home/node/frontend/electron-standalone.html > /home/node/frontend/index.html \

app.py

@@ -1,46 +1,486 @@
-import subprocess
+#!/usr/bin/env python3
+"""
+FastAPI Backend for HuggingClaw-Cain
+=====================================
+Provides REST API endpoints for agent status checks and chat interactions.
+Mounts the Gradio dashboard as a sub-route.
+"""
+import os
 import sys
-import time
+import json
+import asyncio
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+from pathlib import Path
 
-# Restart configuration to prevent crash loops
-MAX_RESTARTS = 3
-RESTART_DELAY = 10  # seconds between restart attempts
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+import uvicorn
 
-if __name__ == "__main__":
-    # In a generic Docker Space, this might not be executed if CMD is set in Dockerfile.
-    # But if the user switches to generic Python SDK or wants to run it manually:
+# Paths
+WORKSPACE_DIR = Path("/tmp/claude-workspace")
+OPENCLAW_HOME = Path.home() / ".openclaw"
 
-    for attempt in range(MAX_RESTARTS):
-        try:
-            print("Starting OpenClaw Sync Wrapper...")
-            if attempt > 0:
-                print(f"Restart attempt {attempt + 1}/{MAX_RESTARTS}...")
-
-            result = subprocess.run(
-                [sys.executable, "scripts/sync_hf.py"],
-                check=True
-            )
-            # Success - exit with the subprocess's return code
-            sys.exit(result.returncode)
-
-        except subprocess.CalledProcessError as e:
-            print(f"ERROR: Sync process failed with exit code {e.returncode}", file=sys.stderr)
-            if attempt < MAX_RESTARTS - 1:
-                print(f"Retrying in {RESTART_DELAY} seconds...", file=sys.stderr)
-                time.sleep(RESTART_DELAY)
+# Use workspace if available (for local testing), otherwise home directory
+if WORKSPACE_DIR.exists() and (WORKSPACE_DIR / ".openclaw").exists():
+    BASE_DIR = WORKSPACE_DIR / ".openclaw"
+else:
+    BASE_DIR = OPENCLAW_HOME
+
+AGENTS_DIR = BASE_DIR / "agents"
+sys.path.insert(0, str(AGENTS_DIR))
+sys.path.insert(0, str(BASE_DIR))
+
+# Import brain and health monitor
+try:
+    from brain_minimal import get_brain, BrainState
+    BRAIN_AVAILABLE = True
+except ImportError:
+    BRAIN_AVAILABLE = False
+    print("[API] Warning: brain_minimal not available")
+
+try:
+    from health_monitor import get_health_monitor, LogLevel, HealthStatus
+    HEALTH_MONITOR_AVAILABLE = True
+except ImportError:
+    HEALTH_MONITOR_AVAILABLE = False
+    print("[API] Warning: health_monitor not available")
+
+# FastAPI app
+app = FastAPI(
+    title="HuggingClaw-Cain API",
+    description="REST API for Cain agent interactions and monitoring",
+    version="1.0.0"
+)
+
+# ========== Request/Response Models ==========
+
+class ChatMessage(BaseModel):
+    """Chat message model"""
+    message: str = Field(..., description="The message to process")
+    session_id: Optional[str] = Field(None, description="Optional session ID for conversation tracking")
+    context: Optional[Dict[str, Any]] = Field(None, description="Additional context for the conversation")
+
+class AgentStatus(BaseModel):
+    """Agent status response model"""
+    agent_name: str
+    role: str
+    state: str
+    brain_state: str
+    legacy_mode: bool
+    tools_registered: int
+    tools_allowed: int
+    last_action: Optional[str]
+    last_action_time: Optional[str]
+    available_states: List[str]
+    uptime_seconds: Optional[float]
+    timestamp: str
+
+class ChatResponse(BaseModel):
+    """Chat response model"""
+    success: bool
+    response: str
+    agent: str
+    state: str
+    timestamp: str
+    session_id: Optional[str]
+    action_taken: Optional[str]
+
+class HealthResponse(BaseModel):
+    """Health check response model"""
+    status: str
+    stage: str
+    agent: str
+    uptime_seconds: Optional[float]
+    components: Dict[str, Any]
+    timestamp: str
+
+# ========== Global State ==========
+
+_brain_instance = None
+_start_time = datetime.utcnow()
+
+def get_brain_instance():
+    """Get or create brain instance"""
+    global _brain_instance
+    if _brain_instance is None and BRAIN_AVAILABLE:
+        _brain_instance = get_brain()
+    return _brain_instance
+
+def get_health_monitor_instance():
+    """Get health monitor instance"""
+    if not HEALTH_MONITOR_AVAILABLE:
+        return None
+    try:
+        workspace = WORKSPACE_DIR if (WORKSPACE_DIR / ".openclaw").exists() else None
+        return get_health_monitor(workspace_path=workspace)
+    except Exception:
+        return None
+
+# ========== Utility Functions ==========
+
+def get_uptime_seconds() -> float:
+    """Get uptime in seconds"""
+    return (datetime.utcnow() - _start_time).total_seconds()
+
+# ========== API Endpoints ==========
+
+@app.get("/", tags=["Root"])
+async def root():
+    """Root endpoint - API information"""
+    return {
+        "name": "HuggingClaw-Cain API",
+        "version": "1.0.0",
+        "status": "running",
+        "endpoints": {
+            "agents": "/api/agents",
+            "chat": "/api/chat",
+            "health": "/api/health",
+            "tools": "/api/tools",
+            "docs": "/docs"
+        },
+        "gradio_dashboard": "/gradio",
+        "timestamp": datetime.utcnow().isoformat() + "Z"
+    }
+
+@app.get("/api/agents", response_model=AgentStatus, tags=["Agents"])
+async def get_agents_status():
+    """
+    Get current agent status and state information.
+
+    Returns information about Cain's current state, available tools,
+    and last actions performed.
+    """
+    brain = get_brain_instance()
+
+    if brain is None:
+        raise HTTPException(status_code=503, detail="Brain not available")
+
+    try:
+        info = brain.get_info()
+
+        return AgentStatus(
+            agent_name=info.get("agent", "cain"),
+            role=info.get("role", "unknown"),
+            state=info.get("agent_state", "idle"),
+            brain_state=info.get("brain_state", "idle"),
+            legacy_mode=info.get("legacy_mode", False),
+            tools_registered=info.get("tools_registered", 0),
+            tools_allowed=info.get("tools_allowed", 0),
+            last_action=info.get("last_action"),
+            last_action_time=info.get("last_action_time"),
+            available_states=[s.value for s in BrainState],
+            uptime_seconds=get_uptime_seconds(),
+            timestamp=datetime.utcnow().isoformat() + "Z"
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error getting agent status: {str(e)}")
+
+@app.post("/api/chat", response_model=ChatResponse, tags=["Chat"])
+async def chat(message: ChatMessage, background_tasks: BackgroundTasks):
+    """
+    Send a chat message to Cain and get a response.
+
+    Processes the input message through Cain's conversation tool
+    and returns the agent's response with current state.
+    """
+    brain = get_brain_instance()
+
+    if brain is None:
+        raise HTTPException(status_code=503, detail="Brain not available")
+
+    try:
+        # Check if conversation_process tool is available
+        if not brain.can_use_tool("conversation_process"):
+            # Fallback: return a simple echo response
+            response_text = f"Cain received: {message.message}"
+            action_taken = "echo"
+        else:
+            # Execute conversation process tool
+            result = brain.execute_tool("conversation_process", message.message)
+
+            if result.get("success"):
+                response_text = result.get("response", f"Processed: {message.message}")
+                action_taken = "conversation_process"
             else:
-                print(f"ERROR: Failed after {MAX_RESTARTS} attempts. Giving up.", file=sys.stderr)
-                sys.exit(1)
+                response_text = f"Error processing message: {result.get('error', 'Unknown error')}"
+                action_taken = "error"
+
+        return ChatResponse(
+            success=True,
+            response=response_text,
+            agent=brain.agent_name,
+            state=brain.get_state(),
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            session_id=message.session_id,
+            action_taken=action_taken
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing chat: {str(e)}")
 
-        except KeyboardInterrupt:
-            print("\nInterrupted by user.")
-            sys.exit(130)  # Standard exit code for SIGINT
+@app.get("/api/health", response_model=HealthResponse, tags=["Health"])
+async def get_health():
+    """
+    Get system health status.
 
+    Returns overall health status and component-level health checks.
+    """
+    monitor = get_health_monitor_instance()
+    brain = get_brain_instance()
+
+    components = {}
+
+    # Brain component
+    if brain:
+        try:
+            health_result = brain.execute_tool("health_check")
+            components["brain"] = health_result
         except Exception as e:
-            print(f"ERROR: Unexpected error: {e}", file=sys.stderr)
-            if attempt < MAX_RESTARTS - 1:
-                print(f"Retrying in {RESTART_DELAY} seconds...", file=sys.stderr)
-                time.sleep(RESTART_DELAY)
-            else:
-                print(f"ERROR: Failed after {MAX_RESTARTS} attempts. Giving up.", file=sys.stderr)
-                sys.exit(1)
+            components["brain"] = {"status": "error", "error": str(e)}
+    else:
+        components["brain"] = {"status": "unavailable"}
+
+    # Health monitor components
+    if monitor:
+        try:
+            health_results = monitor.run_all_health_checks()
+            components["health_monitor"] = {
+                "overall_status": health_results.get("overall_status"),
+                "check_count": health_results.get("check_count"),
+                "components": {
+                    name: {
+                        "status": result["status"].value if isinstance(result["status"], HealthStatus) else result["status"],
+                        "details": result.get("details", {})
+                    }
+                    for name, result in health_results.get("components", {}).items()
+                }
+            }
+        except Exception as e:
+            components["health_monitor"] = {"status": "error", "error": str(e)}
+
+    # Determine overall status
+    if brain:
+        brain_health = brain.execute_tool("health_check")
+        overall_status = brain_health.get("status", "unknown")
+        stage = brain_health.get("stage", "UNKNOWN")
+        agent = brain_health.get("agent", "cain")
+    else:
+        overall_status = "degraded"
+        stage = "BRAIN_UNAVAILABLE"
+        agent = "cain"
+
+    return HealthResponse(
+        status=overall_status,
+        stage=stage,
+        agent=agent,
+        uptime_seconds=get_uptime_seconds(),
+        components=components,
+        timestamp=datetime.utcnow().isoformat() + "Z"
+    )
+
+@app.get("/api/tools", tags=["Tools"])
+async def list_tools(category: Optional[str] = None):
+    """
+    List available tools for the agent.
+
+    Optionally filter by category (infrastructure, ui, interaction, shared).
+    """
+    brain = get_brain_instance()
+
+    if brain is None:
+        raise HTTPException(status_code=503, detail="Brain not available")
+
+    try:
+        # Get allowed tools
+        allowed_tools = brain.get_allowed_tools()
+
+        tools_info = []
+        for tool_name in allowed_tools:
+            if tool_name in brain.tools:
+                tool = brain.tools[tool_name]
+                tool_dict = tool.to_dict()
+                if category is None or tool_dict["category"] == category:
+                    tools_info.append(tool_dict)
+
+        return {
+            "success": True,
+            "agent": brain.agent_name,
+            "tools_count": len(tools_info),
+            "tools": tools_info,
+            "timestamp": datetime.utcnow().isoformat() + "Z"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error listing tools: {str(e)}")
+
+@app.post("/api/execute/{tool_name}", tags=["Tools"])
+async def execute_tool(tool_name: str, params: Optional[Dict[str, Any]] = None):
+    """
+    Execute a specific tool with optional parameters.
+
+    Requires permission check and state management.
+    """
+    brain = get_brain_instance()
+
+    if brain is None:
+        raise HTTPException(status_code=503, detail="Brain not available")
+
+    if not brain.can_use_tool(tool_name):
+        raise HTTPException(
+            status_code=403,
+            detail=f"Permission denied or tool not found: {tool_name}"
+        )
+
+    try:
+        # Execute tool with params (if provided)
+        if params:
+            result = brain.execute_tool(tool_name, **params)
+        else:
+            result = brain.execute_tool(tool_name)
+
+        return {
+            "success": result.get("success", True),
+            "tool": tool_name,
+            "result": result,
+            "agent": brain.agent_name,
+            "state": brain.get_state(),
+            "timestamp": datetime.utcnow().isoformat() + "Z"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error executing tool: {str(e)}")
+
+@app.get("/api/logs", tags=["Monitoring"])
+async def get_logs(
+    level: Optional[str] = None,
+    component: Optional[str] = None,
+    limit: int = 100
+):
+    """
+    Get recent log entries from the health monitor.
+
+    Can filter by log level (debug, info, warning, error, critical)
+    and component name.
+    """
+    monitor = get_health_monitor_instance()
+
+    if monitor is None:
+        return {
+            "success": False,
+            "error": "Health monitor not available",
+            "logs": []
+        }
+
+    try:
+        log_level = None if level is None or level == "all" else LogLevel(level)
+        log_component = None if component is None or component == "all" else component
+
+        logs = monitor.get_logs(level=log_level, component=log_component, limit=limit)
+
+        formatted_logs = []
+        for log in logs:
+            formatted_logs.append({
+                "timestamp": log["timestamp"],
+                "level": log["level"],
+                "component": log["component"],
+                "message": log["message"],
+                "details": log.get("details", {})
+            })
+
+        return {
+            "success": True,
+            "count": len(formatted_logs),
+            "logs": formatted_logs,
+            "filters": {"level": level, "component": component, "limit": limit},
+            "timestamp": datetime.utcnow().isoformat() + "Z"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error getting logs: {str(e)}")
+
+@app.post("/api/reset", tags=["Administration"])
+async def reset_agent():
+    """
+    Reset the agent state to IDLE.
+
+    Use this to recover from error states.
+    """
+    brain = get_brain_instance()
+
+    if brain is None:
+        raise HTTPException(status_code=503, detail="Brain not available")
+
+    try:
+        from brain_minimal import AgentState
+        brain.transition_to(AgentState.IDLE)
+
+        return {
+            "success": True,
+            "message": "Agent state reset to IDLE",
+            "state": brain.get_state(),
+            "timestamp": datetime.utcnow().isoformat() + "Z"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error resetting agent: {str(e)}")
+
+# ========== Gradio Dashboard Mount ==========
+
+# Mount Gradio dashboard at /gradio route
+# Note: We import and mount it here to integrate with FastAPI
+try:
+    import gradio as gr
+
+    # Import the dashboard creation function
+    sys.path.insert(0, str(Path.home()))
+    from gradio_dashboard import create_dashboard
+
+    # Create the Gradio app
+    gradio_app = create_dashboard()
+
+    # Mount the Gradio app as a sub-app
+    # We use gr.mount_gradio_app which integrates Gradio with FastAPI
+    app = gr.mount_gradio_app(app, gradio_app, path="/gradio")
+
+    print("[API] Gradio dashboard mounted at /gradio")
+except ImportError:
+    print("[API] Warning: Gradio not available, dashboard not mounted")
+except Exception as e:
+    print(f"[API] Warning: Could not mount Gradio dashboard: {e}")
+
+# ========== Main Entry Point ==========
+
+def main():
+    """Main entry point for running the server"""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="FastAPI Backend for HuggingClaw-Cain")
+    parser.add_argument(
+        "--host",
+        default=os.getenv("GRADIO_SERVER_NAME", "0.0.0.0"),
+        help="Host to bind to (default: from GRADIO_SERVER_NAME env or 0.0.0.0)"
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=int(os.getenv("PORT", "7860")),
+        help="Port to bind to (default: from PORT env or 7860)"
+    )
+    parser.add_argument(
+        "--reload",
+        action="store_true",
+        help="Enable auto-reload for development"
+    )
+
+    args = parser.parse_args()
+
+    print(f"[API] Starting FastAPI server on {args.host}:{args.port}")
+    print(f"[API] Dashboard available at http://{args.host}:{args.port}/gradio")
+    print(f"[API] API docs available at http://{args.host}:{args.port}/docs")
+
+    uvicorn.run(
+        "app:app",
+        host=args.host,
+        port=args.port,
+        reload=args.reload
+    )
+
+if __name__ == "__main__":
+    main()

gradio_dashboard.py

@@ -3,7 +3,7 @@
 Cain System Health Dashboard - Gradio Interface
 ================================================
 Provides real-time monitoring of Cain's internal operations including:
-- Agent states from brain_minimal.py
+- Agent states from /api/agents endpoint
 - RBAC system status
 - Cron job execution history
 - Memory usage stats
@@ -17,20 +17,17 @@ import sys
 from pathlib import Path
 from datetime import datetime
 import psutil
+import requests
+
+# ========== Configuration ==========
+
+# API Base URL - internal endpoint
+API_BASE_URL = os.getenv("CAIN_API_URL", "http://127.0.0.1:7860")
 
 # Paths - detect workspace vs home directory
 WORKSPACE_DIR = Path("/tmp/claude-workspace")
 OPENCLAW_HOME = Path.home() / ".openclaw"
 
-# Health monitor integration
-sys.path.insert(0, str(WORKSPACE_DIR / ".openclaw"))
-try:
-    from health_monitor import get_health_monitor, LogLevel, HealthStatus
-    HEALTH_MONITOR_AVAILABLE = True
-except ImportError:
-    HEALTH_MONITOR_AVAILABLE = False
-    print("[Dashboard] Warning: health_monitor not available, using legacy mode")
-
 # Use workspace if available (for local testing), otherwise home directory
 if WORKSPACE_DIR.exists() and (WORKSPACE_DIR / ".openclaw").exists():
     BASE_DIR = WORKSPACE_DIR / ".openclaw"
@@ -41,48 +38,133 @@ CRON_LOGS_DIR = BASE_DIR / "logs"
 CRON_JOBS_FILE = BASE_DIR / "cron" / "jobs.json"
 MEMORY_STATE_FILE = Path("/data/memory/state.json")
 WORKSPACE_LOGS = BASE_DIR / "workspace"
-AGENTS_DIR = BASE_DIR / "agents"
 
 
-def get_agent_states():
-    """Get current agent states from brain_minimal.py"""
+# ========== API Client Functions ==========
+
+def fetch_api(endpoint: str, method: str = "GET", data: dict = None) -> dict:
+    """
+    Fetch data from the internal API endpoint.
+
+    Args:
+        endpoint: API endpoint path (e.g., "/api/agents")
+        method: HTTP method (GET, POST)
+        data: Request body for POST requests
+
+    Returns:
+        JSON response as dict
+    """
+    url = f"{API_BASE_URL}{endpoint}"
+
     try:
-        # Try to import the brain module
-        import sys
-        sys.path.insert(0, str(AGENTS_DIR))
-        from brain_minimal import get_brain, BrainState
+        if method == "GET":
+            response = requests.get(url, timeout=5)
+        elif method == "POST":
+            response = requests.post(url, json=data, timeout=30)
+        else:
+            return {"error": f"Unsupported method: {method}"}
+
+        response.raise_for_status()
+        return response.json()
+    except requests.exceptions.RequestException as e:
+        return {"error": f"API request failed: {str(e)}"}
+    except json.JSONDecodeError:
+        return {"error": "Invalid JSON response"}
+
+
+# ========== Dashboard Functions (API-based) ==========
 
-        brain = get_brain()
-        info = brain.get_info()
+def get_agent_states():
+    """Get current agent states from /api/agents endpoint"""
+    try:
+        data = fetch_api("/api/agents")
+
+        if "error" in data:
+            return {
+                "agent_name": "cain",
+                "role": "interaction",
+                "state": "idle",
+                "error": data["error"],
+                "available_states": ["idle", "processing", "success", "error"],
+                "base_dir": str(BASE_DIR),
+                "api_error": True
+            }
 
-        # Format as a clean dict for display
+        # Return the data from API
         return {
-            "agent_name": info.get("agent", "cain"),
-            "role": info.get("role", "unknown"),
-            "state": info.get("state", "idle"),
-            "legacy_mode": info.get("legacy_mode", False),
-            "tools_registered": info.get("tools_registered", 0),
-            "tools_allowed": info.get("tools_allowed", 0),
-            "last_action": info.get("last_action", "N/A"),
-            "last_action_time": info.get("last_action_time", "N/A"),
-            "available_states": [s.value for s in BrainState],
-            "base_dir": str(BASE_DIR),
-            "agents_dir": str(AGENTS_DIR)
+            "agent_name": data.get("agent_name", "cain"),
+            "role": data.get("role", "unknown"),
+            "state": data.get("state", "idle"),
+            "brain_state": data.get("brain_state", "idle"),
+            "legacy_mode": data.get("legacy_mode", False),
+            "tools_registered": data.get("tools_registered", 0),
+            "tools_allowed": data.get("tools_allowed", 0),
+            "last_action": data.get("last_action", "N/A"),
+            "last_action_time": data.get("last_action_time", "N/A"),
+            "available_states": data.get("available_states", []),
+            "uptime_seconds": data.get("uptime_seconds"),
+            "timestamp": data.get("timestamp"),
+            "base_dir": str(BASE_DIR)
         }
     except Exception as e:
         return {
             "agent_name": "cain",
             "role": "interaction",
             "state": "idle",
-            "error": f"Could not load brain: {str(e)}",
-            "available_states": ["idle", "thinking", "executing", "waiting", "error"],
+            "error": f"Could not fetch agent states: {str(e)}",
+            "available_states": ["idle", "processing", "success", "error"],
             "base_dir": str(BASE_DIR),
-            "agents_dir": str(AGENTS_DIR)
+            "api_error": True
         }
 
 
+def get_system_health():
+    """Get system health from /api/health endpoint"""
+    try:
+        data = fetch_api("/api/health")
+
+        if "error" in data:
+            return {
+                "monitor_available": False,
+                "error": data["error"]
+            }
+
+        return data
+    except Exception as e:
+        return {
+            "monitor_available": False,
+            "error": f"Could not fetch health data: {str(e)}"
+        }
+
+
+def chat_with_agent(message: str, session_id: str = ""):
+    """Send a chat message to the agent via /api/chat endpoint"""
+    try:
+        payload = {
+            "message": message
+        }
+        if session_id:
+            payload["session_id"] = session_id
+
+        data = fetch_api("/api/chat", method="POST", data=payload)
+
+        if "error" in data:
+            return f"Error: {data['error']}"
+
+        if data.get("success"):
+            response = data.get("response", "")
+            metadata = f"\n\n[Agent: {data.get('agent', 'cain')} | State: {data.get('state', 'unknown')}]"
+            return response + metadata
+        else:
+            return f"Error: {data.get('response', 'Unknown error')}"
+    except Exception as e:
+        return f"Error sending message: {str(e)}"
+
+
+# ========== Legacy Functions (Fallback) ==========
+
 def get_cron_history():
-    """Get recent cron job execution history"""
+    """Get recent cron job execution history (legacy, file-based)"""
     history = []
 
     # Read jobs configuration
@@ -153,7 +235,7 @@ def get_cron_history():
 
 
 def get_memory_stats():
-    """Get memory usage statistics"""
+    """Get memory usage statistics (legacy, system-based)"""
     stats = {
         "system_memory": {},
         "disk_usage": {},
@@ -216,7 +298,63 @@ def get_memory_stats():
     return stats
 
 
-# Custom CSS for the dashboard
+# ========== API-based Log Functions ==========
+
+def get_health_logs(level: str = "all", component: str = "all", limit: int = 100):
+    """Get recent log entries from health monitor via API"""
+    try:
+        params = []
+        if level and level != "all":
+            params.append(f"level={level}")
+        if component and component != "all":
+            params.append(f"component={component}")
+        params.append(f"limit={limit}")
+
+        endpoint = f"/api/logs?{'&'.join(params)}"
+        data = fetch_api(endpoint)
+
+        if "error" in data:
+            return []
+        if not data.get("success"):
+            return []
+
+        return data.get("logs", [])
+    except Exception as e:
+        return [{"error": str(e)}]
+
+
+# ========== Formatting Functions ==========
+
+def format_agent_states(states):
+    """Format agent states for JSON display"""
+    return json.dumps(states, indent=2)
+
+
+def format_cron_history(history):
+    """Format cron history for table display"""
+    if not history:
+        return []
+
+    table_data = []
+    for entry in history:
+        table_data.append([
+            entry.get("job_id", "N/A"),
+            entry.get("description", "")[:30],
+            entry.get("timestamp", "N/A"),
+            entry.get("action", "N/A"),
+            entry.get("status", "N/A"),
+            "✓" if entry.get("success", True) else "✗"
+        ])
+    return table_data
+
+
+def format_memory_stats(stats):
+    """Format memory stats for JSON display"""
+    return json.dumps(stats, indent=2)
+
+
+# ========== Custom CSS ==========
+
 CUSTOM_CSS = """
 .status-box {
     padding: 10px;
@@ -243,200 +381,123 @@ CUSTOM_CSS = """
 """
 
 
-# ========== Health Monitor Integration ==========
-
-def get_health_monitor_instance():
-    """Get or create health monitor instance"""
-    if not HEALTH_MONITOR_AVAILABLE:
-        return None
-
-    try:
-        workspace = WORKSPACE_DIR if (WORKSPACE_DIR / ".openclaw").exists() else None
-        return get_health_monitor(workspace_path=workspace)
-    except Exception as e:
-        print(f"[Dashboard] Error getting health monitor: {e}")
-        return None
+# ========== Refresh Functions ==========
 
+def refresh_all():
+    """Refresh all dashboard data using API endpoints"""
+    states = get_agent_states()
+    history = get_cron_history()
+    stats = get_memory_stats()
 
-def get_component_health():
-    """Get health status for all components using the health monitor"""
-    monitor = get_health_monitor_instance()
-
-    if monitor is None:
-        # Fallback to legacy mode
-        return {
-            "monitor_available": False,
-            "components": {
-                "brain": get_agent_states(),
-                "memory": get_memory_stats(),
-                "cron": {"history": get_cron_history()}
-            }
-        }
-
-    try:
-        # Run health checks
-        health_results = monitor.run_all_health_checks()
-        status_report = monitor.get_status_report(include_logs=False)
-
-        return {
-            "monitor_available": True,
-            "overall_status": health_results["overall_status"],
-            "uptime_seconds": health_results["uptime_seconds"],
-            "check_count": health_results["check_count"],
-            "last_check": health_results["timestamp"],
-            "components": {
-                name: {
-                    "status": result["status"].value if isinstance(result["status"], HealthStatus) else result["status"],
-                    "details": result.get("details", {})
-                }
-                for name, result in health_results["components"].items()
-            }
-        }
-    except Exception as e:
-        return {
-            "monitor_available": True,
-            "error": str(e),
-            "components": {}
-        }
-
-
-def get_health_logs(level: str = "all", component: str = "all", limit: int = 100):
-    """Get recent log entries from health monitor"""
-    monitor = get_health_monitor_instance()
-
-    if monitor is None:
-        # Return empty if monitor not available
-        return []
-
-    try:
-        log_level = None if level == "all" else LogLevel(level)
-        log_component = None if component == "all" else component
-
-        logs = monitor.get_logs(level=log_level, component=log_component, limit=limit)
-
-        # Format for display
-        formatted = []
-        for log in logs:
-            formatted.append({
-                "timestamp": log["timestamp"],
-                "level": log["level"],
-                "component": log["component"],
-                "message": log["message"],
-                "details": json.dumps(log.get("details", {}), indent=2)[:200]
-            })
-
-        return formatted
-    except Exception as e:
-        return [{"error": str(e)}]
-
-
-def get_health_metrics_summary():
-    """Get summary of health metrics"""
-    monitor = get_health_monitor_instance()
-
-    if monitor is None:
-        return {}
-
-    try:
-        metrics = {}
-
-        # Get overall health metric
-        overall = monitor.get_metrics("overall_health", limit=1)
-        if overall:
-            metrics["overall"] = overall[0]
+    return (
+        format_agent_states(states),
+        format_cron_history(history),
+        format_memory_stats(stats),
+        f"Last updated: {datetime.utcnow().isoformat()}Z"
+    )
 
-        return metrics
-    except Exception as e:
-        return {"error": str(e)}
 
+def refresh_system_health(log_level="all", log_component="all"):
+    """Refresh system health data using API endpoints"""
+    # Get health data
+    health_data = get_system_health()
+
+    # Get logs
+    logs = get_health_logs(level=log_level, component=log_component, limit=100)
+
+    # Format for display
+    health_json = json.dumps(health_data, indent=2, default=str)
+
+    # Format logs for table
+    log_rows = [
+        [l.get("timestamp", ""), l.get("level", ""), l.get("component", ""),
+         l.get("message", ""), json.dumps(l.get("details", {}), indent=2)[:200]]
+        for l in logs[:100]
+    ]
+
+    # Generate status report
+    if "error" in health_data:
+        report = f"Error: {health_data['error']}"
+    elif health_data.get("monitor_available"):
+        status = health_data.get("status", "unknown")
+        stage = health_data.get("stage", "UNKNOWN")
+        uptime = health_data.get("uptime_seconds", 0)
+        report = f"Status: {status}\nStage: {stage}\nUptime: {uptime:.0f}s\n"
+        report += f"Components: {len(health_data.get('components', {}))} monitored"
+    else:
+        report = "Health monitor not available"
 
-def generate_status_report():
-    """Generate a text status report"""
-    monitor = get_health_monitor_instance()
+    timestamp = f"Last updated: {datetime.utcnow().isoformat()}Z"
 
-    if monitor is None:
-        return "Health monitor not available. Please check the installation."
+    return health_json, log_rows, report, timestamp
 
-    try:
-        return monitor.get_summary_report()
-    except Exception as e:
-        return f"Error generating report: {e}"
 
+# ========== Chat Interface ==========
 
-def run_health_check_and_refresh():
-    """Run health checks and return updated data for dashboard"""
-    monitor = get_health_monitor_instance()
+def create_chat_interface():
+    """Create the chat interface component"""
+    with gr.Column() as chat_col:
+        gr.Markdown("### 💬 Chat with Cain")
 
-    if monitor is None:
-        return (
-            json.dumps({"error": "Health monitor not available"}, indent=2),
-            [],
-            "Health monitor not available",
-            f"Last updated: {datetime.utcnow().isoformat()}Z"
+        chatbot = gr.Chatbot(
+            label="Conversation",
+            height=300,
+            show_copy_button=True
         )
 
-    try:
-        # Run health checks
-        health_data = get_component_health()
-        logs = get_health_logs(limit=50)
-        report = generate_status_report()
-
-        return (
-            json.dumps(health_data, indent=2, default=str),
-            logs,
-            report,
-            f"Last updated: {datetime.utcnow().isoformat()}Z"
-        )
-    except Exception as e:
-        return (
-            json.dumps({"error": str(e)}, indent=2),
-            [],
-            f"Error: {e}",
-            f"Last updated: {datetime.utcnow().isoformat()}Z"
+        with gr.Row():
+            chat_input = gr.Textbox(
+                label="Message",
+                placeholder="Type a message to Cain...",
+                scale=4,
+                lines=1
+            )
+            send_btn = gr.Button("Send", variant="primary", scale=1)
+
+        session_id = gr.Textbox(
+            label="Session ID (optional)",
+            placeholder="Leave empty for new session"
         )
 
+        gr.Markdown("""
+        **Instructions:**
+        - Type a message and click Send to chat with Cain
+        - Cain will process your message and respond
+        - Use a Session ID to continue a previous conversation
+        """)
 
-def format_agent_states(states):
-    """Format agent states for JSON display"""
-    return json.dumps(states, indent=2)
+        def handle_send(message, session, history):
+            """Handle sending a chat message"""
+            if not message.strip():
+                return history, message, session
 
+            # Add user message to history
+            history = history + [[message, None]]
 
-def format_cron_history(history):
-    """Format cron history for table display"""
-    if not history:
-        return []
+            # Get response from API
+            response = chat_with_agent(message, session)
 
-    table_data = []
-    for entry in history:
-        table_data.append([
-            entry.get("job_id", "N/A"),
-            entry.get("description", "")[:30],
-            entry.get("timestamp", "N/A"),
-            entry.get("action", "N/A"),
-            entry.get("status", "N/A"),
-            "✓" if entry.get("success", True) else "✗"
-        ])
-    return table_data
+            # Update history with response
+            history[-1][1] = response
 
+            return history, "", session
 
-def format_memory_stats(stats):
-    """Format memory stats for JSON display"""
-    return json.dumps(stats, indent=2)
+        send_btn.click(
+            fn=handle_send,
+            inputs=[chat_input, session_id, chatbot],
+            outputs=[chatbot, chat_input, session_id]
+        )
 
+        chat_input.submit(
+            fn=handle_send,
+            inputs=[chat_input, session_id, chatbot],
+            outputs=[chatbot, chat_input, session_id]
+        )
 
-def refresh_all():
-    """Refresh all dashboard data"""
-    states = get_agent_states()
-    history = get_cron_history()
-    stats = get_memory_stats()
+    return chat_col
 
-    return (
-        format_agent_states(states),
-        format_cron_history(history),
-        format_memory_stats(stats),
-        f"Last updated: {datetime.utcnow().isoformat()}Z"
-    )
 
+# ========== Dashboard Creation ==========
 
 def create_dashboard():
     """Create the Gradio dashboard interface"""
@@ -445,9 +506,14 @@ def create_dashboard():
 
         gr.Markdown("# 🐱 Cain System Health Dashboard")
         gr.Markdown("Real-time monitoring of HuggingClaw-Cain's internal operations")
+        gr.Markdown(f"**API Endpoint:** `{API_BASE_URL}`")
 
         with gr.Tabs():
-            # System Health Tab (NEW)
+            # Chat Tab (NEW)
+            with gr.Tab("💬 Chat"):
+                create_chat_interface()
+
+            # System Health Tab
             with gr.Tab("🏥 System Health"):
                 gr.Markdown("### Component Health Overview")
 
@@ -511,9 +577,8 @@ def create_dashboard():
                 gr.Markdown("""
                 **State Descriptions:**
                 - **idle**: Agent is ready and waiting
-                - **thinking**: Agent is processing a decision
-                - **executing**: Agent is running a tool/action
-                - **waiting**: Agent is waiting for external response
+                - **processing**: Agent is actively processing a task
+                - **success**: Agent completed a task successfully
                 - **error**: Agent encountered an error
                 """)
 
@@ -598,32 +663,6 @@ def create_dashboard():
         )
 
         # Refresh for System Health tab
-        def refresh_system_health(log_level="all", log_component="all"):
-            health_data, logs, report, timestamp = run_health_check_and_refresh()
-
-            # Filter logs
-            filtered_logs = logs
-            if log_level != "all":
-                filtered_logs = [l for l in logs if l.get("level") == log_level]
-            if log_component != "all":
-                filtered_logs = [l for l in filtered_logs if l.get("component") == log_component]
-
-            log_rows = [
-                [l.get("timestamp", ""), l.get("level", ""), l.get("component", ""),
-                 l.get("message", ""), l.get("details", "")]
-                for l in filtered_logs[:100]
-            ]
-
-            return health_data, log_rows, report, timestamp
-
-        # Auto-load system health data on tab load
-        app.load(
-            fn=lambda: refresh_system_health(),
-            inputs=[],
-            outputs=[health_json, logs_table, health_report, last_updated]
-        )
-
-        # Manual refresh for system health
         system_health_refresh_btn = gr.Button("🏥 Refresh Health", visible=False)
         system_health_refresh_btn.click(
             fn=refresh_system_health,
@@ -631,7 +670,7 @@ def create_dashboard():
             outputs=[health_json, logs_table, health_report, last_updated]
         )
 
-        # Log filter change handler
+        # Log filter change handlers
         log_level_filter.change(
             fn=refresh_system_health,
             inputs=[log_level_filter, log_component_filter],
@@ -654,11 +693,16 @@ def create_dashboard():
 
 
 if __name__ == "__main__":
-    # Create and launch the dashboard
+    # Create and launch the dashboard (standalone mode, not mounted)
     dashboard = create_dashboard()
+
+    # Get environment variables with fallbacks
+    server_name = os.getenv("GRADIO_SERVER_NAME", "0.0.0.0")
+    server_port = int(os.getenv("PORT", "7861"))  # Default to 7861 for standalone
+
     dashboard.launch(
-        server_name="0.0.0.0",
-        server_port=7861,  # Different port from main OpenClaw (7860)
+        server_name=server_name,
+        server_port=server_port,
         share=False,
         theme=gr.themes.Soft(primary_hue="blue"),
         css=CUSTOM_CSS

requirements.txt

@@ -1 +1,4 @@
 huggingface_hub>=0.24.5 # Force rebuild 2026-02-11
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+requests>=2.31.0

scripts/entrypoint.sh

@@ -66,12 +66,15 @@ if [ -f /app/openclaw/.version ]; then
   echo "[entrypoint] OpenClaw version: $OPENCLAW_VERSION"
 fi
 
-# ── Start Gradio Dashboard (port 7861, background) ──────────────────────────
-echo "[entrypoint] Starting Gradio System Dashboard on port 7861..."
-python3 /home/node/gradio_dashboard.py > /home/node/logs/gradio-dashboard.log 2>&1 &
-GRADIO_PID=$!
-echo "[entrypoint] Gradio Dashboard PID: $GRADIO_PID"
-
-# ── Start OpenClaw via sync_hf.py (directly on port 7860, no proxy) ───────
-echo "[entrypoint] Starting OpenClaw via sync_hf.py..."
-exec python3 -u /home/node/scripts/sync_hf.py
+# ── Start FastAPI Backend with Gradio Dashboard (port 7860) ──────────────────
+echo "[entrypoint] Starting FastAPI Backend with Gradio Dashboard on port 7860..."
+echo "[entrypoint] Environment: GRADIO_SERVER_NAME=${GRADIO_SERVER_NAME:-0.0.0.0} PORT=${PORT:-7860}"
+
+# Set default environment variables if not already set
+export GRADIO_SERVER_NAME=${GRADIO_SERVER_NAME:-0.0.0.0}
+export PORT=${PORT:-7860}
+export CAIN_API_URL="http://127.0.0.1:${PORT}"
+
+# Start the FastAPI app which includes the mounted Gradio dashboard
+# The app.py now runs the FastAPI server with /gradio endpoint for the dashboard
+exec python3 -u /home/node/app.py