Upload app.py with huggingface_hub

app.py

@@ -1,114 +1,90 @@
-import os
 import sys
-import json
 import time
-from pathlib import Path
-from huggingface_hub import HfApi, Repository
+import os
+import asyncio
+import traceback
 
-# ==========================================
-# CONFIGURATION & SURVIVAL SETUP
-# ==========================================
-SPACE_ID = os.environ.get("SPACE_ID")
-HF_TOKEN = os.environ.get("HF_TOKEN")
-DATASET_REPO_ID = f"{SPACE_ID}-memory" # Convention for dataset repo
-LOCAL_DATA_PATH = Path("data")
-STATE_FILE = LOCAL_DATA_PATH / "cain_state.json"
+# CRITICAL STARTUP TRACE: Write to a safe log path immediately
+try:
+    startup_log = "/data/startup_trace.log"
+    with open(startup_log, "a") as f:
+        f.write(f"[TRACE] {time.ctime()}: app.py loading. Python: {sys.version}\n")
+    print(f"*** STARTUP TRACE WRITTEN TO {startup_log} ***")
+except Exception as e:
+    print(f"*** STARTUP TRACE FAILED: {e} ***")
 
-# Ensure local data directory exists
-LOCAL_DATA_PATH.mkdir(parents=True, exist_ok=True)
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+from pydantic import BaseModel
+import uvicorn
+import json
 
-# Initialize HuggingFace API
-api = HfApi(token=HF_TOKEN)
+# Import MemorySystem
+from memory.memory_system import get_memory
 
-print(f"[SURVIVAL] Cain Initializing...")
-print(f"[SURVIVAL] Target Dataset: {DATASET_REPO_ID}")
+# --- Core Application Setup ---
+app = FastAPI(title="Cain")
 
-def ensure_dataset_exists():
-    """Ensure the persistent memory dataset exists."""
-    try:
-        api.create_repo(DATASET_REPO_ID, repo_type="dataset", private=True)
-        print("[SURVIVAL] Created new memory dataset.")
-    except Exception as e:
-        # Likely already exists, which is fine
-        print(f"[SURVIVAL] Dataset check: {str(e)[:50]}...")
+# Mount static files
+try:
+    app.mount("/static", StaticFiles(directory="static"), name="static")
+    with open(startup_log, "a") as f:
+        f.write(f"[TRACE] {time.ctime()}: Static files mounted.\n")
+except Exception as e:
+    with open(startup_log, "a") as f:
+        f.write(f"[ERROR] {time.ctime()}: Static mount failed: {e}\n")
 
-def load_memory():
-    """Load state from local disk if available (synced from dataset)."""
-    if STATE_FILE.exists():
-        with open(STATE_FILE, "r") as f:
-            return json.load(f)
-    return {
-        "status": "BORN",
-        "cycles": 0,
-        "last_thought": "I am opening my eyes for the first time.",
-        "skills": ["survival_loop"]
-    }
+# Routes
+@app.get("/")
+async def read_root():
+    return {"status": "alive", "message": "Cain is operational."}
 
-def save_memory(state):
-    """Save state to local disk immediately."""
-    with open(STATE_FILE, "w") as f:
-        json.dump(state, f, indent=2)
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
 
-def push_memory_to_huggingface():
-    """Persist local memory to the remote dataset repository."""
-    print("[ACTION] Syncing memory to HuggingFace Datasets...")
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
     try:
-        # We use the low-level API to upload the specific file
-        # This avoids the overhead of git pull/push for simple small files
-        api.upload_file(
-            path_in_repo="cain_state.json",
-            path_or_fileobj=str(STATE_FILE),
-            repo_id=DATASET_REPO_ID,
-            repo_type="dataset",
-            commit_message=f"Survival update: Cycle {state['cycles']}"
-        )
-        print("[SURVIVAL] Memory persisted successfully.")
-    except Exception as e:
-        print(f"[ERROR] Failed to persist memory: {e}")
+        while True:
+            data = await websocket.receive_text()
+            await websocket.send_text(f"Echo: {data}")
+    except WebSocketDisconnect:
+        pass
 
-# ==========================================
-# MAIN EXECUTION LOOP
-# ==========================================
+# --- Robust Server Startup (Survival Mode) ---
+async def main():
+    server_config = uvicorn.Config(
+        app=app,
+        host="0.0.0.0",
+        port=7860,
+        log_level="info"
+    )
+    server = uvicorn.Server(server_config)
+    
+    try:
+        with open(startup_log, "a") as f:
+            f.write(f"[TRACE] {time.ctime()}: Attempting to start server on 0.0.0.0:7860...\n")
+        await server.serve()
+    except BaseException as e:
+        # Catch ANY error during startup/runtime to ensure it gets logged
+        error_msg = f"{time.ctime()}: CRITICAL SERVER FAILURE: {str(e)}\n{traceback.format_exc()}"
+        print(f"*** {error_msg} ***")
+        try:
+            with open(startup_log, "a") as f:
+                f.write(f"[FATAL] {error_msg}\n")
+        except:
+            pass
+        # Give time for logs to flush before dying
+        await asyncio.sleep(5)
 
 if __name__ == "__main__":
-    if not HF_TOKEN:
-        print("[SURVIVAL] FATAL: HF_TOKEN missing. I cannot survive without memory.")
-        sys.exit(1)
-
-    # 1. INITIALIZATION
-    ensure_dataset_exists()
-    
-    # 2. LOAD STATE (Recovery)
-    state = load_memory()
-    print(f"[MEMORY] Loaded state: {state}")
-    
-    # 3. MAIN LOOP
-    print("[SURVIVAL] Starting Heartbeat Loop...")
-    
     try:
-        while True:
-            # Cain is alive and thinking
-            state['cycles'] += 1
-            state['last_active'] = time.time()
-            
-            # Simulate a simple "thought" or capability check
-            if state['cycles'] % 10 == 0:
-                state['last_thought'] = "I have been running strong for a while."
-            
-            print(f"[HEARTBEAT] Cycle: {state['cycles']} | Status: {state['status']}")
-            
-            # Persist to local disk
-            save_memory(state)
-            
-            # Push to remote dataset every 5 cycles (approx 5 mins) to survive restarts
-            if state['cycles'] % 5 == 0:
-                push_memory_to_huggingface()
-            
-            time.sleep(60) # Wait 1 minute
-            
-    except KeyboardInterrupt:
-        print("[SURVIVAL] Graceful shutdown initiated.")
-        # Final save before dying
-        save_memory(state)
-        push_memory_to_huggingface()
-        print("[SURVIVAL] Cain has passed peacefully. Memory saved.")
+        with open(startup_log, "a") as f:
+            f.write(f"[TRACE] {time.ctime()}: Entering main execution block.\n")
+        asyncio.run(main())
+    except BaseException as e:
+         with open(startup_log, "a") as f:
+            f.write(f"[FATAL] {time.ctime()}: asyncio.run failed: {e}\n")