Update app.py

app.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import Optional, Dict
 
 import uvicorn
-from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect, Request, BackgroundTasks
 from fastapi.responses import JSONResponse, FileResponse, PlainTextResponse
 
 # -------------------------
@@ -45,6 +45,12 @@ FILE_CANDIDATES = [
 VOICES_DIR = pick_writable_dir([p for p in VOICE_CANDIDATES if p])
 FILES_DIR  = pick_writable_dir([p for p in FILE_CANDIDATES if p])
 
+def _safe_unlink(path: Path):
+    try:
+        path.unlink(missing_ok=True)
+    except Exception:
+        pass
+
 # -------------------------
 # Piper CLI integration
 # -------------------------
@@ -127,10 +133,12 @@ def build_piper_cmd(text: str, voice_id: str, to_stdout: bool, out_path: Optiona
         "--noise_w",      str(noise_w),
     ]
     if to_stdout:
-        cmd += ["-f", "-"]   # write WAV to stdout
+        # Stream RAW PCM (no WAV header) → simpler, no header parsing bugs.
+        cmd += ["--raw", "-f", "-"]
     else:
         if out_path is None:
             raise ValueError("out_path required when to_stdout=False")
+        # When writing to file, Piper writes WAV by default.
         cmd += ["-f", str(out_path)]
     return cmd
 
@@ -140,8 +148,8 @@ async def piper_to_file(text, voice, out_path, length_scale, noise_scale, noise_
     proc = await asyncio.create_subprocess_exec(
         *cmd, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
     )
-    # IMPORTANT: .write() is not awaitable; keep drain() awaited.
-    proc.stdin.write(text.encode("utf-8"))
+    # Send a final newline so Piper treats it as a complete utterance.
+    proc.stdin.write((text + "\n").encode("utf-8"))
     await proc.stdin.drain()
     proc.stdin.close()
     await proc.wait()
@@ -150,7 +158,7 @@ async def piper_to_file(text, voice, out_path, length_scale, noise_scale, noise_
         raise RuntimeError(f"Piper failed (code {proc.returncode}).\n{stderr}")
 
 async def piper_stream_stdout(text, voice, ws: WebSocket, length_scale, noise_scale, noise_w):
-    """Stream WAV from Piper stdout over WS, stripping the WAV header once even if split."""
+    """Stream RAW PCM from Piper stdout over WS (no WAV header), with stderr logs."""
     await ws.send_text(json.dumps({"event": "ready", "sr": DEFAULT_SR, "channels": DEFAULT_CH}))
 
     cmd = build_piper_cmd(text, voice, to_stdout=True,
@@ -158,46 +166,59 @@ async def piper_stream_stdout(text, voice, ws: WebSocket, length_scale, noise_sc
     proc = await asyncio.create_subprocess_exec(
         *cmd, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
     )
-    # IMPORTANT: .write() is not awaitable; keep drain() awaited.
-    proc.stdin.write(text.encode("utf-8"))
+
+    # Feed text + newline then close stdin
+    proc.stdin.write((text + "\n").encode("utf-8"))
     await proc.stdin.drain()
     proc.stdin.close()
 
-    header_needed = True
-    header_buf = bytearray()
+    # Forward stderr lines to client (debug visibility)
+    async def pump_stderr():
+        try:
+            while True:
+                line = await proc.stderr.readline()
+                if not line:
+                    break
+                try:
+                    await ws.send_text(json.dumps({"event": "log", "stderr": line.decode("utf-8", "ignore").rstrip()}))
+                except Exception:
+                    break
+        except Exception:
+            pass
+
+    stderr_task = asyncio.create_task(pump_stderr())
 
+    total_bytes = 0
     try:
+        # RAW PCM passthrough
         while True:
             chunk = await proc.stdout.read(4096)
             if not chunk:
                 break
-
-            if header_needed:
-                header_buf.extend(chunk)
-                if len(header_buf) < 44:
-                    continue
-                if header_buf[:4] == b"RIFF" and header_buf[8:12] == b"WAVE":
-                    payload = header_buf[44:]
-                else:
-                    payload = bytes(header_buf)
-                header_buf.clear()
-                header_needed = False
-                if payload:
-                    await ws.send_bytes(payload)
-            else:
-                await ws.send_bytes(chunk)
+            total_bytes += len(chunk)
+            await ws.send_bytes(chunk)
 
         await proc.wait()
+        await stderr_task
+
         if proc.returncode != 0:
-            stderr = (await proc.stderr.read()).decode("utf-8", "ignore")
-            await ws.send_text(json.dumps({"event": "error", "detail": stderr}))
+            rem = await proc.stderr.read()
+            detail = rem.decode("utf-8", "ignore").strip()
+            await ws.send_text(json.dumps({"event": "error", "detail": detail or f'piper exited {proc.returncode}'}))
         else:
-            await ws.send_text(json.dumps({"event": "done"}))
+            if total_bytes == 0:
+                await ws.send_text(json.dumps({"event": "error", "detail": "No audio produced"}))
+            else:
+                await ws.send_text(json.dumps({"event": "done"}))
     except WebSocketDisconnect:
         try:
             proc.kill()
         except Exception:
             pass
+        try:
+            await stderr_task
+        except Exception:
+            pass
 
 # ---------------
 # FastAPI wiring
@@ -275,6 +296,65 @@ async def speak(request: Request):
 
     return {"ok": True, "audio_url": f"/file/{out_path.name}"}
 
+# --- Direct-file endpoints (audio/wav response) ---
+@app.post("/speak.wav")
+async def speak_wav_post(request: Request, background_tasks: BackgroundTasks):
+    """
+    POST JSON -> returns audio/wav directly
+    """
+    try:
+        body = await request.json()
+    except Exception:
+        return JSONResponse({"detail": "Invalid JSON"}, status_code=400)
+
+    text = (body.get("text") or "").strip()
+    if not text:
+        return JSONResponse({"detail": "Missing text"}, status_code=400)
+
+    voice        = (body.get("voice") or DEFAULT_VOICE).strip()
+    length_scale = float(body.get("length_scale", 1.08))
+    noise_scale  = float(body.get("noise_scale", 0.35))
+    noise_w      = float(body.get("noise_w", 0.90))
+
+    ts = int(time.time() * 1000)
+    out_path = FILES_DIR / f"tts-{ts}.wav"
+
+    try:
+        ensure_voice(voice)
+        await piper_to_file(text, voice, out_path, length_scale, noise_scale, noise_w)
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=500)
+
+    background_tasks.add_task(_safe_unlink, out_path)
+    return FileResponse(out_path, media_type="audio/wav", filename=out_path.name, background=background_tasks)
+
+@app.get("/speak.wav")
+async def speak_wav_get(
+    text: str,
+    voice: str = DEFAULT_VOICE,
+    length_scale: float = 1.08,
+    noise_scale: float = 0.35,
+    noise_w: float = 0.90,
+    background_tasks: BackgroundTasks | None = None,
+):
+    """GET query -> returns audio/wav directly"""
+    text = (text or "").strip()
+    if not text:
+        return JSONResponse({"detail": "Missing text"}, status_code=400)
+
+    ts = int(time.time() * 1000)
+    out_path = FILES_DIR / f"tts-{ts}.wav"
+
+    try:
+        ensure_voice(voice.strip())
+        await piper_to_file(text, voice.strip(), out_path, float(length_scale), float(noise_scale), float(noise_w))
+    except Exception as e:
+        return JSONResponse({"ok": False, "error": str(e)}, status_code=500)
+
+    background_tasks = background_tasks or BackgroundTasks()
+    background_tasks.add_task(_safe_unlink, out_path)
+    return FileResponse(out_path, media_type="audio/wav", filename=out_path.name, background=background_tasks)
+
 @app.websocket("/ws/tts")
 async def ws_tts(ws: WebSocket):
     await ws.accept()
@@ -321,4 +401,5 @@ async def ws_tts(ws: WebSocket):
             pass
 
 if __name__ == "__main__":
-    uvicorn.run("app:app", host="0.0.0.0", port=7860, reload=False)
+    import os
+    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", "7860")), reload=False)