kryten-webqueue 0.1.1__py3-none-any.whl

kryten_webqueue/queue/shadow.py

@@ -0,0 +1,116 @@
+import asyncio
+import logging
+from datetime import datetime, timedelta, UTC
+
+logger = logging.getLogger(__name__)
+
+
+class QueueShadow:
+    """Local mirror of the CyTube playlist state."""
+
+    def __init__(self, db, now_playing: dict | None = None):
+        self._db = db
+        self._items: list[dict] = []
+        self._now_playing: dict | None = now_playing
+        self._lock = asyncio.Lock()
+
+    @property
+    def items(self) -> list[dict]:
+        return self._items.copy()
+
+    @property
+    def now_playing(self) -> dict | None:
+        return self._now_playing
+
+    async def load_from_db(self):
+        """Load initial state from database."""
+        self._items = await self._db.get_shadow_items()
+
+    async def apply_poll_result(self, playlist_items: list[dict], now_playing: dict | None):
+        """Reconcile polled state with local shadow."""
+        async with self._lock:
+            self._now_playing = now_playing
+
+            polled_uids = {item["uid"] for item in playlist_items}
+            local_uids = {item["uid"] for item in self._items}
+
+            # Removed items
+            removed = local_uids - polled_uids
+            if removed:
+                await self._db.remove_shadow_items(removed)
+
+            # Rebuild item list from poll result, preserving local metadata
+            local_map = {item["uid"]: item for item in self._items}
+            new_items = []
+
+            for pos, polled in enumerate(playlist_items):
+                uid = polled["uid"]
+                if uid in local_map:
+                    # Preserve local metadata, update position
+                    merged = {**local_map[uid], **polled, "position": pos}
+                else:
+                    # New item from external source
+                    merged = {
+                        "uid": uid,
+                        "position": pos,
+                        "title": polled.get("title", ""),
+                        "media_type": polled.get("type", "unknown"),
+                        "media_id": polled.get("id", ""),
+                        "duration_sec": polled.get("duration", 0),
+                        "is_pay": False,
+                        "paid_by": None,
+                        "tier": None,
+                        "z_cost": None,
+                        "schedule_id": None,
+                        "added_at": datetime.now(UTC).isoformat(),
+                    }
+                    await self._db.upsert_shadow_item(merged)
+
+                new_items.append(merged)
+
+            self._items = new_items
+            await self._recalculate_estimated_starts()
+
+    async def _recalculate_estimated_starts(self):
+        """Recalculate estimated start times based on position and now-playing."""
+        if not self._items:
+            return
+
+        # Start from now-playing elapsed or now
+        start_cursor = datetime.now(UTC)
+        if self._now_playing:
+            remaining = (self._now_playing.get("duration", 0) or 0) - (self._now_playing.get("currentTime", 0) or 0)
+            start_cursor += timedelta(seconds=max(0, remaining))
+
+        for item in self._items:
+            item["estimated_start_at"] = start_cursor.isoformat()
+            duration = item.get("duration_sec", 0) or 0
+            start_cursor += timedelta(seconds=duration)
+
+    async def insert_at(self, item: dict, position: int):
+        """Insert a new item at given position in local shadow."""
+        async with self._lock:
+            item["position"] = position
+            self._items.insert(position, item)
+            # Re-index
+            for i, it in enumerate(self._items):
+                it["position"] = i
+            await self._db.upsert_shadow_item(item)
+            await self._recalculate_estimated_starts()
+
+    async def remove(self, uid: int):
+        """Remove item from shadow."""
+        async with self._lock:
+            self._items = [it for it in self._items if it["uid"] != uid]
+            for i, it in enumerate(self._items):
+                it["position"] = i
+            await self._db.remove_shadow_items({uid})
+            await self._recalculate_estimated_starts()
+
+    def get_queue_state(self) -> dict:
+        """Return serializable queue state for WebSocket broadcast."""
+        return {
+            "items": self._items,
+            "now_playing": self._now_playing,
+            "updated_at": datetime.now(UTC).isoformat(),
+        }

kryten_webqueue/routes/admin_playlists.py

