Delete main.py

main.py

@@ -1,847 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import json
-import logging
-import os
-import sqlite3
-import socket
-import time
-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 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")))
-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("/")
-
-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 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,
-                    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);
-                """
-            )
-
-    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 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
-
-
-store = Store(DB_PATH)
-tracker = TrackerClient()
-
-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 we ingest history but intentionally do not alert on it.
-    return profile, ([] if seed else 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'])}** • {age_text(latest_match['collected_at'])}", 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=age_text(match.get("collected_at")), inline=True)
-    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()
-
-
-@client.event
-async def on_disconnect():
-    runtime["discord_connected"] = False
-
-
-@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 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())
-    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` — {age_text(m['collected_at'])}")
-    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}")
-    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)
-
-
-@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
-            # Tracker may reveal several historical/grouped rows in one refresh. Alert only the
-            # newest few so one cache refresh cannot flood a channel.
-            new_matches.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
-            for match in new_matches[:3]:
-                try:
-                    await channel.send(embed=match_embed(row, match))
-                except discord.DiscordException as exc:
-                    log.warning("Failed sending alert for %s: %s", row["label"], exc)
-        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,
-    }
-
-
-@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."
-        )
-
-    # 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())