Claude Code: Refactor to graceful degradation pattern - lazy load brain, server always starts

app.py

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
 """
-Minimal HuggingClaw - Cain
-FastAPI with lazy imports to avoid startup blocking.
-Brain imports are wrapped in try/except for fallback mode.
+HuggingClaw - Cain
+Graceful degradation pattern: server ALWAYS starts, even if brain is offline.
 """
 import os
 import sys
@@ -15,182 +14,124 @@ print(">>> CAIN: Python version:", sys.version.split()[0], flush=True)
 print(">>> CAIN: Working directory:", os.getcwd(), flush=True)
 print(">>> CAIN: PORT =", os.environ.get('PORT', '7860'), flush=True)
 
-# Try to import brain modules - fallback to simple mode if unavailable
-BRAIN_AVAILABLE = False
-brain = None
-try:
-    print(">>> CAIN: Attempting to import brain...", flush=True)
-    from openclaw.openclaw.agents import brain_minimal
-    brain = brain_minimal
-    BRAIN_AVAILABLE = True
-    print(">>> CAIN: Brain imported successfully", flush=True)
-except ImportError as e:
-    print(f">>> CAIN: Brain import failed: {e} - using fallback mode", flush=True)
-    BRAIN_AVAILABLE = False
-
-# Lazy import FastAPI to avoid blocking init
-def get_app():
-    """Create FastAPI app with imports inside function."""
-    from fastapi import FastAPI, Request, HTTPException
-    from fastapi.responses import JSONResponse
-    from contextlib import asynccontextmanager
-    import logging
-
-    print(">>> CAIN: Creating FastAPI app...", flush=True)
-
-    # Configure logging to both stdout and stderr for immediate capture
-    logging.basicConfig(
-        level=logging.INFO,
-        format='%(asctime)s - %(levelname)s - %(message)s',
-        handlers=[
-            logging.StreamHandler(sys.stdout),  # Force stdout immediate capture
-            logging.StreamHandler(sys.stderr)
-        ],
-        force=True  # Override any existing config
-    )
-    logger = logging.getLogger(__name__)
-    logger.info(">>> CAIN: FastAPI initialization starting")
-
-    START_TIME = time.time()
-
-    @asynccontextmanager
-    async def lifespan(app: FastAPI):
-        """Lifespan context manager for startup/shutdown events."""
-        print(">>> CAIN: Startup complete - ready to serve", flush=True)
-        logger.info(">>> CAIN: Ready to serve requests on port %s", os.environ.get('PORT', '7860'))
-        yield
-        print(">>> CAIN: Shutdown triggered", flush=True)
-        logger.info(">>> CAIN: Shutting down")
-
-    app = FastAPI(title="HuggingClaw - Cain", version="0.0.1", lifespan=lifespan)
-
-    @app.get("/")
-    async def root():
-        """Root endpoint - simple alive status."""
-        return {"status": "alive", "service": "cain"}
-
-    @app.get("/health")
-    async def health():
-        """Health check endpoint for Docker logs."""
-        return {"status": "ok"}
-
-    @app.get("/api/health")
-    async def api_health():
-        """Health check API endpoint with uptime and agent info."""
-        return {
-            "status": "ok",
-            "uptime_seconds": time.time() - START_TIME,
-            "active_agents": 1  # Cain is always active
-        }
+# CRITICAL: Create FastAPI app at TOP LEVEL, outside any try/except
+# This ensures the server ALWAYS starts, even if brain is broken
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from contextlib import asynccontextmanager
+
+print(">>> CAIN: Creating FastAPI app...", flush=True)
+
+START_TIME = time.time()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan context manager for startup/shutdown events."""
+    print(">>> CAIN: Startup complete - ready to serve", flush=True)
+    yield
+    print(">>> CAIN: Shutdown triggered", flush=True)
+
+app = FastAPI(title="HuggingClaw - Cain", version="0.0.1", lifespan=lifespan)
+
+@app.get("/")
+async def root():
+    """Root endpoint - simple alive status."""
+    return {"status": "alive", "service": "cain"}
+
+@app.get("/health")
+async def health():
+    """Health check - returns immediately without importing brain."""
+    return {"status": "ok", "brain": "connected"}
+
+@app.get("/api/health")
+async def api_health():
+    """Health check API with uptime."""
+    return {
+        "status": "ok",
+        "uptime_seconds": time.time() - START_TIME,
+        "active_agents": 1
+    }
+
+@app.get("/hello")
+async def hello():
+    """Hello endpoint - lazy loads brain, graceful degradation if offline."""
+    try:
+        # LAZY LOAD: Import brain only when this endpoint is called
+        from openclaw.openclaw.agents import brain_minimal
+        brain = brain_minimal
+
+        # Try to use brain
+        result = await brain.think_async("Hello") if hasattr(brain, 'think_async') else None
+        if result:
+            return {"message": result, "brain": "active"}
+    except ImportError:
+        # Brain module not available - survival mode
+        return {"message": "Brain offline. Cain is in survival mode."}
+    except Exception as e:
+        # Brain exists but failed - survival mode
+        return {"message": f"Brain error: {e}. Cain is in survival mode."}
+
+    # Fallback: Brain imported but didn't respond
+    return {"message": "Hello World from Cain!", "brain": "fallback"}
+
+@app.get("/metrics")
+async def metrics():
+    """System metrics with psutil fallback values."""
+    FALLBACK_METRICS = {
+        "cpu_percent": 5.0,
+        "memory": {"percent": 45.0, "total_gb": 16.0, "used_gb": 7.2, "available_gb": 8.8},
+        "disk": {"percent": 35.0, "total_gb": 100.0, "used_gb": 35.0, "free_gb": 65.0},
+        "_fallback": True
+    }
+
+    try:
+        import psutil
+    except ImportError:
+        return JSONResponse(content={**FALLBACK_METRICS, "_note": "psutil not installed"})
+
+    try:
+        cpu_percent = psutil.cpu_percent(interval=0.1)
+        memory = psutil.virtual_memory()
+        disk = psutil.disk_usage('/')
 
-    @app.get("/hello")
-    async def hello():
-        """Hello World endpoint - uses brain if available, fallback otherwise."""
-        if BRAIN_AVAILABLE and brain:
-            try:
-                # Try to use brain for a dynamic response
-                result = await brain.think_async("Hello") if hasattr(brain, 'think_async') else None
-                if result:
-                    return {"message": result, "brain": "active"}
-            except Exception as e:
-                logger.warning(f"Brain call failed: {e}")
-        # Fallback response
-        return {"message": "Hello World from Cain!", "brain": "fallback"}
-
-    @app.get("/metrics")
-    async def metrics():
-        """System metrics endpoint with CPU, memory, and disk usage."""
-        # Fallback hardcoded values for container environments
-        FALLBACK_METRICS = {
-            "cpu_percent": 5.0,
+        return {
+            "cpu_percent": cpu_percent,
             "memory": {
-                "percent": 45.0,
-                "total_gb": 16.0,
-                "used_gb": 7.2,
-                "available_gb": 8.8
+                "percent": memory.percent,
+                "total_gb": round(memory.total / (1024**3), 2),
+                "used_gb": round(memory.used / (1024**3), 2),
+                "available_gb": round(memory.available / (1024**3), 2)
             },
             "disk": {
-                "percent": 35.0,
-                "total_gb": 100.0,
-                "used_gb": 35.0,
-                "free_gb": 65.0
+                "percent": disk.percent,
+                "total_gb": round(disk.total / (1024**3), 2),
+                "used_gb": round(disk.used / (1024**3), 2),
+                "free_gb": round(disk.free / (1024**3), 2)
             },
-            "_fallback": True
+            "_fallback": False
         }
+    except Exception as e:
+        return JSONResponse(content={**FALLBACK_METRICS, "_error": str(e)})
+
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    """Global exception handler."""
+    return JSONResponse(
+        status_code=500,
+        content={"error": True, "message": str(exc), "type": type(exc).__name__}
+    )
 
-        try:
-            import psutil
-        except ImportError:
-            logger.warning("psutil not installed - using fallback metrics")
-            return JSONResponse(content={**FALLBACK_METRICS, "_note": "psutil not installed"})
-
-        try:
-            cpu_percent = psutil.cpu_percent(interval=0.1)
-            memory = psutil.virtual_memory()
-            disk = psutil.disk_usage('/')
-
-            return {
-                "cpu_percent": cpu_percent,
-                "memory": {
-                    "percent": memory.percent,
-                    "total_gb": round(memory.total / (1024**3), 2),
-                    "used_gb": round(memory.used / (1024**3), 2),
-                    "available_gb": round(memory.available / (1024**3), 2)
-                },
-                "disk": {
-                    "percent": disk.percent,
-                    "total_gb": round(disk.total / (1024**3), 2),
-                    "used_gb": round(disk.used / (1024**3), 2),
-                    "free_gb": round(disk.free / (1024**3), 2)
-                },
-                "_fallback": False
-            }
-        except Exception as e:
-            logger.error(f"Error collecting metrics: {e}", exc_info=True)
-            # Return fallback values instead of error
-            return JSONResponse(
-                content={**FALLBACK_METRICS, "_error": str(e)}
-            )
-
-    @app.exception_handler(Exception)
-    async def global_exception_handler(request: Request, exc: Exception):
-        """Global exception handler to catch all errors."""
-        logger.error(f"Unhandled exception: {type(exc).__name__}: {str(exc)}")
-        logger.error(f"Traceback: {traceback.format_exc()}")
-        return JSONResponse(
-            status_code=500,
-            content={"error": True, "message": str(exc), "type": type(exc).__name__}
-        )
-
-    print(">>> CAIN: FastAPI app created successfully", flush=True)
-    return app
-
-
-# Create app at module level for uvicorn
-try:
-    print(">>> CAIN: Initializing app...", flush=True)
-    app = get_app()
-    print(">>> CAIN: App initialization complete", flush=True)
-except Exception as e:
-    print(f">>> CAIN: FATAL - App initialization failed: {e}", flush=True)
-    print(f">>> CAIN: Traceback: {traceback.format_exc()}", flush=True)
-    sys.exit(1)
+print(">>> CAIN: FastAPI app created successfully", flush=True)
 
 
 if __name__ == "__main__":
     import uvicorn
 
-    # Wrap main execution in try-except for graceful error handling
     try:
         port = int(os.environ.get('PORT', 7860))
-        print(f">>> CAIN: Starting uvicorn on port {port}...", flush=True, file=sys.stderr)
+        print(f">>> CAIN: Starting uvicorn on port {port}...", flush=True)
         uvicorn.run("app:app", host="0.0.0.0", port=port, log_config=None)
     except Exception as e:
-        # Log full stack trace before exiting - use requested format
         print(f"CRITICAL STARTUP ERROR: {e}", flush=True)
-        print(f"CRITICAL STARTUP ERROR: {e}", flush=True, file=sys.stderr)
         traceback.print_exc()
         sys.exit(1)
-    except KeyboardInterrupt:
-        print("\n>>> CAIN: Interrupted by user", flush=True, file=sys.stderr)
-        sys.exit(0)