@@ -0,0 +1,98 @@
+from fastapi import APIRouter, Request, Depends, HTTPException
+from datetime import datetime
+
+from ..auth.session import require_admin
+
+router = APIRouter(prefix="/admin/playlists", tags=["admin"])
+
+
+@router.get("/")
+async def list_playlists(request: Request, user: dict = Depends(require_admin)):
+    """List all saved playlists."""
+    db = request.app.state.db
+    return await db.get_saved_playlists()
+
+
+@router.get("/{playlist_id}")
+async def get_playlist(request: Request, playlist_id: int, user: dict = Depends(require_admin)):
+    """Get a saved playlist with its items."""
+    db = request.app.state.db
+    playlist = await db.get_saved_playlist(playlist_id)
+    if not playlist:
+        raise HTTPException(404, "Playlist not found")
+    items = await db.get_saved_playlist_items(playlist_id)
+    return {**playlist, "items": items}
+
+
+@router.post("/")
+async def create_playlist(request: Request, user: dict = Depends(require_admin)):
+    """Create a new saved playlist."""
+    body = await request.json()
+    db = request.app.state.db
+    playlist_id = await db.create_saved_playlist(
+        name=body["name"],
+        description=body.get("description"),
+        is_immutable=body.get("is_immutable", False),
+        created_by=user["username"],
+    )
+    return {"id": playlist_id}
+
+
+@router.put("/{playlist_id}")
+async def update_playlist(request: Request, playlist_id: int, user: dict = Depends(require_admin)):
+    """Update playlist metadata."""
+    body = await request.json()
+    db = request.app.state.db
+    playlist = await db.get_saved_playlist(playlist_id)
+    if not playlist:
+        raise HTTPException(404, "Playlist not found")
+    await db.update_saved_playlist(
+        playlist_id,
+        name=body.get("name", playlist["name"]),
+        description=body.get("description", playlist.get("description")),
+        is_immutable=body.get("is_immutable", playlist.get("is_immutable", False)),
+    )
+    return {"success": True}
+
+
+@router.delete("/{playlist_id}")
+async def delete_playlist(request: Request, playlist_id: int, user: dict = Depends(require_admin)):
+    """Delete a saved playlist."""
+    db = request.app.state.db
+    playlist = await db.get_saved_playlist(playlist_id)
+    if not playlist:
+        raise HTTPException(404, "Playlist not found")
+    await db.delete_saved_playlist(playlist_id)
+    return {"success": True}
+
+
+@router.put("/{playlist_id}/items")
+async def replace_items(request: Request, playlist_id: int, user: dict = Depends(require_admin)):
+    """Replace all items in a playlist."""
+    body = await request.json()
+    items = body.get("items", [])
+    db = request.app.state.db
+    playlist = await db.get_saved_playlist(playlist_id)
+    if not playlist:
+        raise HTTPException(404, "Playlist not found")
+    await db.replace_playlist_items(playlist_id, items)
+    return {"success": True, "count": len(items)}
+
+
+@router.post("/{playlist_id}/import")
+async def import_to_live(request: Request, playlist_id: int, user: dict = Depends(require_admin)):
+    """Import a saved playlist into the live CyTube queue."""
+    from ..playlists.importer import PlaylistImporter
+
+    db = request.app.state.db
+    playlist = await db.get_saved_playlist(playlist_id)
+    if not playlist:
+        raise HTTPException(404, "Playlist not found")
+
+    importer = PlaylistImporter(
+        api_gate=request.app.state.api_gate,
+        db=db,
+        shadow=request.app.state.shadow,
+    )
+    result = await importer.import_playlist(playlist_id)
+    return result

kryten_webqueue/routes/admin_queue.py

