Update app.py

app.py

@@ -1,35 +1,24 @@
-# app.py 🎭
-# One file, two personalities:
-# - RUN_MODE=api   -> FastAPI JSON multiplayer relay
-# - RUN_MODE=admin -> Streamlit admin console
-#
-# Shared state uses SQLite so both processes agree on reality.
-# (In-memory is where bugs go to reproduce. 🐛💞)
-
 import os, time, json, secrets, string, sqlite3
-from typing import Any, Dict, Optional, List
+from typing import Any, Dict, List
 
-DB_PATH = os.getenv("GAME_DB_PATH", "/data/game.sqlite")  # HF persistent storage uses /data 💾
+DB_PATH = os.getenv("GAME_DB_PATH", "/data/game.sqlite")  # /data if HF persistent storage is enabled
 CORS_ORIGINS = os.getenv("CORS_ORIGINS", "https://allaiinc.org").split(",")
 
-def now_i() -> int:
-    return int(time.time())
+def now_i(): return int(time.time())
 
-def rid(n=6) -> str:
+def rid(n=6):
     alphabet = string.ascii_uppercase + string.digits
     return "".join(secrets.choice(alphabet) for _ in range(n))
 
-def tok() -> str:
-    return secrets.token_urlsafe(24)
+def tok(): return secrets.token_urlsafe(24)
 
-def db() -> sqlite3.Connection:
-    # check_same_thread=False because Streamlit/FastAPI like to multitask 🤹
-    conn = sqlite3.connect(DB_PATH, check_same_thread=False)
-    conn.row_factory = sqlite3.Row
-    return conn
+def db():
+    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
+    con = sqlite3.connect(DB_PATH, check_same_thread=False)
+    con.row_factory = sqlite3.Row
+    return con
 
 def init_db():
