Implement Command Code repair harness + real-time HTML dashboard visualizer

backend.py

@@ -20,16 +20,31 @@ import uuid
 import subprocess
 import asyncio
 import time
+import re
+import collections
 from pathlib import Path
 from typing import AsyncIterator, Optional
 
 from fastapi import FastAPI, Request, Header, HTTPException
-from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.responses import StreamingResponse, JSONResponse, HTMLResponse
 from fastapi.middleware.cors import CORSMiddleware
 from openai import AsyncOpenAI
 import anyio
 import asyncpg
 
+# ---------------------------------------------------------------------------
+# Globals & Activity Logs
+# ---------------------------------------------------------------------------
+activity_logs = collections.deque(maxlen=100)
+MODEL_STATUSES = {}
+ACTIVE_SESSIONS = set()
+
+def log_activity(msg: str):
+    timestamp = time.strftime("%H:%M:%S")
+    log_line = f"[{timestamp}] {msg}"
+    activity_logs.append(log_line)
+    print(log_line)
+
 # ---------------------------------------------------------------------------
 # Configuration
 # ---------------------------------------------------------------------------
@@ -190,6 +205,47 @@ def _safe_path(rel_path: str) -> Path:
     return target
 
 
+def repair_arguments(func_name: str, args: dict) -> tuple[dict, list[str]]:
+    notes = []
+    repaired_args = dict(args)
+    
+    # 1. Nesting extraction (e.g. {"path": {"path": "file.txt"}})
+    for key in list(repaired_args.keys()):
+        val = repaired_args[key]
+        if isinstance(val, dict) and key in val:
+            repaired_args[key] = val[key]
+            notes.append(f"Flattened nested parameter '{key}'")
+            
+    # 2. Markdown stripping from bash command
+    if func_name == "run_bash" and "command" in repaired_args:
+        cmd = repaired_args["command"]
+        if isinstance(cmd, str):
+            pattern = r"```(?:bash)?\s*(.*?)\s*```"
+            match = re.search(pattern, cmd, re.DOTALL)
+            if match:
+                repaired_args["command"] = match.group(1).strip()
+                notes.append("Stripped markdown code blocks from bash command")
+                
+    # 3. Stringified array conversion
+    for key, val in repaired_args.items():
+        if isinstance(val, str) and val.strip().startswith("[") and val.strip().endswith("]"):
+            try:
+                parsed_arr = json.loads(val)
+                if isinstance(parsed_arr, list):
+                    repaired_args[key] = parsed_arr
+                    notes.append(f"Converted stringified array for parameter '{key}' to native array")
+            except:
+                pass
+                
+    # 4. Optional empty objects replacing Null
+    for key in list(repaired_args.keys()):
+        if repaired_args[key] == {}:
+            repaired_args[key] = None
+            notes.append(f"Replaced empty object for parameter '{key}' with null")
+            
+    return repaired_args, notes
+
+
 def execute_tool(name: str, arguments: dict) -> str:
     """Execute a tool and return its output as a string."""
     try:
@@ -428,7 +484,7 @@ async def check_models_health():
     best_model = None
     best_latency = 999.0
     
-    print("[Health Check] Starting periodic model verification...")
+    log_activity("Periodic health check started: verifying 10 NIM models...")
     for model in models_to_test:
         start_time = time.time()
         try:
@@ -440,7 +496,8 @@ async def check_models_health():
                     max_tokens=3,
                 )
             latency = time.time() - start_time
-            print(f"[Health Check] Model {model} is ONLINE. Latency: {latency:.2f}s")
+            MODEL_STATUSES[model] = {"status": "ONLINE", "latency": f"{latency:.2f}s", "raw_latency": latency}
+            log_activity(f"Model checked: {model} is ONLINE ({latency:.2f}s)")
             
             # We want the model that is within 15 seconds
             # and is the fastest (lowest latency)