@@ -0,0 +1,64 @@
+from fastapi import APIRouter, Request, Depends, HTTPException
+
+from ..auth.session import require_admin
+from ..queue.ordering import refund_item
+
+router = APIRouter(prefix="/admin/queue", tags=["admin"])
+
+
+@router.post("/clear")
+async def clear_queue(request: Request, user: dict = Depends(require_admin)):
+    """Clear the CyTube playlist (refunds all pay items)."""
+    db = request.app.state.db
+    api_gate = request.app.state.api_gate
+    shadow = request.app.state.shadow
+
+    # Refund all pay items
+    pay_items = await db.get_pay_items()
+    for item in pay_items:
+        await refund_item(api_gate=api_gate, db=db, uid=item["uid"], reason="admin_clear")
+
+    # Clear playlist
+    await api_gate.playlist_clear()
+    return {"success": True, "refunded": len(pay_items)}
+
+
+@router.delete("/{uid}")
+async def remove_item(request: Request, uid: int, user: dict = Depends(require_admin)):
+    """Remove an item from queue (with refund if paid)."""
+    db = request.app.state.db
+    api_gate = request.app.state.api_gate
+    shadow = request.app.state.shadow
+
+    # Try refund
+    await refund_item(api_gate=api_gate, db=db, uid=uid, reason="admin_remove")
+
+    # Remove from CyTube
+    await api_gate.playlist_delete(uid)
+    await shadow.remove(uid)
+    return {"success": True}
+
+
+@router.post("/{uid}/jump")
+async def jump_to(request: Request, uid: int, user: dict = Depends(require_admin)):
+    """Jump to a specific item in the playlist."""
+    api_gate = request.app.state.api_gate
+    await api_gate.playlist_jump(uid)
+    return {"success": True}
+
+
+@router.get("/sync-logs")
+async def get_sync_logs(request: Request, user: dict = Depends(require_admin)):
+    """Get recent catalog sync logs."""
+    db = request.app.state.db
+    return await db.get_sync_logs()
+
+
+@router.post("/sync-now")
+async def trigger_sync(request: Request, user: dict = Depends(require_admin)):
+    """Trigger an immediate catalog sync."""
+    catalog_sync = request.app.state.catalog_sync
+    # Run in background to not block response
+    import asyncio
+    asyncio.create_task(catalog_sync.sync())
+    return {"success": True, "message": "Sync started"}

kryten_webqueue/routes/admin_schedules.py

@@ -0,0 +1,129 @@
+from fastapi import APIRouter, Request, Depends, HTTPException
+from datetime import datetime
+
+from ..auth.session import require_admin
+
+router = APIRouter(prefix="/admin/schedules", tags=["admin"])
+
+
+@router.get("/")
+async def list_schedules(request: Request, user: dict = Depends(require_admin)):
+    """List all playlist schedules."""
+    db = request.app.state.db
+    return await db.get_schedules()
+
+
+@router.get("/active")
+async def get_active(request: Request, user: dict = Depends(require_admin)):
+    """Get the currently active schedule."""
+    db = request.app.state.db
+    active = await db.get_active_schedule()
+    return active or {}
+
+
+@router.get("/next")
+async def get_next(request: Request, user: dict = Depends(require_admin)):
+    """Get the next upcoming schedule."""
+    db = request.app.state.db
+    next_sched = await db.get_next_schedule()
+    return next_sched or {}
+
+
+@router.get("/{schedule_id}")
+async def get_schedule(request: Request, schedule_id: int, user: dict = Depends(require_admin)):
+    """Get a specific schedule."""
+    db = request.app.state.db
+    sched = await db.get_schedule(schedule_id)
+    if not sched:
+        raise HTTPException(404, "Schedule not found")
+    return sched
+
+
+@router.post("/")
+async def create_schedule(request: Request, user: dict = Depends(require_admin)):
+    """Create a new schedule."""
+    body = await request.json()
+    db = request.app.state.db
+    scheduler = request.app.state.scheduler
+
+    schedule_id = await db.create_schedule(
+        playlist_id=body["playlist_id"],
+        label=body["label"],
+        fire_at=body["fire_at"],
+        is_recurring=body.get("is_recurring", False),
+        rrule=body.get("rrule"),
+        pre_fire_lock_minutes=body.get("pre_fire_lock_minutes", 15),
+        is_active=True,
+        created_by=user["username"],
+    )
+
+    # Register with APScheduler
+    fire_at = datetime.fromisoformat(body["fire_at"])
+    await scheduler.add_schedule(schedule_id, fire_at)
+
+    return {"id": schedule_id}
+
+
+@router.put("/{schedule_id}")
+async def update_schedule(request: Request, schedule_id: int, user: dict = Depends(require_admin)):
+    """Update a schedule."""
+    body = await request.json()
+    db = request.app.state.db
+    scheduler = request.app.state.scheduler
+
+    sched = await db.get_schedule(schedule_id)
+    if not sched:
+        raise HTTPException(404, "Schedule not found")
+
+    await db.update_schedule(schedule_id, **body)
+
+    # Re-register if fire_at changed
+    if "fire_at" in body:
+        await scheduler.remove_schedule(schedule_id)
+        fire_at = datetime.fromisoformat(body["fire_at"])
+        await scheduler.add_schedule(schedule_id, fire_at)
+
+    return {"success": True}
+
+
+@router.delete("/{schedule_id}")
+async def delete_schedule(request: Request, schedule_id: int, user: dict = Depends(require_admin)):
+    """Delete a schedule."""
+    db = request.app.state.db
+    scheduler = request.app.state.scheduler
+
+    sched = await db.get_schedule(schedule_id)
+    if not sched:
+        raise HTTPException(404, "Schedule not found")
+
+    await scheduler.remove_schedule(schedule_id)
+    await db.delete_schedule(schedule_id)
+    return {"success": True}
+
+
+@router.post("/{schedule_id}/fire")
+async def fire_now(request: Request, schedule_id: int, user: dict = Depends(require_admin)):
+    """Manually fire a schedule immediately."""
+    from ..playlists.fire import fire_schedule
+
+    db = request.app.state.db
+    sched = await db.get_schedule(schedule_id)
+    if not sched:
+        raise HTTPException(404, "Schedule not found")
+
+    await fire_schedule(
+        schedule_id=schedule_id,
+        api_gate=request.app.state.api_gate,
+        db=db,
+        shadow=request.app.state.shadow,
+        ws_manager=request.app.state.ws_manager,
+    )
+    return {"success": True}
+
+
+@router.post("/clear-active")
+async def clear_active(request: Request, user: dict = Depends(require_admin)):
+    """Clear the active schedule (return to free mode)."""
+    db = request.app.state.db
+    await db.clear_active_schedule()
+    return {"success": True}

