Update app.py

app.py

@@ -1,26 +1,33 @@
-import os, time, json, asyncio
-from typing import Any, Dict
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request
-from fastapi.responses import JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
+import os, json, time, asyncio
+from typing import AsyncGenerator, Dict, Any
+from fastapi import FastAPI, Request, Response
+from fastapi.responses import JSONResponse, StreamingResponse
 
-BASE_DIR = "/tmp/brain_app"
+# Directories (HF Spaces writable path)
+BASE_DIR = os.environ.get("BASE_DIR", "/tmp/brain_app")
 FILES_DIR = os.path.join(BASE_DIR, "files")
 LOGS_DIR = os.path.join(FILES_DIR, "logs")
-for d in (BASE_DIR, FILES_DIR, LOGS_DIR):
-    os.makedirs(d, exist_ok=True)
+EVENTS_FILE = os.path.join(LOGS_DIR, "events.jsonl")
 
-def log_event(kind: str, data: Dict[str, Any]):
-    rec = {"ts": time.time(), "kind": kind, "data": data}
-    with open(os.path.join(LOGS_DIR, "events.jsonl"), "a", encoding="utf-8") as f:
-        f.write(json.dumps(rec, ensure_ascii=False) + "\n")
+for p in (BASE_DIR, FILES_DIR, LOGS_DIR):
+    os.makedirs(p, exist_ok=True)
 
-app = FastAPI(title="Brain (Skeleton)")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"], allow_credentials=True,
-    allow_methods=[""], allow_headers=[""],
-)
+app = FastAPI(title="Brain Skeleton", version="1.0.0")
+
+# Simple in-memory queue to fan-out logs to /stream/logs clients
+log_queue: "asyncio.Queue[Dict[str, Any]]" = asyncio.Queue()
+
+def write_event(event: Dict[str, Any]) -> None:
+    """Append event to file and enqueue for streaming."""
+    event.setdefault("ts", time.time())
+    os.makedirs(LOGS_DIR, exist_ok=True)
+    with open(EVENTS_FILE, "a", encoding="utf-8") as f:
+        f.write(json.dumps(event, ensure_ascii=False) + "\n")
+    # Put to queue without awaiting (called from sync context)
+    try:
+        log_queue.put_nowait(event)
+    except asyncio.QueueFull:
+        pass
 
 @app.get("/health")
 def health():
@@ -32,32 +39,47 @@ def health():
         "logs_dir": LOGS_DIR,
     }
 
-@app.post("/echo")
-async def echo(request: Request):
-    payload = await request.json()
-    log_event("echo_http_in", payload)
-    out = {"ok": True, "ts": time.time(), "echo": payload}
-    log_event("echo_http_out", out)
-    return JSONResponse(out)
-
-@app.websocket("/ws/echo")
-async def ws_echo(ws: WebSocket):
-    await ws.accept()
-    await ws.send_json({"event": "hello", "msg": "echo socket ready"})
+@app.post("/process")
+async def process(req: Request):
+    """Echo whatever JSON you send and log it."""
     try:
-        while True:
-            text = await ws.receive_text()
-            log_event("echo_ws_in", {"text": text})
-            await ws.send_json({"event": "echo", "text": text})
-    except WebSocketDisconnect:
-        pass
-    except Exception as e:
+        payload = await req.json()
+    except Exception:
+        return JSONResponse({"ok": False, "error": "Invalid JSON body"}, status_code=400)
+
+    event = {"type": "process", "data": payload}
+    write_event(event)
+    return {"ok": True, "received": payload}
+
+@app.get("/stream/logs")
+async def stream_logs() -> StreamingResponse:
+    """Server-Sent Events stream of log events (one per line)."""
+    async def gen() -> AsyncGenerator[bytes, None]:
+        # On connect, tail recent file lines so client sees immediate data (optional)
         try:
-            await ws.send_json({"event": "error", "detail": str(e)})
-        except:
+            if os.path.exists(EVENTS_FILE):
+                with open(EVENTS_FILE, "r", encoding="utf-8") as f:
+                    for line in f.readlines()[-50:]:
+                        yield b"data: " + line.encode("utf-8").rstrip(b"\n") + b"\n\n"
+        except Exception:
             pass
-    finally:
-        try:
-            await ws.close()
-        except:
-            pass
+
+        # Now live stream
+        while True:
+            event = await log_queue.get()
+            line = json.dumps(event, ensure_ascii=False)
+            yield b"data: " + line.encode("utf-8") + b"\n\n"
+
+    headers = {"Cache-Control": "no-cache", "Connection": "keep-alive"}
+    return StreamingResponse(gen(), media_type="text/event-stream", headers=headers)
+
+@app.post("/log_error")
+async def log_error(req: Request):
+    """Allow client to log an error into the event stream."""
+    try:
+        payload = await req.json()
+    except Exception:
+        return JSONResponse({"ok": False, "error": "Invalid JSON body"}, status_code=400)
+    event = {"type": "error", "data": payload}
+    write_event(event)
+    return {"ok": True}