Update app.py

app.py

@@ -1,91 +1,51 @@
-import os
-import json
-import time
-import asyncio
+import os, json, time
 from pathlib import Path
-from typing import Dict, Any
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse, JSONResponse
 
-from fastapi import FastAPI, Body, Request
-from fastapi.responses import JSONResponse, StreamingResponse
-from fastapi.staticfiles import StaticFiles
+BASE_DIR = Path(os.getenv("BASE_DIR","/tmp/brain_app"))
+FILES = BASE_DIR / "files"
+LOGS  = FILES / "logs"
+EVENTS = LOGS / "events.jsonl"
+FILES.mkdir(parents=True, exist_ok=True)
+LOGS.mkdir(parents=True, exist_ok=True)
+EVENTS.touch(exist_ok=True)
 
-BASE_DIR  = Path(os.environ.get("BASE_DIR", "/tmp/brain_app"))
-FILES_DIR = BASE_DIR / "files"
-LOGS_DIR  = FILES_DIR / "logs"
-FILES_DIR.mkdir(parents=True, exist_ok=True)
-LOGS_DIR.mkdir(parents=True, exist_ok=True)
+app = FastAPI()
 
-EVENTS_FILE = LOGS_DIR / "events.jsonl"
-TELEM_FILE  = LOGS_DIR / "telemetry.jsonl"
-
-app = FastAPI(title="Brain")
-app.mount("/files", StaticFiles(directory=str(FILES_DIR)), name="files")
-
-def append_jsonl(path: Path, obj: Dict[str, Any]):
-    obj = {"ts": time.time(), **obj}
-    with path.open("a", encoding="utf-8") as f:
-        f.write(json.dumps(obj, ensure_ascii=False) + "\n")
+def log_event(kind: str, data: dict):
+    ev = {"ts": time.time(), "type": kind, "data": data}
+    with EVENTS.open("a", encoding="utf-8") as f:
+        f.write(json.dumps(ev, ensure_ascii=False) + "\n")
 
 @app.get("/health")
-def health():
-    return {
-        "ok": True,
-        "service": "brain",
-        "time": time.time(),
-        "base_dir": str(BASE_DIR),
-        "files_dir": str(FILES_DIR),
-        "logs_dir": str(LOGS_DIR),
-        "events_file": str(EVENTS_FILE),
-        "telemetry_file": str(TELEM_FILE),
-    }
+async def health():
+    return {"ok": True, "service": "brain", "base_dir": str(BASE_DIR), "events_file": str(EVENTS)}
 
 @app.post("/process")
-async def process(payload: Dict[str, Any] = Body(...)):
-    append_jsonl(EVENTS_FILE, {"type": "process", "data": payload})
-    return {"ok": True, "received": payload}
-
-@app.post("/log_error")
-async def log_error(payload: Dict[str, Any] = Body(...)):
-    append_jsonl(EVENTS_FILE, {"type": "error", "data": payload})
-    return {"ok": True}
-
-@app.post("/telemetry")
-async def telemetry(payload: Dict[str, Any] = Body(...)):
-    append_jsonl(TELEM_FILE, {"type": "telemetry", "data": payload})
-    return {"ok": True}
-
-def sse_lines(path: Path, event_filter: str | None = None):
-    # Tail-like SSE; yields lines as they are appended
-    pos = 0
-    while True:
-        try:
-            with path.open("r", encoding="utf-8") as f:
-                f.seek(pos)
-                for line in f:
-                    pos = f.tell()
-                    try:
-                        obj = json.loads(line.strip())
-                        if event_filter and obj.get("type") != event_filter:
-                            continue
-                        yield f"data: {json.dumps(obj, ensure_ascii=False)}\n\n"
-                    except Exception:
-                        continue
-        except FileNotFoundError:
-            pass
-        time.sleep(0.5)
+async def process(req: Request):
+    body = await req.json()
+    log_event("process", body)
+    # TODO: Replace this echo with your real brain logic
+    reply = f"Echo: {(body.get('text') or body)}"
+    return {"ok": True, "reply": reply}
 
 @app.get("/stream/logs")
-def stream_logs():
-    return StreamingResponse(sse_lines(EVENTS_FILE, None), media_type="text/event-stream")
-
-@app.get("/stream/errors")
-def stream_errors():
-    return StreamingResponse(sse_lines(EVENTS_FILE, "error"), media_type="text/event-stream")
-
-@app.get("/stream/telemetry")
-def stream_telemetry():
-    return StreamingResponse(sse_lines(TELEM_FILE, "telemetry"), media_type="text/event-stream")
-
-@app.get("/")
-def index():
-    return {"ok": True, "service": "brain", "streams": ["/stream/logs", "/stream/telemetry"]}
+async def stream_logs():
+    async def gen():
+        last = EVENTS.stat().st_size
+        with EVENTS.open("r", encoding="utf-8") as f:
+            f.seek(0,0)
+            for line in f:
+                yield f"data: {line}\n\n"
+            f.seek(last)
+            while True:
+                where = f.tell()
+                line = f.readline()
+                if not line:
+                    await asyncio.sleep(0.5)
+                    f.seek(where)
+                    continue
+                yield f"data: {line}\n\n"
+    import asyncio
+    return StreamingResponse(gen(), media_type="text/event-stream")