kryten_webqueue/routes/auth.py

@@ -0,0 +1,83 @@
+from fastapi import APIRouter, Request, HTTPException, Response, Depends
+
+from ..auth.otp import generate_otp, get_otp_expiry
+from ..auth.session import create_session_token, get_current_user
+
+router = APIRouter(prefix="/auth", tags=["auth"])
+
+
+@router.post("/otp/request")
+async def request_otp(request: Request):
+    """Request a one-time password delivered via PM."""
+    body = await request.json()
+    username = body.get("username", "").strip()
+    if not username:
+        raise HTTPException(400, "username required")
+
+    rate_limiter = request.app.state.rate_limiter
+    if not rate_limiter.is_allowed(f"otp:{username}"):
+        raise HTTPException(429, "Too many OTP requests. Try again later.")
+
+    # Generate OTP
+    code = generate_otp()
+    expires_at = get_otp_expiry()
+
+    # Store in DB
+    db = request.app.state.db
+    await db.store_otp(username, code, expires_at)
+
+    # Deliver via PM through api-gate
+    api_gate = request.app.state.api_gate
+    await api_gate.send_pm(username, f"Your login code: {code} (expires in 5 minutes)")
+
+    return {"success": True}
+
+
+@router.post("/otp/verify")
+async def verify_otp(request: Request, response: Response):
+    """Verify OTP and issue session cookie."""
+    body = await request.json()
+    username = body.get("username", "").strip()
+    code = body.get("code", "").strip()
+    if not username or not code:
+        raise HTTPException(400, "username and code required")
+
+    db = request.app.state.db
+    valid = await db.verify_otp(username, code)
+    if not valid:
+        raise HTTPException(401, "Invalid or expired code")
+
+    # Look up user rank from api-gate
+    api_gate = request.app.state.api_gate
+    try:
+        user_data = await api_gate.get_user(username)
+        rank = user_data.get("rank", 1) if user_data else 1
+    except Exception:
+        rank = 1
+
+    # Issue JWT session cookie
+    config = request.app.state.config
+    token = create_session_token(username, rank, config.secret_key, config.session_ttl_hours)
+
+    response.set_cookie(
+        key="session",
+        value=token,
+        httponly=True,
+        secure=True,
+        samesite="strict",
+        max_age=config.session_ttl_hours * 3600,
+    )
+    return {"success": True, "username": username, "rank": rank}
+
+
+@router.post("/logout")
+async def logout(response: Response, user: dict = Depends(get_current_user)):
+    """Clear session cookie."""
+    response.delete_cookie("session")
+    return {"success": True}
+
+
+@router.get("/me")
+async def me(user: dict = Depends(get_current_user)):
+    """Return current session info."""
+    return user

