kryten-webqueue 0.1.1__py3-none-any.whl

kryten_webqueue/__main__.py

@@ -0,0 +1,10 @@
+import os
+import uvicorn
+
+from .config import Config
+from .app import create_app
+
+config_path = os.environ.get("WQ_CONFIG", "/etc/kryten-webqueue/config.json")
+config = Config.from_file(config_path)
+app = create_app(config)
+uvicorn.run(app, host=config.host, port=config.port)

kryten_webqueue/api_gate/client.py

@@ -0,0 +1,113 @@
+import httpx
+
+
+class ApiGateClient:
+    """HTTP client for kryten-api-gate."""
+
+    def __init__(self, base_url: str, token: str):
+        self._base_url = base_url.rstrip("/") + "/api/v1"
+        self._client = httpx.AsyncClient(
+            base_url=self._base_url,
+            headers={"Authorization": f"Bearer {token}"},
+            timeout=httpx.Timeout(10.0, connect=5.0),
+        )
+
+    async def close(self):
+        await self._client.aclose()
+
+    async def get(self, path: str, **params) -> dict:
+        resp = await self._client.get(path, params=params)
+        resp.raise_for_status()
+        return resp.json()
+
+    async def post(self, path: str, json: dict | None = None) -> dict:
+        resp = await self._client.post(path, json=json)
+        resp.raise_for_status()
+        return resp.json()
+
+    async def put(self, path: str, json: dict | None = None) -> dict:
+        resp = await self._client.put(path, json=json)
+        resp.raise_for_status()
+        return resp.json()
+
+    async def delete(self, path: str) -> dict:
+        resp = await self._client.delete(path)
+        resp.raise_for_status()
+        return resp.json()
+
+    # --- State ---
+
+    async def get_playlist(self) -> list[dict]:
+        result = await self.get("/state/playlist")
+        return result.get("items", [])
+
+    async def get_now_playing(self) -> dict:
+        return await self.get("/state/now-playing")
+
+    async def get_user(self, username: str) -> dict:
+        return await self.get(f"/state/user/{username}")
+
+    # --- Playlist CRUD ---
+
+    async def playlist_add(self, media_type: str, media_id: str, *, position: str = "end", temp: bool = True) -> dict:
+        """Add item to playlist. Returns {"success": bool, "uid": int|None}."""
+        return await self.post("/playlist/add", json={
+            "type": media_type,
+            "id": media_id,
+            "position": position,
+            "temp": temp,
+        })
+
+    async def playlist_move(self, uid: int, position: int | str) -> dict:
+        """Move item. position is a UID (int) or "prepend"/"append"."""
+        return await self.put(f"/playlist/{uid}/move", json={"position": position})
+
+    async def playlist_delete(self, uid: int) -> dict:
+        return await self.delete(f"/playlist/{uid}")
+
+    async def playlist_clear(self) -> dict:
+        return await self.delete("/playlist/")
+
+    async def playlist_jump(self, uid: int) -> dict:
+        return await self.post(f"/playlist/{uid}/jump")
+
+    # --- Chat ---
+
+    async def send_pm(self, username: str, message: str) -> dict:
+        return await self.post("/chat/pm", json={"username": username, "message": message})
+
+    # --- Admin ---
+
+    async def get_motd(self) -> str:
+        result = await self.get("/admin/motd")
+        return result.get("motd", "")
+
+    # --- Economy proxy ---
+
+    async def get_balance(self, username: str) -> dict:
+        return await self.get(f"/economy/balance/{username}")
+
+    async def get_transactions(self, username: str, limit: int = 20, offset: int = 0) -> dict:
+        return await self.get(f"/economy/transactions/{username}", limit=limit, offset=offset)
+
+    async def queue_preview(self, username: str, duration_sec: int, tier: str = "queue") -> dict:
+        return await self.post("/economy/queue-preview", json={
+            "username": username,
+            "duration_sec": duration_sec,
+            "tier": tier,
+        })
+
+    async def queue_spend(self, username: str, duration_sec: int, tier: str, request_id: str) -> dict:
+        return await self.post("/economy/queue-spend", json={
+            "username": username,
+            "duration_sec": duration_sec,
+            "tier": tier,
+            "request_id": request_id,
+        })
+
+    async def queue_refund(self, username: str, request_id: str, reason: str) -> dict:
+        return await self.post("/economy/queue-refund", json={
+            "username": username,
+            "request_id": request_id,
+            "reason": reason,
+        })

