Delete main.py

main.py

@@ -1,1312 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import os
-import sqlite3
-import socket
-import time
-import base64
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any, Optional
-
-import discord
-from discord import app_commands
-from discord.ext import tasks
-from fastapi import FastAPI
-import aiohttp
-import uvicorn
-import requests
-import yarl
-
-from tracker_client import TrackerClient, TrackerError
-
-APP_DIR = Path(__file__).resolve().parent
-DB_PATH = Path(os.getenv("DB_PATH", str(APP_DIR / "rocket_watch.db")))
-POLL_SECONDS = max(60, int(os.getenv("POLL_SECONDS", "120")))
-ALERT_MAX_AGE_MINUTES = max(5, int(os.getenv("ALERT_MAX_AGE_MINUTES", "30")))
-DISCORD_BOT_TOKEN = os.getenv("DISCORD_BOT_TOKEN", "").strip()
-GUILD_ID = os.getenv("DISCORD_GUILD_ID", "").strip()
-DISCORD_LOGIN_TIMEOUT = max(5, int(os.getenv("DISCORD_LOGIN_TIMEOUT", "20")))
-DISCORD_READY_TIMEOUT = max(10, int(os.getenv("DISCORD_READY_TIMEOUT", "30")))
-DISCORD_RELAY_ORIGIN = (os.getenv("DISCORD_RELAY_ORIGIN") or os.getenv("DISCORD_PROXY_ORIGIN", "")).strip().rstrip("/")
-DISCORD_RELAY_SECRET = (os.getenv("DISCORD_RELAY_SECRET") or os.getenv("DISCORD_PROXY_SECRET", "")).strip().strip("/")
-GHT = os.getenv("GHT", "").strip()
-GITHUB_DATA_REPO = os.getenv("GITHUB_DATA_REPO", "Wuhpondiscord/rldevs").strip()
-GITHUB_DATA_BRANCH = os.getenv("GITHUB_DATA_BRANCH", "main").strip() or "main"
-GITHUB_SYNC_ACTIVITY_LIMIT = max(100, int(os.getenv("GITHUB_SYNC_ACTIVITY_LIMIT", "5000")))
-GITHUB_AUTO_SYNC_SECONDS = max(60, int(os.getenv("GITHUB_AUTO_SYNC_SECONDS", "300")))
-
-logging.basicConfig(
-    level=os.getenv("LOG_LEVEL", "INFO").upper(),
-    format="%(asctime)s | %(levelname)s | %(name)s | %(message)s",
-)
-log = logging.getLogger("rocket-watch")
-
-
-def configure_discord_relay() -> Optional[str]:
-    """Route discord.py REST + Gateway traffic through the external Deno relay.
-
-    The relay uses a secret path segment so it cannot be used as an open Discord
-    proxy by anyone who does not know the shared secret. The bot token is not
-    stored in the relay; discord.py sends it as the normal Authorization header.
-    """
-    if not DISCORD_RELAY_ORIGIN and not DISCORD_RELAY_SECRET:
-        return None
-    if not DISCORD_RELAY_ORIGIN or not DISCORD_RELAY_SECRET:
-        raise RuntimeError(
-            "Set both DISCORD_RELAY_ORIGIN and DISCORD_RELAY_SECRET, or neither."
-        )
-    if not DISCORD_RELAY_ORIGIN.startswith("https://"):
-        raise RuntimeError("DISCORD_RELAY_ORIGIN must start with https://")
-
-    from discord.http import Route
-    from discord.gateway import DiscordWebSocket
-
-    rest_base = f"{DISCORD_RELAY_ORIGIN}/p/{DISCORD_RELAY_SECRET}/api/v10"
-    gateway = DISCORD_RELAY_ORIGIN.replace("https://", "wss://", 1)
-    gateway = f"{gateway}/p/{DISCORD_RELAY_SECRET}/gateway"
-
-    Route.BASE = rest_base
-    DiscordWebSocket.DEFAULT_GATEWAY = yarl.URL(gateway)
-
-    # Discord's READY event contains a direct resume_gateway_url. discord.py stores
-    # that URL for later RESUME attempts. Restore our proxy URL immediately after
-    # READY/RESUMED processing so reconnects never escape the relay.
-    original_received_message = DiscordWebSocket.received_message
-
-    async def proxied_received_message(self, msg):
-        result = await original_received_message(self, msg)
-        if getattr(self, "session_id", None) and str(getattr(self, "gateway", "")) != gateway:
-            self.gateway = yarl.URL(gateway)
-        return result
-
-    if not getattr(DiscordWebSocket.received_message, "_rocket_watch_proxy_patch", False):
-        proxied_received_message._rocket_watch_proxy_patch = True
-        DiscordWebSocket.received_message = proxied_received_message
-
-    log.info("Discord relay enabled through %s", DISCORD_RELAY_ORIGIN)
-    return gateway
-
-
-DISCORD_RELAY_GATEWAY = configure_discord_relay()
-
-
-def utc_now_iso() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def parse_dt(value: Optional[str]) -> Optional[datetime]:
-    if not value:
-        return None
-    try:
-        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
-        if dt.tzinfo is None:
-            dt = dt.replace(tzinfo=timezone.utc)
-        return dt.astimezone(timezone.utc)
-    except ValueError:
-        return None
-
-
-def age_text(value: Optional[str]) -> str:
-    dt = parse_dt(value)
-    if not dt:
-        return "unknown"
-    sec = max(0, int((datetime.now(timezone.utc) - dt).total_seconds()))
-    if sec < 60:
-        return f"{sec}s ago"
-    if sec < 3600:
-        return f"{sec // 60}m ago"
-    if sec < 86400:
-        return f"{sec // 3600}h {(sec % 3600) // 60}m ago"
-    return f"{sec // 86400}d ago"
-
-
-def discord_time(value: Optional[str], style: str = "F") -> str:
-    """Render a timestamp in each Discord viewer's own locale/timezone."""
-    dt = parse_dt(value)
-    if not dt:
-        return "unknown"
-    return f"<t:{int(dt.timestamp())}:{style}>"
-
-
-def queue_window_text(value: Optional[str]) -> str:
-    """Conservative inference from Tracker collection time; never claims live presence."""
-    dt = parse_dt(value)
-    if not dt:
-        return "Unknown"
-    age_min = max(0, (datetime.now(timezone.utc) - dt).total_seconds() / 60)
-    if age_min <= 3:
-        return "**Very fresh result** — strongest window to try the same playlist/MMR"
-    if age_min <= 8:
-        return "**Fresh** — they may still be playing or re-queueing"
-    if age_min <= 20:
-        return "**Recent** — useful signal, but queue status is uncertain"
-    return "**Stale** — weak signal for current matchmaking"
-
-
-def activity_label(value: Optional[str]) -> str:
-    dt = parse_dt(value)
-    if not dt:
-        return "UNKNOWN"
-    age = (datetime.now(timezone.utc) - dt).total_seconds()
-    if age <= 8 * 60:
-        return "HOT"
-    if age <= 20 * 60:
-        return "RECENT"
-    if age <= 60 * 60:
-        return "COOLING"
-    return "INACTIVE"
-
-
-def trunc(s: str, n: int) -> str:
-    return s if len(s) <= n else s[: n - 1] + "…"
-
-
-class Store:
-    def __init__(self, path: Path):
-        self.path = path
-        self.path.parent.mkdir(parents=True, exist_ok=True)
-        self._init()
-
-    def conn(self):
-        conn = sqlite3.connect(self.path, timeout=30)
-        conn.row_factory = sqlite3.Row
-        return conn
-
-    def _init(self):
-        with self.conn() as c:
-            c.executescript(
-                """
-                PRAGMA journal_mode=WAL;
-                CREATE TABLE IF NOT EXISTS players (
-                    id INTEGER PRIMARY KEY,
-                    guild_id INTEGER NOT NULL,
-                    label TEXT NOT NULL,
-                    platform TEXT NOT NULL,
-                    identifier TEXT NOT NULL,
-                    handle TEXT,
-                    tracker_player_id INTEGER,
-                    alert_channel_id INTEGER,
-                    enabled INTEGER NOT NULL DEFAULT 1,
-                    created_at TEXT NOT NULL,
-                    alert_watermark_at TEXT,
-                    UNIQUE(guild_id, platform, identifier)
-                );
-
-                CREATE TABLE IF NOT EXISTS snapshots (
-                    id INTEGER PRIMARY KEY,
-                    player_id INTEGER NOT NULL,
-                    observed_at TEXT NOT NULL,
-                    tracker_updated_at TEXT,
-                    playlist_json TEXT NOT NULL,
-                    FOREIGN KEY(player_id) REFERENCES players(id)
-                );
-                CREATE INDEX IF NOT EXISTS idx_snapshots_player_time
-                    ON snapshots(player_id, observed_at DESC);
-
-                CREATE TABLE IF NOT EXISTS matches (
-                    id INTEGER PRIMARY KEY,
-                    player_id INTEGER NOT NULL,
-                    external_id TEXT NOT NULL,
-                    collected_at TEXT,
-                    playlist TEXT,
-                    result TEXT,
-                    rating INTEGER,
-                    rating_delta INTEGER,
-                    tier TEXT,
-                    division TEXT,
-                    is_grouped INTEGER,
-                    matches_played INTEGER,
-                    wins INTEGER,
-                    goals INTEGER,
-                    assists INTEGER,
-                    saves INTEGER,
-                    shots INTEGER,
-                    mvps INTEGER,
-                    first_seen_at TEXT NOT NULL,
-                    raw_json TEXT,
-                    FOREIGN KEY(player_id) REFERENCES players(id),
-                    UNIQUE(player_id, external_id)
-                );
-                CREATE INDEX IF NOT EXISTS idx_matches_player_collected
-                    ON matches(player_id, collected_at DESC);
-                """
-            )
-            cols = {row["name"] for row in c.execute("PRAGMA table_info(players)")}
-            if "alert_watermark_at" not in cols:
-                c.execute("ALTER TABLE players ADD COLUMN alert_watermark_at TEXT")
-
-    def add_player(self, guild_id: int, label: str, platform: str, identifier: str, channel_id: int) -> int:
-        with self.conn() as c:
-            c.execute(
-                """
-                INSERT INTO players(guild_id,label,platform,identifier,alert_channel_id,created_at)
-                VALUES(?,?,?,?,?,?)
-                ON CONFLICT(guild_id, platform, identifier) DO UPDATE SET
-                    label=excluded.label,
-                    alert_channel_id=excluded.alert_channel_id,
-                    enabled=1
-                """,
-                (guild_id, label, platform, identifier, channel_id, utc_now_iso()),
-            )
-            row = c.execute(
-                "SELECT id FROM players WHERE guild_id=? AND platform=? AND identifier=?",
-                (guild_id, platform, identifier),
-            ).fetchone()
-            return int(row["id"])
-
-    def remove_player(self, guild_id: int, query: str) -> bool:
-        with self.conn() as c:
-            cur = c.execute(
-                "DELETE FROM players WHERE guild_id=? AND (label=? COLLATE NOCASE OR identifier=? COLLATE NOCASE)",
-                (guild_id, query, query),
-            )
-            return cur.rowcount > 0
-
-    def players(self, guild_id: Optional[int] = None):
-        with self.conn() as c:
-            if guild_id is None:
-                return c.execute("SELECT * FROM players WHERE enabled=1 ORDER BY guild_id,label").fetchall()
-            return c.execute(
-                "SELECT * FROM players WHERE enabled=1 AND guild_id=? ORDER BY label COLLATE NOCASE",
-                (guild_id,),
-            ).fetchall()
-
-    def get_player(self, guild_id: int, query: str):
-        with self.conn() as c:
-            return c.execute(
-                """
-                SELECT * FROM players
-                WHERE guild_id=? AND enabled=1
-                  AND (label=? COLLATE NOCASE OR handle=? COLLATE NOCASE OR identifier=? COLLATE NOCASE)
-                LIMIT 1
-                """,
-                (guild_id, query, query, query),
-            ).fetchone()
-
-    def update_identity(self, player_id: int, handle: str, tracker_player_id: Optional[int]):
-        with self.conn() as c:
-            c.execute(
-                "UPDATE players SET handle=?, tracker_player_id=? WHERE id=?",
-                (handle, tracker_player_id, player_id),
-            )
-
-    def set_alert_watermark(self, player_id: int, value: Optional[str]) -> None:
-        if not value:
-            return
-        with self.conn() as c:
-            c.execute("UPDATE players SET alert_watermark_at=? WHERE id=?", (value, player_id))
-
-    def ensure_alert_watermark(self, player_id: int) -> Optional[str]:
-        with self.conn() as c:
-            row = c.execute("SELECT alert_watermark_at, created_at FROM players WHERE id=?", (player_id,)).fetchone()
-            if not row:
-                return None
-            if row["alert_watermark_at"]:
-                return row["alert_watermark_at"]
-            latest = c.execute(
-                "SELECT collected_at FROM matches WHERE player_id=? AND collected_at IS NOT NULL ORDER BY collected_at DESC LIMIT 1",
-                (player_id,),
-            ).fetchone()
-            value = latest["collected_at"] if latest else row["created_at"]
-            c.execute("UPDATE players SET alert_watermark_at=? WHERE id=?", (value, player_id))
-            return value
-
-    def add_snapshot(self, player_id: int, profile) -> None:
-        with self.conn() as c:
-            c.execute(
-                "INSERT INTO snapshots(player_id,observed_at,tracker_updated_at,playlist_json) VALUES(?,?,?,?)",
-                (
-                    player_id,
-                    utc_now_iso(),
-                    profile.last_updated.isoformat() if profile.last_updated else None,
-                    json.dumps(profile.playlists, separators=(",", ":")),
-                ),
-            )
-
-    def latest_snapshot(self, player_id: int):
-        with self.conn() as c:
-            return c.execute(
-                "SELECT * FROM snapshots WHERE player_id=? ORDER BY observed_at DESC LIMIT 1",
-                (player_id,),
-            ).fetchone()
-
-    def insert_matches(self, player_id: int, matches: list[dict[str, Any]]) -> list[dict[str, Any]]:
-        newly_added: list[dict[str, Any]] = []
-        with self.conn() as c:
-            for m in matches:
-                ext = m.get("match_id")
-                if not ext:
-                    continue
-                cur = c.execute(
-                    """
-                    INSERT OR IGNORE INTO matches(
-                        player_id,external_id,collected_at,playlist,result,rating,rating_delta,tier,division,
-                        is_grouped,matches_played,wins,goals,assists,saves,shots,mvps,first_seen_at,raw_json
-                    ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
-                    """,
-                    (
-                        player_id, ext, m.get("collected_at"), m.get("playlist"), m.get("result"),
-                        m.get("rating"), m.get("rating_delta"), m.get("tier"), m.get("division"),
-                        int(bool(m.get("is_grouped"))), m.get("matches_played"), m.get("wins"),
-                        m.get("goals"), m.get("assists"), m.get("saves"), m.get("shots"), m.get("mvps"),
-                        utc_now_iso(), json.dumps(m, separators=(",", ":")),
-                    ),
-                )
-                if cur.rowcount:
-                    newly_added.append(m)
-        return newly_added
-
-    def recent_matches(self, player_id: int, limit: int = 10):
-        with self.conn() as c:
-            return c.execute(
-                "SELECT * FROM matches WHERE player_id=? ORDER BY collected_at DESC LIMIT ?",
-                (player_id, limit),
-            ).fetchall()
-
-    def latest_match(self, player_id: int):
-        rows = self.recent_matches(player_id, 1)
-        return rows[0] if rows else None
-
-
-    def export_players(self) -> list[dict[str, Any]]:
-        with self.conn() as c:
-            rows = c.execute("SELECT * FROM players ORDER BY guild_id,label COLLATE NOCASE").fetchall()
-        return [dict(r) for r in rows]
-
-    def export_matches(self, limit: int = 5000) -> list[dict[str, Any]]:
-        with self.conn() as c:
-            rows = c.execute(
-                """
-                SELECT p.guild_id,p.platform,p.identifier,p.label,m.*
-                FROM matches m JOIN players p ON p.id=m.player_id
-                ORDER BY m.collected_at DESC, m.id DESC LIMIT ?
-                """,
-                (limit,),
-            ).fetchall()
-        out = []
-        for r in rows:
-            d = dict(r)
-            d.pop("id", None)
-            d.pop("player_id", None)
-            out.append(d)
-        return out
-
-    def restore_player(self, item: dict[str, Any]) -> Optional[int]:
-        try:
-            guild_id = int(item["guild_id"])
-            platform = str(item["platform"])
-            identifier = str(item["identifier"])
-            label = str(item.get("label") or identifier)
-            channel_id = int(item.get("alert_channel_id") or 0)
-        except (KeyError, TypeError, ValueError):
-            return None
-        with self.conn() as c:
-            c.execute(
-                """
-                INSERT INTO players(
-                    guild_id,label,platform,identifier,handle,tracker_player_id,
-                    alert_channel_id,enabled,created_at,alert_watermark_at
-                ) VALUES(?,?,?,?,?,?,?,?,?,?)
-                ON CONFLICT(guild_id,platform,identifier) DO UPDATE SET
-                    label=excluded.label,
-                    handle=COALESCE(excluded.handle,players.handle),
-                    tracker_player_id=COALESCE(excluded.tracker_player_id,players.tracker_player_id),
-                    alert_channel_id=CASE WHEN excluded.alert_channel_id>0 THEN excluded.alert_channel_id ELSE players.alert_channel_id END,
-                    enabled=excluded.enabled,
-                    alert_watermark_at=COALESCE(excluded.alert_watermark_at,players.alert_watermark_at)
-                """,
-                (
-                    guild_id,label,platform,identifier,item.get("handle"),item.get("tracker_player_id"),
-                    channel_id,int(item.get("enabled",1)),item.get("created_at") or utc_now_iso(),item.get("alert_watermark_at"),
-                ),
-            )
-            row=c.execute(
-                "SELECT id FROM players WHERE guild_id=? AND platform=? AND identifier=?",
-                (guild_id,platform,identifier),
-            ).fetchone()
-            return int(row["id"]) if row else None
-
-    def restore_match(self, player_id: int, item: dict[str, Any]) -> None:
-        ext = item.get("external_id") or item.get("match_id")
-        if not ext:
-            return
-        with self.conn() as c:
-            c.execute(
-                """
-                INSERT OR IGNORE INTO matches(
-                    player_id,external_id,collected_at,playlist,result,rating,rating_delta,tier,division,
-                    is_grouped,matches_played,wins,goals,assists,saves,shots,mvps,first_seen_at,raw_json
-                ) VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
-                """,
-                (
-                    player_id,ext,item.get("collected_at"),item.get("playlist"),item.get("result"),
-                    item.get("rating"),item.get("rating_delta"),item.get("tier"),item.get("division"),
-                    int(bool(item.get("is_grouped"))),item.get("matches_played"),item.get("wins"),
-                    item.get("goals"),item.get("assists"),item.get("saves"),item.get("shots"),item.get("mvps"),
-                    item.get("first_seen_at") or utc_now_iso(),item.get("raw_json") or json.dumps(item,separators=(",",":")),
-                ),
-            )
-
-
-class GitHubDataStore:
-    API = "https://api.github.com"
-
-    def __init__(self, token: str, repo: str, branch: str = "main"):
-        self.token = token
-        self.repo = repo
-        self.branch = branch
-        self.enabled = bool(token and repo)
-        self.session = requests.Session()
-        if self.enabled:
-            self.session.headers.update({
-                "Authorization": f"Bearer {token}",
-                "Accept": "application/vnd.github+json",
-                "X-GitHub-Api-Version": "2022-11-28",
-                "User-Agent": "rocket-watch-hf/1.0",
-            })
-        self.last_sync_at: Optional[str] = None
-        self.last_error: Optional[str] = None
-
-    def _url(self, path: str) -> str:
-        return f"{self.API}/repos/{self.repo}/contents/{path}"
-
-    def read_json(self, path: str, default: dict[str, Any]) -> tuple[dict[str, Any], Optional[str]]:
-        if not self.enabled:
-            return default, None
-        r = self.session.get(self._url(path), params={"ref": self.branch}, timeout=20)
-        if r.status_code == 404:
-            return default, None
-        r.raise_for_status()
-        payload = r.json()
-        raw = base64.b64decode(payload.get("content", "")).decode("utf-8")
-        return json.loads(raw), payload.get("sha")
-
-    def write_json(self, path: str, data: dict[str, Any], message: str) -> None:
-        if not self.enabled:
-            return
-        _, sha = self.read_json(path, {})
-        body = {
-            "message": message,
-            "content": base64.b64encode((json.dumps(data, indent=2, sort_keys=False) + "\n").encode()).decode(),
-            "branch": self.branch,
-        }
-        if sha:
-            body["sha"] = sha
-        r = self.session.put(self._url(path), json=body, timeout=30)
-        r.raise_for_status()
-
-    def ensure_files(self) -> None:
-        if not self.enabled:
-            return
-        defaults = {
-            "datasets/users.json": {"schema_version": 1, "updated_at": None, "players": []},
-            "datasets/activity.json": {"schema_version": 1, "updated_at": None, "matches": []},
-        }
-        for path, default in defaults.items():
-            data, sha = self.read_json(path, default)
-            if sha is None:
-                self.write_json(path, data, f"Create {path}")
-
-    def restore_into(self, store: Store) -> dict[str, int]:
-        if not self.enabled:
-            return {"players": 0, "matches": 0}
-        users, _ = self.read_json("datasets/users.json", {"players": []})
-        activity, _ = self.read_json("datasets/activity.json", {"matches": []})
-        key_to_id: dict[tuple[int,str,str], int] = {}
-        restored_players = 0
-        for item in users.get("players") or []:
-            pid = store.restore_player(item)
-            if pid is not None:
-                key_to_id[(int(item["guild_id"]), str(item["platform"]), str(item["identifier"]))] = pid
-                restored_players += 1
-        restored_matches = 0
-        for item in activity.get("matches") or []:
-            try:
-                key = (int(item["guild_id"]), str(item["platform"]), str(item["identifier"]))
-            except (KeyError, TypeError, ValueError):
-                continue
-            pid = key_to_id.get(key)
-            if pid is None:
-                row = store.get_player(key[0], key[2])
-                pid = int(row["id"]) if row else None
-            if pid is not None:
-                store.restore_match(pid, item)
-                restored_matches += 1
-        self.last_sync_at = utc_now_iso()
-        self.last_error = None
-        return {"players": restored_players, "matches": restored_matches}
-
-    def push_all(self, store: Store, reason: str = "Sync RL dev tracker datasets") -> None:
-        if not self.enabled:
-            return
-        now = utc_now_iso()
-        users = {"schema_version": 1, "updated_at": now, "players": store.export_players()}
-        activity = {"schema_version": 1, "updated_at": now, "matches": store.export_matches(GITHUB_SYNC_ACTIVITY_LIMIT)}
-        self.write_json("datasets/users.json", users, f"{reason}: users")
-        self.write_json("datasets/activity.json", activity, f"{reason}: activity")
-        self.last_sync_at = now
-        self.last_error = None
-
-
-github_data = GitHubDataStore(GHT, GITHUB_DATA_REPO, GITHUB_DATA_BRANCH)
-
-
-store = Store(DB_PATH)
-tracker = TrackerClient()
-
-
-async def github_push(reason: str = "Sync RL dev tracker datasets") -> bool:
-    if not github_data.enabled:
-        return False
-    try:
-        await asyncio.to_thread(github_data.push_all, store, reason)
-        return True
-    except Exception as exc:
-        github_data.last_error = f"{type(exc).__name__}: {exc}"
-        log.warning("GitHub dataset sync failed: %s", exc)
-        return False
-
-
-intents = discord.Intents.default()
-client = discord.Client(intents=intents)
-tree = app_commands.CommandTree(client)
-
-# Runtime state used by the health endpoint.
-runtime = {
-    "discord_connected": False,
-    "discord_user": None,
-    "discord_last_error": None,
-    "discord_last_attempt": None,
-    "discord_last_connected": None,
-    "discord_retry_seconds": None,
-    "discord_stage": "idle",
-    "discord_stage_since": None,
-}
-
-
-async def fetch_and_store(player_row, *, seed: bool = False) -> tuple[Any, list[dict[str, Any]]]:
-    profile = await asyncio.to_thread(tracker.profile, player_row["platform"], player_row["identifier"])
-    sessions_payload = await asyncio.to_thread(tracker.sessions, player_row["platform"], player_row["identifier"])
-    matches = tracker.flatten_session_matches(sessions_payload)
-
-    store.update_identity(player_row["id"], profile.handle, profile.player_id)
-    store.add_snapshot(player_row["id"], profile)
-    new_matches = store.insert_matches(player_row["id"], matches)
-
-    # On initial add, establish a watermark at the newest historical match. Tracker can
-    # reveal older/grouped rows later, and those must never be announced as live activity.
-    if seed:
-        dated = [m for m in matches if parse_dt(m.get("collected_at"))]
-        if dated:
-            newest = max(dated, key=lambda m: parse_dt(m.get("collected_at")))
-            store.set_alert_watermark(player_row["id"], newest.get("collected_at"))
-        else:
-            store.set_alert_watermark(player_row["id"], utc_now_iso())
-        return profile, []
-
-    return profile, new_matches
-
-
-def profile_embed(player_row, profile, latest_match=None) -> discord.Embed:
-    e = discord.Embed(
-        title=f"{profile.handle} — Rocket League",
-        description=f"{profile.platform.upper()} • Season {profile.season or '?'}",
-        color=discord.Color.blurple(),
-        timestamp=datetime.now(timezone.utc),
-    )
-    if profile.avatar_url:
-        e.set_thumbnail(url=profile.avatar_url)
-
-    if latest_match:
-        e.add_field(
-            name="Activity",
-            value=f"**{activity_label(latest_match['collected_at'])}** • {discord_time(latest_match['collected_at'], 'R')}\n{discord_time(latest_match['collected_at'], 'f')}",
-            inline=True,
-        )
-        e.add_field(name="Last mode", value=latest_match["playlist"] or "Unknown", inline=True)
-        if latest_match["rating"] is not None:
-            delta = latest_match["rating_delta"]
-            ds = f" ({delta:+d})" if delta is not None else ""
-            e.add_field(name="Last MMR", value=f"{latest_match['rating']}{ds}", inline=True)
-
-    ranked = [p for p in profile.playlists if p.get("rating") is not None]
-    ranked.sort(key=lambda p: ("Ranked" not in (p.get("name") or ""), p.get("name") or ""))
-    for p in ranked[:10]:
-        rank = " ".join(x for x in [p.get("tier"), p.get("division")] if x) or "—"
-        peak = f" • peak {p['peak_rating']}" if p.get("peak_rating") is not None else ""
-        e.add_field(
-            name=trunc(p.get("name") or "Playlist", 256),
-            value=f"**{p['rating']} MMR** • {rank}{peak}",
-            inline=False,
-        )
-    e.set_footer(text="Tracker collection times can lag actual in-game activity.")
-    return e
-
-
-def match_embed(player_row, match: dict[str, Any]) -> discord.Embed:
-    rating = match.get("rating")
-    delta = match.get("rating_delta")
-    mmr = "Unknown"
-    if rating is not None:
-        mmr = str(rating)
-        if delta is not None:
-            mmr += f" ({delta:+d})"
-    result = match.get("result") or "activity"
-    e = discord.Embed(
-        title=f"New RL activity — {player_row['label']}",
-        description=f"**{match.get('playlist') or 'Unknown playlist'}** • {result}",
-        color=discord.Color.green() if str(result).lower() == "victory" else discord.Color.orange(),
-        timestamp=parse_dt(match.get("collected_at")) or datetime.now(timezone.utc),
-    )
-    e.add_field(name="MMR", value=mmr, inline=True)
-    rank = " ".join(x for x in [match.get("tier"), match.get("division")] if x)
-    if rank:
-        e.add_field(name="Rank", value=rank, inline=True)
-    e.add_field(
-        name="Observed",
-        value=f"{discord_time(match.get('collected_at'), 'R')}\n{discord_time(match.get('collected_at'), 'f')}",
-        inline=True,
-    )
-    e.add_field(name="Matchmaking signal", value=queue_window_text(match.get("collected_at")), inline=False)
-    stats = []
-    for k, label in [("goals", "G"), ("assists", "A"), ("saves", "S"), ("shots", "Shots")]:
-        if match.get(k) is not None:
-            stats.append(f"{label}: {match[k]}")
-    if stats:
-        e.add_field(name="Stats", value=" • ".join(stats), inline=False)
-    e.set_footer(text="Activity is inferred from Tracker updates; it is not a direct online-status signal.")
-    return e
-
-
-@client.event
-async def on_ready():
-    runtime["discord_connected"] = True
-    runtime["discord_user"] = str(client.user) if client.user else None
-    runtime["discord_last_connected"] = utc_now_iso()
-    runtime["discord_last_error"] = None
-    runtime["discord_retry_seconds"] = None
-    log.info("Logged in as %s (%s)", client.user, client.user.id if client.user else "?")
-    if not watcher.is_running():
-        watcher.change_interval(seconds=POLL_SECONDS)
-        watcher.start()
-    if github_data.enabled and not github_auto_sync.is_running():
-        github_auto_sync.change_interval(seconds=GITHUB_AUTO_SYNC_SECONDS)
-        github_auto_sync.start()
-
-
-@client.event
-async def on_disconnect():
-    runtime["discord_connected"] = False
-
-
-
-
-@tree.command(name="help", description="Explain the tracker commands, alerts, and GitHub persistence")
-async def help_cmd(interaction: discord.Interaction):
-    e = discord.Embed(
-        title="Dev Stalker — Help",
-        description=(
-            "Tracks public Rocket League Tracker activity for selected accounts. "
-            "Tracker data can lag, so freshness is an inference rather than direct online/queue status."
-        ),
-        color=discord.Color.blurple(),
-    )
-    e.add_field(
-        name="Tracking",
-        value=(
-            "`/track_add` — add an Epic/Steam/Xbox/PSN account and alert this channel.\n"
-            "`/track_remove` — stop tracking an account.\n"
-            "`/track_list` — list accounts tracked in this server.\n"
-            "`/rl_refresh` — force an immediate Tracker refresh for all tracked accounts."
-        ),
-        inline=False,
-    )
-    e.add_field(
-        name="Player info",
-        value=(
-            "`/rl_player` — current profile, ranks/MMR, and latest observed activity.\n"
-            "`/rl_recent` — recent recorded matches/activity with local Discord timestamps.\n"
-            "`/watch_status` — compact playlist/MMR/freshness view for one target.\n"
-            "`/watch_hot` — rank tracked targets by freshest observed activity."
-        ),
-        inline=False,
-    )
-    e.add_field(
-        name="GitHub persistence",
-        value=(
-            "GitHub backup is automatic. Adds/removes/new activity trigger immediate syncs, and a "
-            f"background safety sync runs about every **{GITHUB_AUTO_SYNC_SECONDS // 60 or 1} minute(s)**.\n"
-            "`/github_status` — show persistence health and last successful sync.\n"
-            "`/github_sync` — manually force a backup if you suspect something went wrong."
-        ),
-        inline=False,
-    )
-    e.add_field(
-        name="Alert behavior",
-        value=(
-            "Historical matches are seeded silently when a player is first added. Grouped `Multiple` rows are "
-            "kept in history but suppressed from live alerts. Discord timestamps render in each viewer's local timezone."
-        ),
-        inline=False,
-    )
-    e.set_footer(text="Use /github_status if persistence ever looks unhealthy.")
-    await interaction.response.send_message(embed=e, ephemeral=True)
-
-
-@tree.command(name="track_add", description="Track a Rocket League account and alert this channel on new activity")
-@app_commands.describe(platform="steam, epic, xbox, or psn", identifier="Tracker-compatible account identifier", label="Short name shown by the bot")
-async def track_add(interaction: discord.Interaction, platform: str, identifier: str, label: Optional[str] = None):
-    if not interaction.guild_id or not interaction.channel_id:
-        await interaction.response.send_message("Use this command inside a server channel.", ephemeral=True)
-        return
-    platform = platform.strip().lower()
-    aliases = {"xbox": "xbl", "playstation": "psn", "epicgames": "epic"}
-    platform = aliases.get(platform, platform)
-    if platform not in {"steam", "epic", "xbl", "psn"}:
-        await interaction.response.send_message("Platform must be `steam`, `epic`, `xbl`, or `psn`.", ephemeral=True)
-        return
-
-    await interaction.response.defer(ephemeral=True)
-    row_id = store.add_player(interaction.guild_id, label or identifier, platform, identifier.strip(), interaction.channel_id)
-    row = store.get_player(interaction.guild_id, label or identifier)
-    if not row:
-        # If label changed on an existing record, fetch by identifier.
-        row = store.get_player(interaction.guild_id, identifier.strip())
-    try:
-        profile, _ = await fetch_and_store(row, seed=True)
-    except TrackerError as exc:
-        store.remove_player(interaction.guild_id, identifier.strip())
-        await interaction.followup.send(f"Could not load that Tracker profile: `{exc}`", ephemeral=True)
-        return
-
-    await github_push("Track add")
-    await interaction.followup.send(
-        f"Tracking **{profile.handle}** as **{label or profile.handle}**. New activity will be posted in <#{interaction.channel_id}>. Historical sessions were seeded without alerts.",
-        ephemeral=True,
-    )
-
-
-@tree.command(name="track_remove", description="Stop tracking a Rocket League account")
-async def track_remove(interaction: discord.Interaction, player: str):
-    if not interaction.guild_id:
-        await interaction.response.send_message("Use this in a server.", ephemeral=True)
-        return
-    ok = store.remove_player(interaction.guild_id, player.strip())
-    if ok:
-        await github_push("Track remove")
-    await interaction.response.send_message("Removed." if ok else "No matching tracked player.", ephemeral=True)
-
-
-@tree.command(name="track_list", description="List Rocket League accounts tracked in this server")
-async def track_list(interaction: discord.Interaction):
-    if not interaction.guild_id:
-        await interaction.response.send_message("Use this in a server.", ephemeral=True)
-        return
-    rows = store.players(interaction.guild_id)
-    if not rows:
-        await interaction.response.send_message("No players are being tracked yet.", ephemeral=True)
-        return
-    lines = []
-    for r in rows:
-        last = store.latest_match(r["id"])
-        status = activity_label(last["collected_at"]) if last else "UNKNOWN"
-        mode = last["playlist"] if last else "no session data"
-        lines.append(f"• **{r['label']}** — `{r['platform']}` / `{r['identifier']}` — **{status}** — {mode}")
-    await interaction.response.send_message("\n".join(lines), ephemeral=True)
-
-
-@tree.command(name="rl_player", description="Show current MMRs and recent activity for a tracked player")
-async def rl_player(interaction: discord.Interaction, player: str):
-    if not interaction.guild_id:
-        await interaction.response.send_message("Use this in a server.", ephemeral=True)
-        return
-    row = store.get_player(interaction.guild_id, player.strip())
-    if not row:
-        await interaction.response.send_message("Player not found. Use `/track_list`.", ephemeral=True)
-        return
-    await interaction.response.defer()
-    try:
-        profile, _ = await fetch_and_store(row, seed=False)
-    except TrackerError as exc:
-        await interaction.followup.send(f"Tracker request failed: `{exc}`")
-        return
-    latest = store.latest_match(row["id"])
-    await interaction.followup.send(embed=profile_embed(row, profile, latest))
-
-
-@tree.command(name="rl_recent", description="Show a tracked player's recent recorded matches/activity")
-@app_commands.describe(count="Number of entries to show (1-10)")
-async def rl_recent(interaction: discord.Interaction, player: str, count: app_commands.Range[int, 1, 10] = 5):
-    if not interaction.guild_id:
-        await interaction.response.send_message("Use this in a server.", ephemeral=True)
-        return
-    row = store.get_player(interaction.guild_id, player.strip())
-    if not row:
-        await interaction.response.send_message("Player not found. Use `/track_list`.", ephemeral=True)
-        return
-    matches = store.recent_matches(row["id"], count)
-    if not matches:
-        await interaction.response.send_message("No session records stored yet.")
-        return
-    lines = []
-    for m in matches:
-        mmr = "?" if m["rating"] is None else str(m["rating"])
-        if m["rating_delta"] is not None:
-            mmr += f" ({m['rating_delta']:+d})"
-        lines.append(
-            f"**{m['playlist'] or 'Unknown'}** — {m['result'] or 'activity'} — `{mmr} MMR` — "
-            f"{discord_time(m['collected_at'], 'R')} ({discord_time(m['collected_at'], 't')})"
-        )
-    e = discord.Embed(title=f"Recent activity — {row['label']}", description="\n".join(lines), color=discord.Color.blurple())
-    await interaction.response.send_message(embed=e)
-
-
-@tree.command(name="rl_refresh", description="Refresh all tracked players in this server now")
-async def rl_refresh(interaction: discord.Interaction):
-    if not interaction.guild_id:
-        await interaction.response.send_message("Use this in a server.", ephemeral=True)
-        return
-    await interaction.response.defer(ephemeral=True)
-    rows = store.players(interaction.guild_id)
-    ok = 0
-    errors = []
-    for row in rows:
-        try:
-            await fetch_and_store(row, seed=False)
-            ok += 1
-        except TrackerError as exc:
-            errors.append(f"{row['label']}: {exc}")
-    if ok:
-        await github_push("Manual refresh")
-    msg = f"Refreshed {ok}/{len(rows)} tracked players."
-    if errors:
-        msg += "\n" + "\n".join(f"• {trunc(e, 160)}" for e in errors[:5])
-    await interaction.followup.send(msg, ephemeral=True)
-
-
-@tree.command(name="watch_status", description="Show the most useful current matchmaking signal for a tracked player")
-async def watch_status(interaction: discord.Interaction, player: str):
-    if not interaction.guild_id:
-        await interaction.response.send_message("Use this in a server.", ephemeral=True)
-        return
-    row = store.get_player(interaction.guild_id, player.strip())
-    if not row:
-        await interaction.response.send_message("Player not found. Use `/track_list`.", ephemeral=True)
-        return
-    latest = store.latest_match(row["id"])
-    if not latest:
-        await interaction.response.send_message("No activity has been recorded for that player yet.")
-        return
-    rating = "?" if latest["rating"] is None else str(latest["rating"])
-    if latest["rating_delta"] is not None:
-        rating += f" ({latest['rating_delta']:+d})"
-    e = discord.Embed(title=f"Watch status — {row['label']}", color=discord.Color.blurple())
-    e.add_field(name="Playlist", value=latest["playlist"] or "Unknown", inline=True)
-    e.add_field(name="MMR", value=rating, inline=True)
-    e.add_field(name="Freshness", value=activity_label(latest["collected_at"]), inline=True)
-    e.add_field(name="Observed", value=f"{discord_time(latest['collected_at'],'R')}\n{discord_time(latest['collected_at'],'f')}", inline=False)
-    e.add_field(name="Matchmaking signal", value=queue_window_text(latest["collected_at"]), inline=False)
-    e.set_footer(text="Tracker collection times can lag and do not prove the player is currently queued.")
-    await interaction.response.send_message(embed=e)
-
-
-@tree.command(name="watch_hot", description="List tracked players with the freshest recent activity")
-async def watch_hot(interaction: discord.Interaction):
-    if not interaction.guild_id:
-        await interaction.response.send_message("Use this in a server.", ephemeral=True)
-        return
-    entries=[]
-    for row in store.players(interaction.guild_id):
-        last=store.latest_match(row["id"])
-        if not last:
-            continue
-        dt=parse_dt(last["collected_at"])
-        if not dt:
-            continue
-        entries.append((dt,row,last))
-    if not entries:
-        await interaction.response.send_message("No tracked activity is stored yet.", ephemeral=True)
-        return
-    entries.sort(key=lambda x:x[0], reverse=True)
-    lines=[]
-    for _,row,last in entries[:15]:
-        mmr="?" if last["rating"] is None else str(last["rating"])
-        lines.append(f"**{row['label']}** — {last['playlist'] or 'Unknown'} — `{mmr} MMR` — **{activity_label(last['collected_at'])}** — {discord_time(last['collected_at'],'R')}")
-    await interaction.response.send_message(embed=discord.Embed(title="Freshest tracked activity",description="\n".join(lines),color=discord.Color.blurple()))
-
-
-@tree.command(name="github_sync", description="Manually sync the bot datasets to GitHub")
-async def github_sync_cmd(interaction: discord.Interaction):
-    await interaction.response.defer(ephemeral=True)
-    if not github_data.enabled:
-        await interaction.followup.send("GitHub persistence is disabled. Add `GHT` as a Hugging Face secret.", ephemeral=True)
-        return
-    ok=await github_push("Manual Discord sync")
-    if ok:
-        await interaction.followup.send(f"Synced datasets to `{GITHUB_DATA_REPO}`.", ephemeral=True)
-    else:
-        await interaction.followup.send(f"GitHub sync failed: `{trunc(github_data.last_error or 'unknown error',300)}`", ephemeral=True)
-
-
-@tree.command(name="github_status", description="Show GitHub persistence status")
-async def github_status_cmd(interaction: discord.Interaction):
-    state="enabled" if github_data.enabled else "disabled"
-    msg=(f"GitHub persistence: **{state}**\nRepo: `{GITHUB_DATA_REPO}`\nBranch: `{GITHUB_DATA_BRANCH}`\n"
-         f"Last sync: {discord_time(github_data.last_sync_at,'R') if github_data.last_sync_at else 'never'}")
-    if github_data.last_error:
-        msg += f"\nLast error: `{trunc(github_data.last_error,300)}`"
-    await interaction.response.send_message(msg, ephemeral=True)
-
-
-@tasks.loop(seconds=300)
-async def github_auto_sync():
-    if not github_data.enabled:
-        return
-    ok = await github_push("Automatic safety sync")
-    if ok:
-        log.info("Automatic GitHub dataset sync completed")
-
-
-@github_auto_sync.before_loop
-async def before_github_auto_sync():
-    await client.wait_until_ready()
-
-
-@tasks.loop(seconds=120)
-async def watcher():
-    rows = store.players()
-    for row in rows:
-        try:
-            profile, new_matches = await fetch_and_store(row, seed=False)
-            if not new_matches:
-                continue
-
-            watermark_raw = store.ensure_alert_watermark(row["id"])
-            watermark = parse_dt(watermark_raw)
-            now = datetime.now(timezone.utc)
-            filtered: list[dict[str, Any]] = []
-            for match in new_matches:
-                collected = parse_dt(match.get("collected_at"))
-                if not collected:
-                    continue
-                # Grouped/aggregate Tracker rows such as "Multiple" can be backfilled later and
-                # are not reliable enough for live matchmaking alerts. Keep them in history only.
-                if match.get("is_grouped"):
-                    continue
-                if watermark and collected <= watermark:
-                    continue
-                if (now - collected).total_seconds() > ALERT_MAX_AGE_MINUTES * 60:
-                    continue
-                filtered.append(match)
-
-            if not filtered:
-                continue
-
-            filtered.sort(key=lambda m: m.get("collected_at") or "", reverse=True)
-            channel = client.get_channel(row["alert_channel_id"])
-            if channel is None:
-                try:
-                    channel = await client.fetch_channel(row["alert_channel_id"])
-                except discord.DiscordException:
-                    log.warning("Could not resolve channel %s", row["alert_channel_id"])
-                    continue
-            sent_any = False
-            for match in filtered[:3]:
-                try:
-                    await channel.send(embed=match_embed(row, match))
-                    store.set_alert_watermark(row["id"], match.get("collected_at"))
-                    sent_any = True
-                except discord.DiscordException as exc:
-                    log.warning("Failed sending alert for %s: %s", row["label"], exc)
-            if sent_any:
-                await github_push("New Tracker activity")
-        except TrackerError as exc:
-            log.warning("Tracker error for %s: %s", row["label"], exc)
-        except Exception:
-            log.exception("Unexpected watcher error for %s", row["label"])
-        await asyncio.sleep(1)
-
-
-@watcher.before_loop
-async def before_watcher():
-    await client.wait_until_ready()
-
-
-# Hugging Face Docker Spaces expect an HTTP service. This tiny endpoint also gives
-# you a convenient uptime/health check while the Discord bot runs in the same process.
-health = FastAPI(title="Rocket Watch Health")
-
-
-@health.get("/")
-def root():
-    return {
-        "ok": True,
-        "service": "rocket-watch-discord-bot",
-        "discord_connected": runtime["discord_connected"],
-        "discord_user": runtime["discord_user"],
-        "discord_last_error": runtime["discord_last_error"],
-        "discord_last_attempt": runtime["discord_last_attempt"],
-        "discord_last_connected": runtime["discord_last_connected"],
-        "discord_retry_seconds": runtime["discord_retry_seconds"],
-        "discord_stage": runtime["discord_stage"],
-        "discord_stage_since": runtime["discord_stage_since"],
-        "discord_relay_enabled": bool(DISCORD_RELAY_GATEWAY),
-        "discord_relay_origin": DISCORD_RELAY_ORIGIN or None,
-        "tracked_players": len(store.players()),
-        "poll_seconds": POLL_SECONDS,
-        "alert_max_age_minutes": ALERT_MAX_AGE_MINUTES,
-        "github_persistence_enabled": github_data.enabled,
-        "github_data_repo": GITHUB_DATA_REPO,
-        "github_last_sync_at": github_data.last_sync_at,
-        "github_auto_sync_seconds": GITHUB_AUTO_SYNC_SECONDS,
-        "github_last_error": github_data.last_error,
-    }
-
-
-@health.get("/health")
-def healthcheck():
-    return {
-        "ok": True,
-        "http": "online",
-        "discord": "connected" if runtime["discord_connected"] else "disconnected",
-        "discord_last_error": runtime["discord_last_error"],
-        "discord_stage": runtime["discord_stage"],
-        "discord_stage_since": runtime["discord_stage_since"],
-    }
-
-
-def set_discord_stage(stage: str) -> None:
-    runtime["discord_stage"] = stage
-    runtime["discord_stage_since"] = utc_now_iso()
-
-
-@health.get("/debug/discord")
-async def debug_discord():
-    """Test both direct Discord and the configured Deno relay without a token."""
-
-    async def probe(label: str, url: str):
-        started = time.monotonic()
-        try:
-            timeout = aiohttp.ClientTimeout(total=10, connect=5, sock_connect=5, sock_read=5)
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                async with session.get(url) as resp:
-                    body = await resp.text()
-                    return {
-                        "label": label,
-                        "url": url.replace(DISCORD_RELAY_SECRET, "***") if DISCORD_RELAY_SECRET else url,
-                        "status": resp.status,
-                        "body": body[:300],
-                        "elapsed_ms": round((time.monotonic() - started) * 1000),
-                    }
-        except Exception as exc:
-            return {
-                "label": label,
-                "url": url.replace(DISCORD_RELAY_SECRET, "***") if DISCORD_RELAY_SECRET else url,
-                "error": f"{type(exc).__name__}: {exc}",
-                "elapsed_ms": round((time.monotonic() - started) * 1000),
-            }
-
-    dns = None
-    try:
-        infos = await asyncio.wait_for(
-            asyncio.get_running_loop().run_in_executor(
-                None, lambda: socket.getaddrinfo("discord.com", 443, type=socket.SOCK_STREAM)
-            ),
-            timeout=5,
-        )
-        dns = sorted({item[4][0] for item in infos})[:6]
-    except Exception as exc:
-        dns = f"{type(exc).__name__}: {exc}"
-
-    result = {
-        "discord_dns": dns,
-        "direct": await probe("direct", "https://discord.com/api/v10/gateway"),
-        "relay_enabled": bool(DISCORD_RELAY_GATEWAY),
-    }
-    if DISCORD_RELAY_GATEWAY:
-        relay_url = f"{DISCORD_RELAY_ORIGIN}/p/{DISCORD_RELAY_SECRET}/api/v10/gateway"
-        result["relay"] = await probe("deno-relay", relay_url)
-    return result
-
-
-async def sync_commands():
-    """Sync slash commands after Discord is actually connected."""
-    try:
-        if GUILD_ID:
-            guild = discord.Object(id=int(GUILD_ID))
-            tree.copy_global_to(guild=guild)
-            synced = await tree.sync(guild=guild)
-            log.info("Synced %d slash commands to guild %s", len(synced), GUILD_ID)
-        else:
-            synced = await tree.sync()
-            log.info("Synced %d global slash commands", len(synced))
-    except Exception:
-        log.exception("Slash-command sync failed")
-
-
-def rebuild_discord_client() -> None:
-    """Replace the Discord client with a brand-new HTTP/WebSocket stack.
-
-    discord.py can close its internal aiohttp session after a failed login.
-    Client.clear() resets cache/state but does not make that closed session usable
-    again, so retries must use a fresh Client instance.
-    """
-    global client, tree
-
-    # Preserve the application-command objects already registered on the current
-    # tree, then attach them to a fresh tree/client.
-    commands = list(tree.get_commands())
-
-    new_client = discord.Client(intents=intents)
-    new_tree = app_commands.CommandTree(new_client)
-    for command in commands:
-        new_tree.add_command(command)
-
-    # Re-register event callbacks on the new Client. The callbacks intentionally
-    # reference the module-level `client`, which is rebound below.
-    new_client.event(on_ready)
-    new_client.event(on_disconnect)
-
-    client = new_client
-    tree = new_tree
-
-
-async def discord_supervisor():
-    """Keep Discord failures isolated from the Hugging Face HTTP service.
-
-    The Space listens only on $PORT (7860 by default). Discord uses outbound
-    HTTPS/WSS and therefore does not need another local listening port. Every
-    retry uses a completely fresh discord.Client so a failed aiohttp session
-    cannot poison future attempts.
-    """
-    delay = 5
-    max_delay = 300
-    first_attempt = True
-
-    while True:
-        runtime["discord_last_attempt"] = utc_now_iso()
-        runtime["discord_retry_seconds"] = None
-
-        if not first_attempt:
-            rebuild_discord_client()
-        first_attempt = False
-
-        connect_task = None
-        try:
-            log.info("Connecting to Discord with a fresh client...")
-
-            set_discord_stage("rest_login")
-            await asyncio.wait_for(
-                client.login(DISCORD_BOT_TOKEN),
-                timeout=DISCORD_LOGIN_TIMEOUT,
-            )
-            log.info("Discord REST login succeeded as %s", client.user)
-
-            set_discord_stage("command_sync")
-            await asyncio.wait_for(sync_commands(), timeout=20)
-
-            # client.connect() is intentionally long-running. Start it separately,
-            # then require READY within a bounded amount of time. This distinguishes
-            # a successful REST login from a Gateway/WebSocket failure.
-            set_discord_stage("gateway_connect")
-            connect_task = asyncio.create_task(client.connect(reconnect=True), name="discord-gateway")
-            await asyncio.wait_for(client.wait_until_ready(), timeout=DISCORD_READY_TIMEOUT)
-            set_discord_stage("connected")
-            log.info("Discord gateway is READY")
-
-            # Stay attached to the gateway until discord.py returns or fails.
-            await connect_task
-
-            runtime["discord_connected"] = False
-            runtime["discord_last_error"] = "Discord connection closed"
-            set_discord_stage("disconnected")
-            delay = 5
-        except asyncio.CancelledError:
-            try:
-                if not client.is_closed():
-                    await client.close()
-            finally:
-                raise
-        except asyncio.TimeoutError:
-            stage = runtime.get("discord_stage") or "unknown"
-            timeout_used = DISCORD_LOGIN_TIMEOUT if stage == "rest_login" else DISCORD_READY_TIMEOUT
-            runtime["discord_connected"] = False
-            runtime["discord_last_error"] = f"Timeout while in {stage} after {timeout_used}s"
-            log.error("Discord timed out during %s after %ss", stage, timeout_used)
-        except discord.LoginFailure as exc:
-            runtime["discord_connected"] = False
-            runtime["discord_last_error"] = f"Login failure: {exc}"
-            delay = 300
-            log.error("Discord rejected the bot token: %s", exc)
-        except Exception as exc:
-            runtime["discord_connected"] = False
-            runtime["discord_last_error"] = f"{type(exc).__name__}: {exc}"
-            log.exception("Discord connection attempt failed")
-
-        # Best-effort cleanup. We never reuse this instance after a failure.
-        if connect_task is not None and not connect_task.done():
-            connect_task.cancel()
-            try:
-                await connect_task
-            except (asyncio.CancelledError, Exception):
-                pass
-        try:
-            if not client.is_closed():
-                await client.close()
-        except Exception:
-            log.debug("Discord client cleanup failed", exc_info=True)
-
-        runtime["discord_retry_seconds"] = delay
-        set_discord_stage("retry_wait")
-        log.warning("Discord unavailable; retrying with a fresh client in %ss", delay)
-        await asyncio.sleep(delay)
-        delay = min(delay * 2, max_delay)
-
-
-async def main():
-    if not DISCORD_BOT_TOKEN:
-        raise RuntimeError(
-            "DISCORD_BOT_TOKEN is not set. Add it as a Hugging Face Space secret or environment variable."
-        )
-
-    if github_data.enabled:
-        try:
-            await asyncio.to_thread(github_data.ensure_files)
-            restored = await asyncio.to_thread(github_data.restore_into, store)
-            log.info("Restored %s players and %s activity records from GitHub", restored["players"], restored["matches"])
-            await github_push("Startup reconciliation")
-        except Exception as exc:
-            github_data.last_error = f"{type(exc).__name__}: {exc}"
-            log.warning("GitHub startup restore failed: %s", exc)
-
-    # Hugging Face exposes one HTTP port. Uvicorn owns that port; Discord runs as
-    # an outbound background connection and never binds a local port.
-    port = int(os.getenv("PORT", "7860"))
-    config = uvicorn.Config(
-        health,
-        host="0.0.0.0",
-        port=port,
-        log_level=os.getenv("UVICORN_LOG_LEVEL", "info").lower(),
-        lifespan="on",
-    )
-    server = uvicorn.Server(config)
-
-    discord_task = asyncio.create_task(discord_supervisor(), name="discord-supervisor")
-    try:
-        await server.serve()
-    finally:
-        discord_task.cancel()
-        try:
-            await discord_task
-        except asyncio.CancelledError:
-            pass
-        if not client.is_closed():
-            await client.close()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())