kryten_webqueue/routes/catalog.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter, Request, Depends, HTTPException
+
+from ..auth.session import get_current_user
+
+router = APIRouter(prefix="/catalog", tags=["catalog"])
+
+
+@router.get("/browse")
+async def browse(request: Request, category: str | None = None, page: int = 1,
+                 user: dict = Depends(get_current_user)):
+    """Browse catalog with optional category filter."""
+    db = request.app.state.db
+    items = await db.browse(category=category, page=page)
+    categories = await db.get_categories()
+    return {"items": items, "categories": categories, "page": page}
+
+
+@router.get("/search")
+async def search(request: Request, q: str = "", page: int = 1,
+                 user: dict = Depends(get_current_user)):
+    """Full-text search of catalog."""
+    if not q.strip():
+        raise HTTPException(400, "Query required")
+    db = request.app.state.db
+    items = await db.search(q, page=page)
+    return {"items": items, "query": q, "page": page}
+
+
+@router.get("/item/{friendly_token}")
+async def get_item(request: Request, friendly_token: str,
+                   user: dict = Depends(get_current_user)):
+    """Get single catalog item detail."""
+    db = request.app.state.db
+    item = await db.get_item(friendly_token)
+    if not item:
+        raise HTTPException(404, "Item not found")
+    return item
+
+
+@router.get("/categories")
+async def list_categories(request: Request, user: dict = Depends(get_current_user)):
+    """List all categories."""
+    db = request.app.state.db
+    return await db.get_categories()

kryten_webqueue/routes/pages.py

@@ -0,0 +1,82 @@
+from fastapi import APIRouter, Request, Depends
+from fastapi.responses import HTMLResponse, RedirectResponse
+from fastapi.templating import Jinja2Templates
+from pathlib import Path
+
+from ..auth.session import get_current_user
+
+templates = Jinja2Templates(directory=str(Path(__file__).parent.parent / "templates"))
+
+router = APIRouter(tags=["pages"])
+
+
+def _get_user_or_none(request: Request) -> dict | None:
+    """Non-throwing user extraction for page rendering."""
+    token = request.cookies.get("session")
+    if not token:
+        return None
+    import jwt
+    try:
+        payload = jwt.decode(token, request.app.state.config.secret_key, algorithms=["HS256"])
+        return {"username": payload["sub"], "rank": payload["rank"]}
+    except Exception:
+        return None
+
+
+@router.get("/", response_class=HTMLResponse)
+async def home(request: Request):
+    user = _get_user_or_none(request)
+    if user:
+        return RedirectResponse("/catalog/browse")
+    return RedirectResponse("/auth/login")
+
+
+@router.get("/auth/login", response_class=HTMLResponse)
+async def login_page(request: Request):
+    user = _get_user_or_none(request)
+    if user:
+        return RedirectResponse("/catalog/browse")
+    return templates.TemplateResponse("auth/login.html", {"request": request, "user": None})
+
+
+@router.get("/catalog/browse", response_class=HTMLResponse)
+async def catalog_browse_page(request: Request, category: str | None = None, page: int = 1):
+    user = _get_user_or_none(request)
+    if not user:
+        return RedirectResponse("/auth/login")
+    db = request.app.state.db
+    items = await db.browse(category=category, page=page)
+    categories = await db.get_categories()
+    return templates.TemplateResponse("catalog/browse.html", {
+        "request": request,
+        "user": user,
+        "items": items,
+        "categories": categories,
+        "page": page,
+        "active_category": category,
+        "query": None,
+    })
+
+
+@router.get("/queue", response_class=HTMLResponse)
+async def queue_page(request: Request):
+    user = _get_user_or_none(request)
+    if not user:
+        return RedirectResponse("/auth/login")
+    return templates.TemplateResponse("queue/index.html", {"request": request, "user": user})
+
+
+@router.get("/user/dashboard", response_class=HTMLResponse)
+async def user_dashboard_page(request: Request):
+    user = _get_user_or_none(request)
+    if not user:
+        return RedirectResponse("/auth/login")
+    return templates.TemplateResponse("user/dashboard.html", {"request": request, "user": user})
+
+
+@router.get("/admin", response_class=HTMLResponse)
+async def admin_page(request: Request):
+    user = _get_user_or_none(request)
+    if not user or user.get("rank", 0) < 3:
+        return RedirectResponse("/auth/login")
+    return templates.TemplateResponse("admin/index.html", {"request": request, "user": user})