-    os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
     con = db()
     cur = con.cursor()
     cur.executescript("""
@@ -64,386 +53,29 @@ def init_db():
     con.commit()
     con.close()
 
-def room_get(con, room: str):
-    r = con.execute("SELECT * FROM rooms WHERE room=?", (room,)).fetchone()
-    return r
-
-def event_append(con, room: str, kind: str, data: Dict[str, Any]) -> int:
-    r = room_get(con, room)
-    if not r:
-      raise ValueError("room not found")
-    seq = int(r["seq"]) + 1
-    con.execute("UPDATE rooms SET seq=? WHERE room=?", (seq, room))
-    con.execute(
-        "INSERT INTO events(room, seq, t, kind, data_json) VALUES(?,?,?,?,?)",
-        (room, seq, now_i(), kind, json.dumps(data, ensure_ascii=False))
-    )
-    return seq
-
-def players_roster(con, room: str) -> List[Dict[str, Any]]:
-    rows = con.execute("SELECT seat, name, last_seen FROM players WHERE room=? ORDER BY seat", (room,)).fetchall()
-    return [dict(r) for r in rows]
+def room_get(con, room): return con.execute("SELECT * FROM rooms WHERE room=?", (room,)).fetchone()
 
-def player_by_token(con, token: str):
-    return con.execute("SELECT * FROM players WHERE token=?", (token,)).fetchone()
-
-def public_get(con, room: str) -> Dict[str, Any]:
-    r = room_get(con, room)
-    if not r:
-        raise KeyError("room")
-    return json.loads(r["public_json"])
-
-def public_set(con, room: str, obj: Dict[str, Any]):
+def public_get(con, room): return json.loads(room_get(con, room)["public_json"])
+def public_set(con, room, obj):
     con.execute("UPDATE rooms SET public_json=? WHERE room=?", (json.dumps(obj, ensure_ascii=False), room))
 
-def private_get(con, room: str, seat: int) -> Dict[str, Any]:
+def private_get(con, room, seat):
     r = con.execute("SELECT private_json FROM private_state WHERE room=? AND seat=?", (room, seat)).fetchone()
     return json.loads(r["private_json"]) if r else {}
 
-def private_set(con, room: str, seat: int, obj: Dict[str, Any]):
+def private_set(con, room, seat, obj):
     con.execute(
         "INSERT INTO private_state(room, seat, private_json) VALUES(?,?,?) "
         "ON CONFLICT(room, seat) DO UPDATE SET private_json=excluded.private_json",
-        (room, seat, json.dumps(obj, ensure_ascii=False))
+        (room, seat, json.dumps(obj, ensure_ascii=False)),
     )
 
-def cleanup_inactive(con, room: str, ttl: int = 180):
-    # “If you haven’t pinged me in 3 minutes, I assume you went to get snacks.” 🍪
-    cutoff = now_i() - ttl
-    gone = con.execute("SELECT seat, name FROM players WHERE room=? AND last_seen < ?", (room, cutoff)).fetchall()
-    if gone:
-        con.execute("DELETE FROM players WHERE room=? AND last_seen < ?", (room, cutoff))
-        for g in gone:
-            event_append(con, room, "leave", {"seat": int(g["seat"]), "name": g["name"], "why": "timeout"})
-
-# -----------------------------
-# FastAPI mode 🧠⚡
-# -----------------------------
-if os.getenv("RUN_MODE", "api") == "api":
-    from fastapi import FastAPI, HTTPException
-    from fastapi.middleware.cors import CORSMiddleware
-    from pydantic import BaseModel
-
-    init_db()
-    api = FastAPI(title="AllAIINC Multiplayer Relay", version="0.1")
-
-    api.add_middleware(
-        CORSMiddleware,
-        allow_origins=[o.strip() for o in CORS_ORIGINS if o.strip()],
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-
-    class CreateRoomIn(BaseModel):
-        name: str = "Host"
-
-    class JoinRoomIn(BaseModel):
-        room: str
-        name: str = "Player"
-
-    class CmdIn(BaseModel):
-        room: str
-        token: str
-        cmd: str
-
-    class ActionIn(BaseModel):
-        room: str
-        token: str
-        kind: str
-        payload: Dict[str, Any] = {}
-
-    # --- “Easy words” multiplayer language ---
-    # verbs: say, put, get, add, del, who, list, ping, clear
-    # all stored as events + public kv (plus private kv per player if needed)
-
-    def parse_cmd(cmd: str):
-        cmd = (cmd or "").strip()
-        parts = cmd.split()
-        verb = parts[0].lower() if parts else ""
-        rest = parts[1:]
-        return verb, rest
-
-    @api.get("/api/health")
-    def health():
-        return {"ok": True, "t": now_i(), "db": DB_PATH}
-
-    @api.post("/api/room/create")
-    def room_create(body: CreateRoomIn):
-        con = db()
-        try:
-            room = rid()
-            token_ = tok()
-            public = {"turnSeat": 0, "kv": {}, "joke": "Why did the packet cross the road? To get ACK’d. 🐔📨"}
-            con.execute(
-                "INSERT INTO rooms(room, created, seq, public_json) VALUES(?,?,?,?)",
-                (room, now_i(), 0, json.dumps(public, ensure_ascii=False))
-            )
-            con.execute(
-                "INSERT INTO players(token, room, seat, name, last_seen) VALUES(?,?,?,?,?)",
-                (token_, room, 0, body.name[:24], now_i())
-            )
-            private_set(con, room, 0, {"kv": {}, "note": "host private pocket 🧥"})
-            event_append(con, room, "join", {"seat": 0, "name": body.name[:24]})
-            con.commit()
-            return {"room": room, "token": token_, "seat": 0}
-        finally:
-            con.close()
-
-    @api.post("/api/room/join")
-    def room_join(body: JoinRoomIn):
-        con = db()
-        try:
-            if not room_get(con, body.room):
-                raise HTTPException(404, "Room not found")
-            cleanup_inactive(con, body.room)
-
-            # seat = smallest unused
-            used = {int(r["seat"]) for r in con.execute("SELECT seat FROM players WHERE room=?", (body.room,)).fetchall()}
-            seat = 0
-            while seat in used:
-                seat += 1
-
-            token_ = tok()
-            con.execute(
-                "INSERT INTO players(token, room, seat, name, last_seen) VALUES(?,?,?,?,?)",
-                (token_, body.room, seat, body.name[:24], now_i())
-            )
-            private_set(con, body.room, seat, {"kv": {}, "hand": []})
-            seq = event_append(con, body.room, "join", {"seat": seat, "name": body.name[:24]})
-            con.commit()
-            return {"room": body.room, "token": token_, "seat": seat, "seq": seq}
-        finally:
-            con.close()
-
-    @api.get("/api/state")
-    def state(room: str, token: str, since: int = 0):
-        con = db()
-        try:
-            if not room_get(con, room):
-                raise HTTPException(404, "Room not found")
-            p = player_by_token(con, token)
-            if not p or p["room"] != room:
-                raise HTTPException(401, "Bad token")
-            con.execute("UPDATE players SET last_seen=? WHERE token=?", (now_i(), token))
-            cleanup_inactive(con, room)
-
-            pub = public_get(con, room)
-            seat = int(p["seat"])
-            priv = private_get(con, room, seat)
-
-            evs = con.execute(
-                "SELECT seq, t, kind, data_json FROM events WHERE room=? AND seq > ? ORDER BY seq",
-                (room, since)
-            ).fetchall()
-
-            return {
-                "seq": int(room_get(con, room)["seq"]),
-                "you": {"seat": seat, "name": p["name"]},
-                "roster": players_roster(con, room),
-                "public": pub,
-                "private": priv,
-                "events": [{"seq": int(e["seq"]), "t": int(e["t"]), "kind": e["kind"], "data": json.loads(e["data_json"])} for e in evs],
-            }
-        finally:
-            con.close()
-
-    @api.post("/api/cmd")
-    def cmd_run(body: CmdIn):
-        con = db()
-        try:
-            if not room_get(con, body.room):
-                raise HTTPException(404, "Room not found")
-            p = player_by_token(con, body.token)
-            if not p or p["room"] != body.room:
-                raise HTTPException(401, "Bad token")
-
-            seat = int(p["seat"])
-            name = p["name"]
-            con.execute("UPDATE players SET last_seen=? WHERE token=?", (now_i(), body.token))
-            cleanup_inactive(con, body.room)
-
-            pub = public_get(con, body.room)
-            pub.setdefault("kv", {})
-            priv = private_get(con, body.room, seat)
-            priv.setdefault("kv", {})
-
-            verb, rest = parse_cmd(body.cmd)
-
-            if verb in ("help", ""):
-                return {"ok": True, "msg": "verbs: join, say, put, get, add, del, who, list, ping, clear"}
+def player_by_token(con, token): return con.execute("SELECT * FROM players WHERE token=?", (token,)).fetchone()
 
-            if verb == "ping":
-                seq = event_append(con, body.room, "ping", {"seat": seat, "name": name})
-                con.commit()
-                return {"ok": True, "msg": "pong 🏓", "seq": seq}
-
-            if verb == "who":
-                return {"ok": True, "players": players_roster(con, body.room)}
-
-            if verb == "list":
-                return {"ok": True, "keys": sorted(pub["kv"].keys())}
-
-            if verb == "say":
-                msg = " ".join(rest).strip()[:240]
-                if not msg:
-                    raise HTTPException(400, "Usage: say <message>")
-                seq = event_append(con, body.room, "say", {"seat": seat, "name": name, "text": msg})
-                con.commit()
-                return {"ok": True, "msg": "sent 🗣️", "seq": seq}
-
-            if verb == "put":
-                if len(rest) < 2:
-                    raise HTTPException(400, "Usage: put <key> <value>")
-                k = rest[0]
-                v = " ".join(rest[1:])[:240]
-                pub["kv"][k] = v
-                public_set(con, body.room, pub)
-                seq = event_append(con, body.room, "put", {"seat": seat, "key": k, "value": v})
-                con.commit()
-                return {"ok": True, "msg": f"ok ✅ stored {k}", "seq": seq}
-
-            if verb == "get":
-                if len(rest) != 1:
-                    raise HTTPException(400, "Usage: get <key>")
-                k = rest[0]
-                return {"ok": True, "key": k, "value": pub["kv"].get(k)}
-
-            if verb == "add":
-                if len(rest) < 2:
-                    raise HTTPException(400, "Usage: add <key> <number>")
-                k = rest[0]
-                try:
-                    amt = float(rest[1])
-                except:
-                    raise HTTPException(400, "add needs a number, e.g. add score 5")
-                cur = pub["kv"].get(k, 0)
-                try:
-                    cur = float(cur)
-                except:
-                    cur = 0.0
-                pub["kv"][k] = cur + amt
-                public_set(con, body.room, pub)
-                seq = event_append(con, body.room, "add", {"seat": seat, "key": k, "amt": amt, "new": pub["kv"][k]})
-                con.commit()
-                return {"ok": True, "msg": f"{k} -> {pub['kv'][k]} 📈", "seq": seq}
-
-            if verb == "del":
-                if len(rest) != 1:
-                    raise HTTPException(400, "Usage: del <key>")
-                k = rest[0]
-                pub["kv"].pop(k, None)
-                public_set(con, body.room, pub)
-                seq = event_append(con, body.room, "del", {"seat": seat, "key": k})
-                con.commit()
-                return {"ok": True, "msg": f"deleted {k} 🧹", "seq": seq}
-
-            if verb == "clear":
-                if seat != 0:
-                    raise HTTPException(403, "Only seat 0 can clear")
-                pub["kv"] = {}
-                public_set(con, body.room, pub)
-                seq = event_append(con, body.room, "clear", {"by": name})
-                con.commit()
-                return {"ok": True, "msg": "cleared 🧼", "seq": seq}
-
-            raise HTTPException(400, f"Unknown verb: {verb}")
-        finally:
-            con.close()
-
-    @api.post("/api/action")
-    def action(body: ActionIn):
-        # “action” is for structured game moves (turn-based etc.)
-        con = db()
-        try:
-            if not room_get(con, body.room):
-                raise HTTPException(404, "Room not found")
-            p = player_by_token(con, body.token)
-            if not p or p["room"] != body.room:
-                raise HTTPException(401, "Bad token")
-
-            seat = int(p["seat"])
-            name = p["name"]
-            con.execute("UPDATE players SET last_seen=? WHERE token=?", (now_i(), body.token))
-            cleanup_inactive(con, body.room)
-
-            pub = public_get(con, body.room)
-
-            # ultra-minimal example: a shared “pot” with turn enforcement
-            pub.setdefault("turnSeat", 0)
-            pub.setdefault("pot", 0)
-
-            if seat != int(pub["turnSeat"]):
-                raise HTTPException(409, "Not your turn")
-
-            if body.kind == "add_to_pot":
-                amt = int(body.payload.get("amt", 1))
-                pub["pot"] += max(0, amt)
-            else:
-                raise HTTPException(400, "Unknown kind")
-
-            # advance turn
-            seats = [r["seat"] for r in players_roster(con, body.room)]
-            seats = sorted(int(s) for s in seats)
-            i = seats.index(seat)
-            pub["turnSeat"] = seats[(i+1) % len(seats)]
-
-            public_set(con, body.room, pub)
-            seq = event_append(con, body.room, "action", {"seat": seat, "name": name, "kind": body.kind, "payload": body.payload})
-            con.commit()
-            return {"ok": True, "seq": seq, "public": pub}
-        finally:
-            con.close()
-
-# -----------------------------
-# Streamlit admin mode 🧑‍🔧🧠
-# -----------------------------
-else:
-    import streamlit as st
-    import pandas as pd
-    import requests
-
-    init_db()
-
-    st.set_page_config(page_title="Admin — Multiplayer Relay", layout="wide")
-    st.title("🧑‍✈️ Admin Console — Multiplayer Relay")
-    st.caption("If you can read this, nginx routing worked. If you can’t, blame gremlins. 👹")
-
-    con = db()
-    rooms = con.execute("SELECT room, created, seq FROM rooms ORDER BY created DESC").fetchall()
-    con.close()
-
-    if not rooms:
-        st.info("No rooms yet. Create one via /api/room/create from your web client.")
-        st.stop()
-
-    df_rooms = pd.DataFrame([dict(r) for r in rooms])
-    st.dataframe(df_rooms, use_container_width=True, hide_index=True)
-
-    room_id = st.selectbox("Pick a room", df_rooms["room"].tolist())
-    col1, col2, col3 = st.columns([1,1,1])
-
-    if col1.button("🔄 Refresh"):
-        st.rerun()
-
-    # Show room details
-    con = db()
-    room = con.execute("SELECT * FROM rooms WHERE room=?", (room_id,)).fetchone()
-    roster = con.execute("SELECT seat, name, last_seen FROM players WHERE room=? ORDER BY seat", (room_id,)).fetchall()
-    events = con.execute("SELECT seq, t, kind, data_json FROM events WHERE room=? ORDER BY seq DESC LIMIT 80", (room_id,)).fetchall()
-    con.close()
-
-    st.subheader(f"🧩 Room `{room_id}`")
-    st.write("**Public**")
-    st.json(json.loads(room["public_json"]))
-
-    st.write("**Players**")
-    st.dataframe(pd.DataFrame([dict(r) for r in roster]), use_container_width=True, hide_index=True)
-
-    st.write("**Recent events**")
-    ev_df = pd.DataFrame([{
-        "seq": int(e["seq"]), "t": int(e["t"]), "kind": e["kind"], "data": json.loads(e["data_json"])
-    } for e in events])
-    st.dataframe(ev_df, use_container_width=True, hide_index=True)
+def roster(con, room) -> List[Dict[str, Any]]:
+    rows = con.execute("SELECT seat, name, last_seen FROM players WHERE room=? ORDER BY seat", (room,)).fetchall()
+    return [dict(r) for r in rows]
 
-    st.caption("Joke: A SQL query walks into a bar and says: ‘Can I join you?’ 🍻🧾")
+def event_append(con, room, kind, data) -> int:
+    r = room_get(con, room)
+    seq = int(r["seq"]) +