Update app.py

app.py

@@ -1,73 +1,92 @@
-import os
-import time
-import json
+# app.py
+import json, time, os
 from pathlib import Path
 from fastapi import FastAPI, Request
 from fastapi.responses import JSONResponse, StreamingResponse
 
-# ------------------
-# Setup paths
-# ------------------
-BASE_DIR = Path(__file__).parent
-FILES_DIR = BASE_DIR / "files"
-LOG_DIR = FILES_DIR / "logs"
+app = FastAPI(title="Brain", version="0.1.0")
 
-FILES_DIR.mkdir(parents=True, exist_ok=True)
-LOG_DIR.mkdir(parents=True, exist_ok=True)
+# -----------------------------
+# Writable paths (with fallback)
+# -----------------------------
+def _mk_dir(path: Path) -> Path:
+    try:
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+    except Exception as e:
+        # fallback to /tmp which is always writable on HF Spaces
+        fallback = Path("/tmp/brain_app/files") if "files" in str(path) else Path("/tmp/brain_app")
+        try:
+            fallback.mkdir(parents=True, exist_ok=True)
+        except Exception:
+            pass
+        print(f"[WARN] Could not create {path} ({e}); using {fallback}")
+        return fallback
+
+# Allow overrides via env, else use /tmp
+BASE_DIR = Path(os.getenv("BRAIN_BASE_DIR", "/tmp/brain_app"))
+FILES_DIR = _mk_dir(Path(os.getenv("FILES_DIR", str(BASE_DIR / "files"))))
+LOG_DIR = _mk_dir(Path(os.getenv("LOG_DIR", str(FILES_DIR / "logs"))))
 
-# ------------------
-# Safe logger
-# ------------------
-def _safe_append_jsonl(path: Path, event: dict):
-    """Safely append JSON event to a file without crashing."""
+EVENTS_FILE = LOG_DIR / "events.jsonl"
+ERRORS_FILE = LOG_DIR / "errors.jsonl"
+
+# -----------------------------
+# Safe file append
+# -----------------------------
+def _append_jsonl(path: Path, obj: dict):
     try:
         path.parent.mkdir(parents=True, exist_ok=True)
-        with open(path, "a", encoding="utf-8") as f:
-            f.write(json.dumps(event, ensure_ascii=False) + "\n")
+        with path.open("a", encoding="utf-8") as f:
+            f.write(json.dumps(obj, ensure_ascii=False) + "\n")
     except Exception as e:
-        print(f"[WARN] Could not log event: {e}")
-
-# ------------------
-# FastAPI app
-# ------------------
-app = FastAPI(title="Brain", version="0.1")
+        print(f"[WARN] log write failed: {e}")
 
+# -----------------------------
+# Endpoints
+# -----------------------------
 @app.get("/health")
-async def health():
+def health():
     return {
         "ok": True,
         "service": "brain",
         "time": time.time(),
+        "base_dir": str(BASE_DIR),
         "files_dir": str(FILES_DIR),
-        "logs": str(LOG_DIR),
+        "logs_dir": str(LOG_DIR),
+        "events_file": str(EVENTS_FILE),
     }
 
 @app.post("/process")
-async def process(request: Request):
-    payload = await request.json()
-
-    event = {
-        "ts": time.time(),
-        "type": "process",
-        "data": payload,
-    }
-    _safe_append_jsonl(LOG_DIR / "events.jsonl", event)
-
-    # Echo back
-    return JSONResponse({"ok": True, "received": payload})
+async def process(req: Request):
+    payload = await req.json()
+    evt = {"ts": time.time(), "type": "process", "data": payload}
+    _append_jsonl(EVENTS_FILE, evt)
+    return {"ok": True, "received": payload}
 
-@app.get("/stream/logs")
-async def stream_logs():
-    """Stream logs line-by-line to client (SSE style)."""
+@app.post("/log_error")
+async def log_error(req: Request):
+    payload = await req.json()
+    err = {"ts": time.time(), "type": "error", "data": payload}
+    _append_jsonl(ERRORS_FILE, err)
+    _append_jsonl(EVENTS_FILE, {"ts": err["ts"], "type": "error_ref"})
+    return {"ok": True}
 
-    async def event_stream():
-        path = LOG_DIR / "events.jsonl"
+def _sse_from_file(path: Path):
+    # generator for SSE streaming of an existing file (no tailing daemon)
+    def gen():
         if not path.exists():
             yield "data: {}\n\n"
             return
-
-        with open(path, "r", encoding="utf-8") as f:
+        with path.open("r", encoding="utf-8") as f:
             for line in f:
-                yield f"data: {line.strip()}\n\n"
+                yield f"data: " + line.strip() + "\n\n"
+    return gen
+
+@app.get("/stream/logs")
+def stream_logs():
+    return StreamingResponse(_sse_from_file(EVENTS_FILE)(), media_type="text/event-stream")
 
-    return StreamingResponse(event_stream(), media_type="text/event-stream")
+@app.get("/stream/errors")
+def stream_errors():
+    return StreamingResponse(_sse_from_file(ERRORS_FILE)(), media_type="text/event-stream")