kryten_webqueue/app.py

@@ -0,0 +1,184 @@
+import asyncio
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from pathlib import Path
+
+from .config import Config
+from .catalog.db import Database
+from .api_gate.client import ApiGateClient
+from .catalog.sync import CatalogSync
+from .catalog.images import CoverArtResolver
+from .queue.shadow import QueueShadow
+from .queue.poller import StatePoller
+from .ws.manager import WebSocketManager
+from .playlists.scheduler import PlaylistScheduler
+from .auth.rate_limit import RateLimiter
+
+from .routes.auth import router as auth_router
+from .routes.catalog import router as catalog_router
+from .routes.queue import router as queue_router
+from .routes.user import router as user_router
+from .routes.admin_playlists import router as admin_playlists_router
+from .routes.admin_schedules import router as admin_schedules_router
+from .routes.admin_queue import router as admin_queue_router
+from .routes.pages import router as pages_router
+from .ws.handler import router as ws_router
+
+logger = logging.getLogger(__name__)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    config: Config = app.state.config
+
+    # Database
+    db = Database(config.db_path)
+    await db.connect()
+    await db.run_migrations()
+    app.state.db = db
+
+    # API Gate client
+    api_gate = ApiGateClient(config.api_gate_url, config.api_gate_token)
+    app.state.api_gate = api_gate
+
+    # Catalog sync
+    catalog_sync = CatalogSync(
+        mediacms_url=config.mediacms_url,
+        mediacms_token=config.mediacms_token,
+        db=db,
+    )
+    app.state.catalog_sync = catalog_sync
+
+    # Cover art resolver
+    cover_art = CoverArtResolver(
+        image_dir=config.image_dir,
+        placeholder_dir=config.placeholder_dir,
+        tmdb_api_key=config.tmdb_api_key,
+        omdb_api_key=config.omdb_api_key,
+    )
+    app.state.cover_art = cover_art
+
+    # WebSocket manager
+    ws_manager = WebSocketManager()
+    app.state.ws_manager = ws_manager
+
+    # Queue shadow
+    shadow = QueueShadow(db)
+    await shadow.load_from_db()
+    app.state.shadow = shadow
+
+    # State poller
+    poller = StatePoller(
+        api_gate=api_gate,
+        shadow=shadow,
+        ws_manager=ws_manager,
+        interval=config.state_poll_interval_sec,
+    )
+    await poller.start()
+    app.state.poller = poller
+
+    # Rate limiter
+    app.state.rate_limiter = RateLimiter()
+
+    # Playlist scheduler
+    scheduler = PlaylistScheduler(db=db, api_gate=api_gate, shadow=shadow, ws_manager=ws_manager)
+    await scheduler.start()
+    app.state.scheduler = scheduler
+
+    # Background workers
+    async def _catalog_sync_loop():
+        interval = config.catalog_sync_interval_hours * 3600
+        while True:
+            await asyncio.sleep(interval)
+            try:
+                await catalog_sync.sync()
+            except Exception as e:
+                logger.error(f"Catalog sync error: {e}")
+
+    async def _otp_cleanup_loop():
+        while True:
+            await asyncio.sleep(3600)  # every hour
+            try:
+                await db.cleanup_expired_otps()
+            except Exception as e:
+                logger.error(f"OTP cleanup error: {e}")
+
+    async def _immutability_expiry_loop():
+        while True:
+            await asyncio.sleep(300)  # every 5 minutes
+            try:
+                await db._execute("""
+                    UPDATE saved_playlists SET is_immutable = 0
+                    WHERE id IN (
+                        SELECT sp.id FROM saved_playlists sp
+                        JOIN playlist_schedules ps ON ps.playlist_id = sp.id
+                        WHERE sp.is_immutable = 1
+                          AND ps.immutability_expires_at IS NOT NULL
+                          AND ps.immutability_expires_at < datetime('now')
+                          AND NOT EXISTS (
+                              SELECT 1 FROM playlist_schedules ps2
+                              WHERE ps2.playlist_id = sp.id
+                                AND ps2.is_active = 1
+                                AND (ps2.immutability_expires_at IS NULL OR ps2.immutability_expires_at > datetime('now'))
+                          )
+                    )
+                """)
+            except Exception as e:
+                logger.error(f"Immutability expiry error: {e}")
+
+    bg_tasks = [
+        asyncio.create_task(_catalog_sync_loop()),
+        asyncio.create_task(_otp_cleanup_loop()),
+        asyncio.create_task(_immutability_expiry_loop()),
+    ]
+
+    logger.info(f"kryten-webqueue started on {config.host}:{config.port}")
+
+    yield
+
+    # Shutdown
+    for task in bg_tasks:
+        task.cancel()
+    await poller.stop()
+    await scheduler.stop()
+    await catalog_sync.close()
+    await cover_art.close()
+    await api_gate.close()
+    await db.close()
+    logger.info("kryten-webqueue shut down")
+
+
+def create_app(config: Config) -> FastAPI:
+    app = FastAPI(
+        title="kryten-webqueue",
+        version="0.1.0",
+        lifespan=lifespan,
+    )
+    app.state.config = config
+
+    # Register routes
+    app.include_router(pages_router)
+    app.include_router(auth_router)
+    app.include_router(catalog_router)
+    app.include_router(queue_router)
+    app.include_router(user_router)
+    app.include_router(admin_playlists_router)
+    app.include_router(admin_schedules_router)
+    app.include_router(admin_queue_router)
+    app.include_router(ws_router)
+
+    # Health check
+    @app.get("/health")
+    async def health():
+        return {"status": "ok"}
+
+    # Static files
+    static_dir = Path(__file__).parent / "static"
+    if static_dir.exists():
+        app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+
+    return app

