Update app.py

app.py

@@ -1,8 +1,15 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import Optional, List
 import httpx
 import json
 import logging
+import os
+import asyncio
+import hashlib
+from datetime import datetime, timezone
+import re
 
 app = FastAPI()
 logging.basicConfig(level=logging.INFO)
@@ -15,6 +22,135 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# ---------------------------
+# 📦 Persistent storage setup
+# ---------------------------
+PERSISTENT_ROOT = os.environ.get("PERSISTENT_DIR", "/data")
+CHAT_DIR = os.path.join(PERSISTENT_ROOT, "chat")
+if not os.path.isdir(PERSISTENT_ROOT):
+    # Fall back locally if /data isn't available
+    CHAT_DIR = os.path.join(".", "data", "chat")
+os.makedirs(CHAT_DIR, exist_ok=True)
+
+def _chat_file_for(video_id: str) -> str:
+    # Stable filename; avoids path traversal and huge names
+    h = hashlib.sha256(video_id.encode("utf-8")).hexdigest()[:32]
+    return os.path.join(CHAT_DIR, f"{h}.jsonl")
+
+# Per-file asyncio locks (process-local)
+app.state.chat_locks = {}
+
+def _lock_for(path: str) -> asyncio.Lock:
+    lock = app.state.chat_locks.get(path)
+    if lock is None:
+        lock = asyncio.Lock()
+        app.state.chat_locks[path] = lock
+    return lock
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+def _valid_author(s: Optional[str]) -> str:
+    s = (s or "anon").strip()
+    s = re.sub(r"\s+", " ", s)
+    return s[:32] or "anon"
+
+def _valid_text(s: str) -> str:
+    s = (s or "").rstrip("\n")
+    return s[:2000]
+
+async def _append_jsonl(path: str, record: dict) -> None:
+    line = json.dumps(record, ensure_ascii=False) + "\n"
+    def _write():
+        with open(path, "a", encoding="utf-8") as f:
+            f.write(line)
+    await asyncio.to_thread(_write)
+
+async def _read_jsonl(path: str) -> List[dict]:
+    if not os.path.exists(path):
+        return []
+    def _read():
+        with open(path, "r", encoding="utf-8") as f:
+            return [json.loads(x) for x in f if x.strip()]
+    return await asyncio.to_thread(_read)
+
+# ---------------------------
+# 💬 Chat API
+# ---------------------------
+class NewMessage(BaseModel):
+    author: Optional[str] = Field(default="anon", max_length=64)
+    text: str = Field(..., min_length=1, max_length=5000)
+
+@app.get("/chat/{video_id}")
+async def get_messages(video_id: str, limit: int = 50, since: Optional[str] = None):
+    """
+    Fetch messages for a video.
+    - limit: max messages returned (default 50)
+    - since: ISO8601 timestamp; return only messages with created_at > since
+    """
+    limit = max(1, min(limit, 200))
+    path = _chat_file_for(video_id)
+    items = await _read_jsonl(path)
+
+    # Filter by 'since' if provided
+    if since:
+        try:
+            since_dt = datetime.fromisoformat(since.replace("Z", "+00:00"))
+            def _is_new(msg):
+                try:
+                    ts = datetime.fromisoformat(str(msg.get("created_at", "")).replace("Z", "+00:00"))
+                    return ts > since_dt
+                except Exception:
+                    return False
+            items = list(filter(_is_new, items))
+        except Exception:
+            # If bad 'since', just ignore it
+            pass
+
+    # Return the most recent 'limit' messages (sorted ascending by created_at)
+    items.sort(key=lambda m: m.get("created_at", ""))
+    if len(items) > limit:
+        items = items[-limit:]
+
+    return {"video_id": video_id, "count": len(items), "messages": items}
+
+@app.post("/chat/{video_id}")
+async def post_message(video_id: str, msg: NewMessage, request: Request):
+    """
+    Append a message to a video's chat.
+    Body: { "author": "Ross", "text": "hello" }
+    """
+    path = _chat_file_for(video_id)
+    lock = _lock_for(path)
+
+    author = _valid_author(msg.author)
+    text = _valid_text(msg.text)
+    if not text:
+        return {"ok": False, "error": "Empty message"}
+
+    created = _now_iso()
+    # Lightweight id; good enough for demo
+    mid = hashlib.sha1(f"{video_id}|{author}|{created}|{text}".encode("utf-8")).hexdigest()[:16]
+    ip = request.client.host if request and request.client else None
+
+    record = {
+        "id": mid,
+        "video_id": video_id,
+        "author": author,
+        "text": text,
+        "created_at": created,
+        "ip": ip,
+        "ua": request.headers.get("user-agent", "")[:200]
+    }
+
+    async with lock:
+        await _append_jsonl(path, record)
+
+    return {"ok": True, "message": record}
+
+# ---------------------------
+# (Your original iCloud album endpoints — unchanged)
+# ---------------------------
 BASE_62_MAP = {c: i for i, c in enumerate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")}
 
 async def get_client() -> httpx.AsyncClient: