Upload 6 files

.dockerignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+*.pyo
+*.db
+.venv/
+.git/
+.env

.gitignore

@@ -0,0 +1,5 @@
+__pycache__/
+*.py[cod]
+.venv/
+.env
+rocket_watch.db

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.12-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1 \
+    PYTHONUNBUFFERED=1 \
+    PORT=7860 \
+    DB_PATH=/data/rocket_watch.db
+
+WORKDIR /app
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY main.py tracker_client.py ./
+
+RUN mkdir -p /data
+
+EXPOSE 7860
+
+CMD ["python", "main.py"]

main.py

@@ -0,0 +1,847 @@
+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())

requirements.txt

@@ -0,0 +1,4 @@
+discord.py>=2.5,<3
+requests>=2.32,<3
+fastapi>=0.115,<1
+uvicorn[standard]>=0.34,<1

tracker_client.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional
+
+import requests
+
+BASE_WEB = "https://api.tracker.gg"
+
+
+class TrackerError(RuntimeError):
+    pass
+
+
+def _dt(value: Optional[str]) -> Optional[datetime]:
+    if not value:
+        return None
+    try:
+        d = datetime.fromisoformat(value.replace("Z", "+00:00"))
+        if d.tzinfo is None:
+            d = d.replace(tzinfo=timezone.utc)
+        return d.astimezone(timezone.utc)
+    except ValueError:
+        return None
+
+
+def _stat_value(stats: Dict[str, Any], name: str, default=None):
+    return (stats.get(name) or {}).get("value", default)
+
+
+@dataclass
+class PlayerProfile:
+    platform: str
+    identifier: str
+    handle: str
+    player_id: Optional[int]
+    last_updated: Optional[datetime]
+    season: Optional[int]
+    avatar_url: Optional[str]
+    lifetime: Dict[str, Any]
+    playlists: List[Dict[str, Any]]
+    raw: Dict[str, Any]
+
+
+class TrackerClient:
+    """Best-effort client for Tracker web endpoints observed in supplied samples.
+
+    This intentionally does not solve/bypass Cloudflare or Warden challenges. A 401/403
+    is returned to the bot as an error instead.
+    """
+
+    def __init__(self, timeout: int = 20):
+        self.session = requests.Session()
+        self.timeout = timeout
+        self.session.headers.update(
+            {
+                "Accept": "application/json, text/plain, */*",
+                "Origin": "https://rocketleague.tracker.network",
+                "Referer": "https://rocketleague.tracker.network/",
+                "User-Agent": os.getenv(
+                    "TRACKER_USER_AGENT",
+                    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
+                    "(KHTML, like Gecko) Chrome/153.0.0.0 Safari/537.36",
+                ),
+            }
+        )
+        cookie = os.getenv("TRACKER_COOKIE", "").strip()
+        if cookie:
+            self.session.headers["Cookie"] = cookie
+
+    def _get(self, path: str, params: Optional[dict] = None) -> Dict[str, Any]:
+        url = f"{BASE_WEB}{path}"
+        try:
+            r = self.session.get(url, params=params, timeout=self.timeout)
+        except requests.RequestException as exc:
+            raise TrackerError(f"Network error contacting Tracker: {exc}") from exc
+        if r.status_code in (401, 403):
+            raise TrackerError(
+                f"HTTP {r.status_code}; Tracker's web endpoint may be protected or require browser state."
+            )
+        try:
+            r.raise_for_status()
+        except requests.HTTPError as exc:
+            raise TrackerError(f"HTTP {r.status_code} for {r.url}") from exc
+        try:
+            return r.json()
+        except ValueError as exc:
+            raise TrackerError("Tracker returned non-JSON content") from exc
+
+    def profile(self, platform: str, identifier: str) -> PlayerProfile:
+        payload = self._get(f"/api/v2/rocket-league/standard/profile/{platform}/{identifier}")
+        data = payload.get("data") or {}
+        pinfo = data.get("platformInfo") or {}
+        meta = data.get("metadata") or {}
+        segments = data.get("segments") or []
+
+        lifetime: Dict[str, Any] = {}
+        playlists: List[Dict[str, Any]] = []
+        for seg in segments:
+            stats = seg.get("stats") or {}
+            if seg.get("type") == "overview":
+                lifetime = {k: (v or {}).get("value") for k, v in stats.items()}
+            elif seg.get("type") == "playlist":
+                attrs = seg.get("attributes") or {}
+                smeta = seg.get("metadata") or {}
+                tier = stats.get("tier") or {}
+                div = stats.get("division") or {}
+                rating = stats.get("rating") or {}
+                peak = stats.get("peakRating") or {}
+                playlists.append(
+                    {
+                        "playlist_id": attrs.get("playlistId"),
+                        "name": smeta.get("name", f"Playlist {attrs.get('playlistId')}"),
+                        "season": attrs.get("season"),
+                        "rating": rating.get("value"),
+                        "tier": (rating.get("metadata") or {}).get("tierName")
+                        or (tier.get("metadata") or {}).get("name"),
+                        "division": (div.get("metadata") or {}).get("name"),
+                        "matches_played": _stat_value(stats, "matchesPlayed"),
+                        "win_streak": _stat_value(stats, "winStreak"),
+                        "peak_rating": peak.get("value"),
+                    }
+                )
+
+        return PlayerProfile(
+            platform=pinfo.get("platformSlug") or platform,
+            identifier=pinfo.get("platformUserIdentifier") or identifier,
+            handle=pinfo.get("platformUserHandle") or identifier,
+            player_id=meta.get("playerId"),
+            last_updated=_dt((meta.get("lastUpdated") or {}).get("value")),
+            season=meta.get("currentSeason"),
+            avatar_url=pinfo.get("avatarUrl"),
+            lifetime=lifetime,
+            playlists=playlists,
+            raw=payload,
+        )
+
+    def sessions(self, platform: str, identifier: str) -> Dict[str, Any]:
+        return self._get(f"/api/v2/rocket-league/standard/profile/{platform}/{identifier}/sessions")
+
+    def mmr_history(self, player_id: int) -> Dict[str, Any]:
+        return self._get(f"/api/v1/rocket-league/player-history/mmr/{player_id}")
+
+    def overview_history(self, player_id: int) -> Dict[str, Any]:
+        return self._get(f"/api/v1/rocket-league/player-history/overview/{player_id}", params={"type": "graph"})
+
+    def aggregated(self, platform: str, identifier: str, local_offset: int = 0) -> Dict[str, Any]:
+        return self._get(
+            f"/api/v1/rocket-league/matches/{platform}/{identifier}/aggregated",
+            params={"localOffset": local_offset},
+        )
+
+    @staticmethod
+    def flatten_session_matches(payload: Dict[str, Any]) -> List[Dict[str, Any]]:
+        out: List[Dict[str, Any]] = []
+        for session in ((payload.get("data") or {}).get("items") or []):
+            for m in session.get("matches") or []:
+                meta = m.get("metadata") or {}
+                stats = m.get("stats") or {}
+                r = stats.get("rating") or {}
+                rmeta = r.get("metadata") or {}
+                out.append(
+                    {
+                        "match_id": m.get("id"),
+                        "collected_at": meta.get("dateCollected"),
+                        "playlist": meta.get("playlist"),
+                        "result": meta.get("result"),
+                        "is_grouped": bool(meta.get("isGrouped")),
+                        "rating": r.get("value"),
+                        "rating_delta": rmeta.get("ratingDelta"),
+                        "tier": rmeta.get("tier"),
+                        "division": rmeta.get("division"),
+                        "matches_played": _stat_value(stats, "matchesPlayed"),
+                        "wins": _stat_value(stats, "wins"),
+                        "goals": _stat_value(stats, "goals"),
+                        "assists": _stat_value(stats, "assists"),
+                        "saves": _stat_value(stats, "saves"),
+                        "shots": _stat_value(stats, "shots"),
+                        "mvps": _stat_value(stats, "mvps"),
+                    }
+                )
+        out.sort(key=lambda x: x.get("collected_at") or "", reverse=True)
+        return out