kryten_webqueue/auth/otp.py

@@ -0,0 +1,10 @@
+import secrets
+from datetime import datetime, timedelta, UTC
+
+
+def generate_otp() -> str:
+    return str(secrets.randbelow(1000000)).zfill(6)
+
+
+def get_otp_expiry(minutes: int = 5) -> str:
+    return (datetime.now(UTC) + timedelta(minutes=minutes)).isoformat()

kryten_webqueue/auth/rate_limit.py

@@ -0,0 +1,29 @@
+import time
+from collections import defaultdict, deque
+
+
+class RateLimiter:
+    """Sliding-window rate limiter for OTP requests."""
+
+    def __init__(self, max_requests: int = 3, window_seconds: int = 300):
+        self._max = max_requests
+        self._window = window_seconds
+        self._requests: dict[str, deque] = defaultdict(deque)
+
+    def is_allowed(self, key: str) -> bool:
+        now = time.time()
+        window = self._requests[key]
+        # Remove expired entries
+        while window and window[0] < now - self._window:
+            window.popleft()
+        if len(window) >= self._max:
+            return False
+        window.append(now)
+        return True
+
+    def remaining(self, key: str) -> int:
+        now = time.time()
+        window = self._requests[key]
+        while window and window[0] < now - self._window:
+            window.popleft()
+        return max(0, self._max - len(window))

kryten_webqueue/auth/session.py

@@ -0,0 +1,40 @@
+import jwt
+from datetime import datetime, timedelta, UTC
+from fastapi import Request, HTTPException
+
+
+def create_session_token(username: str, rank: int, secret_key: str, ttl_hours: int = 24) -> str:
+    payload = {
+        "sub": username,
+        "rank": rank,
+        "iat": datetime.now(UTC),
+        "exp": datetime.now(UTC) + timedelta(hours=ttl_hours),
+    }
+    return jwt.encode(payload, secret_key, algorithm="HS256")
+
+
+def decode_session_token(token: str, secret_key: str) -> dict:
+    return jwt.decode(token, secret_key, algorithms=["HS256"])
+
+
+async def get_current_user(request: Request) -> dict:
+    """FastAPI dependency: extract user from session cookie."""
+    token = request.cookies.get("session")
+    if not token:
+        raise HTTPException(status_code=401, detail="Not authenticated")
+    config = request.app.state.config
+    try:
+        payload = decode_session_token(token, config.secret_key)
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(status_code=401, detail="Session expired")
+    except jwt.InvalidTokenError:
+        raise HTTPException(status_code=401, detail="Invalid session")
+    return {"username": payload["sub"], "rank": payload["rank"]}
+
+
+async def require_admin(request: Request) -> dict:
+    """FastAPI dependency: require rank >= 3."""
+    user = await get_current_user(request)
+    if user["rank"] < 3:
+        raise HTTPException(status_code=403, detail="Admin required")
+    return user