Update app.py

app.py

@@ -1,51 +1,111 @@
-import os, json, time
-from pathlib import Path
-from fastapi import FastAPI, Request
-from fastapi.responses import StreamingResponse, JSONResponse
-
-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)
-
-app = FastAPI()
-
-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")
+import os, json, asyncio, time
+from typing import Optional
+import httpx
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Body
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
+FILES_DIR = os.environ.get("FILES_DIR", "/tmp/brain_app/files")
+TTS_WS_TARGET = os.environ.get("TTS_WS_TARGET", "")
+TTS_HTTP_TARGET = os.environ.get("TTS_HTTP_TARGET", "")
+STT_WS_TARGET = os.environ.get("STT_WS_TARGET", "")
+
+app = FastAPI(title="Brain Proxy")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[""], allow_headers=[""], allow_methods=["*"], allow_credentials=True,
+)
 
 @app.get("/health")
-async def health():
-    return {"ok": True, "service": "brain", "base_dir": str(BASE_DIR), "events_file": str(EVENTS)}
-
-@app.post("/process")
-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")
-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)
+def health():
+    return {
+        "ok": True,
+        "service": "brain",
+        "files_dir": FILES_DIR,
+        "tts_ws_target": TTS_WS_TARGET,
+        "tts_http_target": TTS_HTTP_TARGET,
+        "stt_ws_target": STT_WS_TARGET,
+        "time": time.time(),
+    }
+
+# ---------- HTTP proxy to TTS /speak ----------
+@app.post("/speak")
+async def speak_proxy(body: dict = Body(...)):
+    if not TTS_HTTP_TARGET:
+        return JSONResponse({"ok": False, "error": "TTS HTTP target not configured"}, 500)
+    try:
+        async with httpx.AsyncClient(timeout=60) as client:
+            r = await client.post(TTS_HTTP_TARGET, json=body)
+            r.raise_for_status()
+            return JSONResponse(r.json(), r.status_code)
+    except httpx.HTTPError as e:
+        return JSONResponse({"ok": False, "error": f"TTS proxy failed: {e}"}, 502)
+
+# ---------- WS proxy helpers ----------
+async def _bridge_ws(client_ws: WebSocket, upstream_url: str):
+    import websockets
+
+    # Establish upstream connection
+    try:
+        upstream = await websockets.connect(upstream_url, ping_interval=None, max_size=8_000_000)
+    except Exception as e:
+        await client_ws.send_json({"event":"error","error":f"Upstream connect failed: {repr(e)}"})
+        await client_ws.close()
+        return
+
+    async def c2u():
+        # client -> upstream (pass text or bytes)
+        try:
             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")
+                msg = await client_ws.receive()
+                if "bytes" in msg and msg["bytes"] is not None:
+                    await upstream.send(msg["bytes"])
+                elif "text" in msg and msg["text"] is not None:
+                    await upstream.send(msg["text"])
+                else:
+                    # ignore pings/others
+                    pass
+        except WebSocketDisconnect:
+            pass
+        finally:
+            try:
+                await upstream.close()
+            except Exception:
+                pass
+
+    async def u2c():
+        # upstream -> client (pass text or binary)
+        try:
+            while True:
+                msg = await upstream.recv()
+                if isinstance(msg, (bytes, bytearray)):
+                    await client_ws.send_bytes(msg)
+                else:
+                    await client_ws.send_text(msg)
+        except Exception:
+            pass
+        finally:
+            try:
+                await client_ws.close()
+            except Exception:
+                pass
+
+    # run both directions
+    await asyncio.gather(c2u(), u2c())
+
+# ---------- WS endpoints the client will use ----------
+@app.websocket("/ws/tts_proxy")
+async def ws_tts_proxy(ws: WebSocket):
+    await ws.accept()
+    if not TTS_WS_TARGET:
+        await ws.send_json({"event":"error","error":"TTS WS target not configured"})
+        await ws.close(); return
+    await _bridge_ws(ws, TTS_WS_TARGET)
+
+@app.websocket("/ws/stt_proxy")
+async def ws_stt_proxy(ws: WebSocket):
+    await ws.accept()
+    if not STT_WS_TARGET:
+        await ws.send_json({"event":"error","error":"STT WS target not configured"})
+        await ws.close(); return
+    await _bridge_ws(ws, STT_WS_TARGET)