@@ -449,33 +506,35 @@ async def check_models_health():
                 best_model = model
                 
         except Exception as e:
-            print(f"[Health Check] Model {model} is OFFLINE or TIMEOUT: {e}")
+            MODEL_STATUSES[model] = {"status": "OFFLINE", "latency": "N/A", "raw_latency": 999.0}
+            log_activity(f"Model checked: {model} is OFFLINE / TIMEOUT: {e}")
             
     if best_model:
         RECOMMENDED_MODEL = best_model
-        print(f"[Health Check] Best model found: {RECOMMENDED_MODEL} ({best_latency:.2f}s)")
+        log_activity(f"Best model selected: {RECOMMENDED_MODEL} ({best_latency:.2f}s)")
     else:
-        print("[Health Check] Warning: All checked models failed or timed out!")
+        log_activity("Warning: All checked models failed or timed out!")
 
 async def periodic_health_check_loop():
-    # Wait 30 seconds after startup before the first check to let the space boot fully
-    await asyncio.sleep(30)
+    # Wait 10 seconds after startup before the first check to let the space boot fully
+    await asyncio.sleep(10)
     while True:
         try:
             await check_models_health()
         except Exception as e:
-            print(f"[Health Check] Loop error: {e}")
+            log_activity(f"Health check loop error: {e}")
         await asyncio.sleep(300) # every 5 minutes
 
 @app.on_event("startup")
 async def startup():
     await init_db()
     Path(WORKSPACE_DIR).mkdir(parents=True, exist_ok=True)
+    # Initialize statuses for all models
+    for model_id, display_name in ALL_MODELS.items():
+        MODEL_STATUSES[model_id] = {"status": "UNCHECKED", "latency": "N/A", "raw_latency": 999.0}
     # Start background health checking
     asyncio.create_task(periodic_health_check_loop())
-    print(f"[Backend] Started. Workspace: {WORKSPACE_DIR}")
-    print(f"[Backend] Tool-capable models: {list(TOOL_CAPABLE_MODELS.keys())}")
-    print(f"[Backend] DB connected: {db_pool is not None}")
+    log_activity(f"FastAPI backend started. Workspace: {WORKSPACE_DIR}")
 
 
 # ---------------------------------------------------------------------------
@@ -512,6 +571,9 @@ async def chat_completions(request: Request, authorization: str = Header(None)):
     is_agentic = requested_model in TOOL_CAPABLE_MODELS
     request_id = str(uuid.uuid4())[:8]
 
+    ACTIVE_SESSIONS.add(session_id)
+    log_activity(f"Session [{session_id[:6]}] connected. Model: {requested_model}")
+
     # Build message history
     final_messages = []
     
@@ -550,6 +612,8 @@ async def chat_completions(request: Request, authorization: str = Header(None)):
             response = await nim_client.chat.completions.create(**kwargs)
             content = response.choices[0].message.content or ""
             await save_message(session_id, "assistant", content)
+            ACTIVE_SESSIONS.discard(session_id)
+            log_activity(f"Session [{session_id[:6]}] finished (non-streaming)")
             return JSONResponse({
                 "id": f"chatcmpl-{request_id}",
                 "object": "chat.completion",
@@ -558,6 +622,7 @@ async def chat_completions(request: Request, authorization: str = Header(None)):
                 "choices": [{"index": 0, "message": {"role": "assistant", "content": content}, "finish_reason": "stop"}],
             })
         except Exception as e:
+            ACTIVE_SESSIONS.discard(session_id)
             return JSONResponse({"error": {"message": str(e), "type": "internal_error"}}, status_code=500)
 
     # Streaming + agentic loop
@@ -632,28 +697,55 @@ async def chat_completions(request: Request, authorization: str = Header(None)):
                 # Execute each tool and add results
                 for tc in tool_calls_list:
                     func_name = tc["function"]["name"]
+                    raw_args_str = tc["function"]["arguments"]
                     try:
-                        func_args = json.loads(tc["function"]["arguments"])
+                        func_args = json.loads(raw_args_str)
                     except json.JSONDecodeError:
-                        func_args = {}
+                        # Attempt raw JSON repair
+                        repaired_str = raw_args_str.strip()
+                        if not repaired_str.startswith("{"):
+                            repaired_str = "{" + repaired_str
+                        if not repaired_str.endswith("}"):
+                            repaired_str = repaired_str + "}"
+                        try:
+                            func_args = json.loads(repaired_str)
+                            log_activity(f"Auto-fixed invalid JSON string for tool: {func_name}")
+                        except:
+                            func_args = {}
+
+                    # Perform semantic repairs
+                    repaired_args, repair_notes = repair_arguments(func_name, func_args)
                     
+                    # Log activity
+                    log_activity(f"Tool execution: {func_name} args={repaired_args}")
+                    if repair_notes:
+                        for note in repair_notes:
+                            log_activity(f"[Tool Repair] {note}")
+
                     # Show tool execution to user
                     yield make_chunk(request_id, requested_model, f"\n\n🔧 **{func_name}**")
-                    if func_name == "run_bash" and "command" in func_args:
-                        yield make_chunk(request_id, requested_model, f": `{func_args['command']}`\n")
-                    elif func_name == "read_file" and "path" in func_args:
-                        yield make_chunk(request_id, requested_model, f": `{func_args['path']}`\n")
-                    elif func_name == "write_file" and "path" in func_args:
-                        yield make_chunk(request_id, requested_model, f": `{func_args['path']}`\n")
+                    if repair_notes:
+                        yield make_chunk(request_id, requested_model, " *(Auto-Repaired)*")
+                    
+                    if func_name == "run_bash" and "command" in repaired_args:
+                        yield make_chunk(request_id, requested_model, f": `{repaired_args['command']}`\n")
+                    elif func_name == "read_file" and "path" in repaired_args:
+                        yield make_chunk(request_id, requested_model, f": `{repaired_args['path']}`\n")
+                    elif func_name == "write_file" and "path" in repaired_args:
+                        yield make_chunk(request_id, requested_model, f": `{repaired_args['path']}`\n")
                     elif func_name == "list_directory":
-                        yield make_chunk(request_id, requested_model, f": `{func_args.get('path', '.')}`\n")
+                        yield make_chunk(request_id, requested_model, f": `{repaired_args.get('path', '.')}`\n")
                     elif func_name == "grep_search":
-                        yield make_chunk(request_id, requested_model, f": `{func_args.get('pattern', '')}`\n")
+                        yield make_chunk(request_id, requested_model, f": `{repaired_args.get('pattern', '')}`\n")
                     else:
                         yield make_chunk(request_id, requested_model, "\n")
 
                     # Execute the tool
-                    result = execute_tool(func_name, func_args)
+                    result = execute_tool(func_name, repaired_args)
+
+                    # Append teaching note if repaired
+                    if repair_notes:
+                        result += f"\n\n[SYSTEM REPAIR NOTE: The harness automatically fixed formatting issues: {', '.join(repair_notes)}. Please strictly follow the tool's JSON schema in subsequent calls without these wrapping/formatting errors.]"
 
                     # Show truncated result to user
                     preview = result[:500] + ("..." if len(result) > 500 else "")
@@ -717,6 +809,193 @@ async def list_models(authorization: str = Header(None)):
 # /health — Health check
 # ---------------------------------------------------------------------------
 
+# ---------------------------------------------------------------------------
+# Dashboard and Status API
+# ---------------------------------------------------------------------------
+
+DASHBOARD_HTML = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Claude Code Agent Console</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        @import url('https://fonts.googleapis.com/css2?family=Fira+Code:wght@400;500;700&family=Outfit:wght@400;600;800&display=swap');
+        body {
+            font-family: 'Outfit', sans-serif;
+            background-color: #0b0c10;
+        }
+        .code-font {
+            font-family: 'Fira Code', monospace;
+        }
+        .glow-amber {
+            box-shadow: 0 0 15px rgba(245, 158, 11, 0.2);
+        }
+    </style>
+</head>
+<body class="text-gray-100 min-h-screen flex flex-col pb-10">
+    <header class="border-b border-gray-800 bg-gray-950/80 backdrop-blur px-6 py-4 flex items-center justify-between sticky top-0 z-50">
+        <div class="flex items-center space-x-3">
+            <span class="text-2xl font-extrabold tracking-tight bg-gradient-to-r from-blue-400 via-indigo-400 to-purple-400 bg-clip-text text-transparent">
+                Claude Code Agent Console
+            </span>
+            <span class="px-2 py-0.5 text-xs rounded bg-blue-500/10 text-blue-400 border border-blue-500/20 font-semibold animate-pulse">
+                LIVE
+            </span>
+        </div>
+        <div class="flex items-center space-x-4 text-sm text-gray-400">
+            <div>Workspace: <span class="text-gray-200 code-font">/tmp/workspace</span></div>
+            <div class="h-4 w-px bg-gray-800"></div>
+            <div>Active Sessions: <span id="active-sessions-count" class="text-blue-400 font-bold code-font">0</span></div>
+        </div>
+    </header>
+
+    <main class="max-w-7xl w-full mx-auto px-6 mt-8 flex-1 grid grid-cols-1 lg:grid-cols-3 gap-8">
+        <!-- Left: Models Grid -->
+        <div class="lg:col-span-2 space-y-6">
+            <div class="flex items-center justify-between">
+                <h2 class="text-lg font-bold tracking-tight text-gray-300">Nvidia NIM Models & Health Status</h2>
+                <span class="text-xs text-gray-500">Checked every 5 mins</span>
+            </div>
+            
+            <div id="models-container" class="grid grid-cols-1 md:grid-cols-2 gap-4">
+                <!-- Dynamically loaded models go here -->
+            </div>
+        </div>
+
+        <!-- Right: Log Viewer -->
+        <div class="space-y-6 flex flex-col h-full">
+            <h2 class="text-lg font-bold tracking-tight text-gray-300">System Activity Logs</h2>
+            
+            <div class="border border-gray-800 rounded-lg overflow-hidden bg-gray-950 flex flex-col flex-1 min-h-[400px]">
+                <div class="bg-gray-900 px-4 py-2 border-b border-gray-800 flex items-center justify-between">
+                    <span class="text-xs text-gray-400 font-semibold code-font">agent-stdout.log</span>
+                    <div class="flex space-x-1.5">
+                        <span class="w-2.5 h-2.5 rounded-full bg-red-500/30"></span>
+                        <span class="w-2.5 h-2.5 rounded-full bg-yellow-500/30"></span>
+                        <span class="w-2.5 h-2.5 rounded-full bg-green-500/30"></span>
+                    </div>
+                </div>
+                <div id="terminal-content" class="p-4 flex-1 overflow-y-auto code-font text-xs text-green-400 bg-black/90 space-y-1 select-all">
+                    <!-- Logs go here -->
+                </div>
+            </div>
+        </div>
+    </main>
+
+    <script>
+        async function fetchSystemData() {
+            try {
+                const res = await fetch('/health');
+                if (!res.ok) return;
+                const data = await res.json();
+                document.getElementById('active-sessions-count').innerText = data.active_sessions || 0;
+            } catch (e) {
+                console.error(e);
+            }
+        }
+
+        async function fetchModels() {
+            try {
+                const res = await fetch('/api/models-status');
+                if (!res.ok) return;
+                const models = await res.json();
+                
+                const container = document.getElementById('models-container');
+                container.innerHTML = '';
+                
+                models.forEach(model => {
+                    const isRec = model.is_recommended;
+                    const isOnline = model.status === 'ONLINE';
+                    
+                    const card = document.createElement('div');
+                    card.className = `p-4 border rounded-xl bg-gray-950 transition-all ${
+                        isRec ? 'border-amber-500/50 glow-amber bg-amber-500/5' : 'border-gray-800 bg-gray-950'
+                    }`;
+                    
+                    card.innerHTML = `
+                        <div class="flex items-center justify-between mb-3">
+                            <span class="text-xs text-gray-500 code-font truncate max-w-[200px]" title="${model.id}">${model.id}</span>
+                            <div class="flex items-center space-x-2">
+                                ${isRec ? '<span class="text-[10px] px-1.5 py-0.5 rounded bg-amber-500/10 text-amber-400 border border-amber-500/20 font-bold">★ Recommended</span>' : ''}
+                                <span class="h-2 w-2 rounded-full ${isOnline ? 'bg-green-500 animate-pulse' : 'bg-red-500'}"></span>
+                                <span class="text-[10px] font-bold ${isOnline ? 'text-green-400' : 'text-red-400'}">${model.status}</span>
+                            </div>
+                        </div>
+                        <h3 class="text-sm font-bold text-gray-200 mb-2 truncate">${model.name}</h3>
+                        <div class="flex items-center justify-between text-xs text-gray-400 border-t border-gray-900 pt-2">
+                            <span>Type: <strong class="text-gray-300 font-medium">${model.type}</strong></span>
+                            <span>Latency: <strong class="text-blue-400 code-font">${model.latency}</strong></span>
+                        </div>
+                    `;
+                    container.appendChild(card);
+                });
+            } catch (e) {
+                console.error(e);
+            }
+        }
+
+        async function fetchLogs() {
+            try {
+                const res = await fetch('/api/logs');
+                if (!res.ok) return;
+                const logs = await res.json();
+                
+                const term = document.getElementById('terminal-content');
+                const shouldScroll = term.scrollHeight - term.clientHeight <= term.scrollTop + 50;
+                term.innerHTML = logs.map(line => `<div>${line}</div>`).join('');
+                if (shouldScroll) {
+                    term.scrollTop = term.scrollHeight;
+                }
+            } catch (e) {
+                console.error(e);
+            }
+        }
+
+        setInterval(fetchSystemData, 3000);
+        setInterval(fetchModels, 3000);
+        setInterval(fetchLogs, 2000);
+        
+        fetchSystemData();
+        fetchModels();
+        fetchLogs();
+    </script>
+</body>
+</html>
+"""
+
+@app.get("/", response_class=HTMLResponse)
+async def dashboard():
+    return HTMLResponse(content=DASHBOARD_HTML)
+
+
+@app.get("/api/logs")
+async def get_logs():
+    return list(activity_logs)
+
+
+@app.get("/api/models-status")
+async def get_models_status():
+    status_list = []
+    for model_id, display_name in ALL_MODELS.items():
+        status_info = MODEL_STATUSES.get(model_id, {"status": "ONLINE (Unchecked)", "latency": "N/A"})
+        is_rec = model_id == RECOMMENDED_MODEL
+        is_agentic = model_id in TOOL_CAPABLE_MODELS
+        status_list.append({
+            "id": model_id,
+            "name": display_name,
+            "status": status_info["status"],
+            "latency": status_info["latency"],
+            "is_recommended": is_rec,
+            "type": "Agentic (Tools)" if is_agentic else "Chat Only",
+        })
+    # Sort: Recommended first, then Agentic, then Chat
+    status_list.sort(key=lambda m: (not m["is_recommended"], m["type"] != "Agentic (Tools)", m["name"]))
+    return status_list
+
+
 @app.get("/health")
 async def health():
     return {
@@ -726,6 +1005,7 @@ async def health():
         "db_connected": db_pool is not None,
         "models_count": len(ALL_MODELS),
         "recommended_model": RECOMMENDED_MODEL,
+        "active_sessions": len(ACTIVE_SESSIONS),
     }