Initial version

bot.py

@@ -0,0 +1,462 @@
+#!/usr/bin/env python3
+"""
+Twitch chat → MPD control bot, plus optional "going live" notifications.
+
+Connects to Twitch IRC over TLS, joins the configured channel, and responds to:
+    !skip   advance MPD to the next track (per-user cooldown — see SKIP_COOLDOWN)
+    !queue  print the next few queued tracks
+    !info   print full metadata (artist · title · album · year · genre) for now-playing
+The new track shows up on stream because bridges/mpd-state.py is already
+broadcasting MPD state to the loading / game / music-box overlays.
+
+If MM_HOOK is set, a second task polls the public ophi118.com status service
+(which already polls Twitch Helix for live/title/game) and POSTs a single
+Mattermost notification per offline→live transition. See live_watch().
+
+Reads .env from the same directory:
+    TWITCH_ACCESS_TOKEN   chat OAuth token (with or without `oauth:` prefix)
+    TWITCH_NICK           bot login name (lowercase)
+    TWITCH_CHANNEL        channel to join, no leading `#` — defaults to TWITCH_NICK
+    MM_HOOK               optional Mattermost incoming-webhook URL; enables
+                          going-live notifications when set
+    STATUS_URL            optional override for the status API endpoint
+                          (default: https://ophi118.com/api/status.json)
+
+TWITCH_REFRESH_TOKEN and TWITCH_CLIENT_ID are also stored in .env (paired with
+the access token at generation time) but the bot doesn't use them yet — token
+refresh would land here later if access tokens start expiring mid-stream.
+"""
+
+import asyncio
+import json
+import os
+import ssl
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+from mpd.asyncio import MPDClient
+
+HERE = Path(__file__).resolve().parent
+ENV  = HERE / ".env"
+
+MPD_HOST = os.environ.get("MPD_HOST", "localhost")
+MPD_PORT = int(os.environ.get("MPD_PORT", "6600"))
+
+IRC_HOST     = "irc.chat.twitch.tv"
+IRC_PORT     = 6697
+PING_TIMEOUT = 360.0   # twitch PINGs ~every 5min; reconnect if silent longer
+SKIP_COOLDOWN = 60.0   # per-user seconds between successful !skip invocations
+QUEUE_PEEK    = 3      # how many upcoming tracks !queue should print
+
+# Going-live watcher: poll cadence matches the server's Twitch poll (60s) so we
+# never lag the upstream signal by more than ~2 polls.
+STATUS_URL    = os.environ.get("STATUS_URL", "https://ophi118.com/api/status.json")
+STATUS_POLL_S = 60.0
+
+# Set TWITCH_BOT_DEBUG=1 (env or .env) to dump every received IRC line. Useful
+# when a brand-new bot account looks "connected" but doesn't see chat — Twitch
+# silently degrades unverified accounts in ways that don't surface as errors.
+DEBUG_RAW = os.environ.get("TWITCH_BOT_DEBUG", "").strip() not in ("", "0", "false")
+
+
+# ─── tiny .env loader ───────────────────────────────────────────────────────
+
+def load_env(path: Path) -> dict:
+    """KEY=VALUE lines, # comments, optional surrounding quotes. Avoids a
+    python-dotenv dependency for three vars."""
+    out = {}
+    if not path.exists():
+        return out
+    for raw in path.read_text().splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, _, v = line.partition("=")
+        out[k.strip()] = v.strip().strip('"').strip("'")
+    return out
+
+
+# ─── MPD ────────────────────────────────────────────────────────────────────
+
+class Mpd:
+    """One shared MPDClient with reconnect-on-failure.
+
+    python-mpd2's asyncio client doesn't auto-reconnect, so each command is
+    wrapped to retry once after dropping the connection — covers MPD
+    restarts and idle-socket timeouts without surfacing transient errors.
+    """
+
+    def __init__(self):
+        self._cli  = None
+        self._lock = asyncio.Lock()
+
+    async def _ensure(self):
+        if self._cli is None:
+            cli = MPDClient()
+            await cli.connect(MPD_HOST, MPD_PORT)
+            self._cli = cli
+
+    async def _retry(self, op):
+        """Run an MPD coroutine with one reconnect-on-failure retry."""
+        async with self._lock:
+            last = None
+            for attempt in (1, 2):
+                try:
+                    await self._ensure()
+                    return await op(self._cli)
+                except Exception as e:
+                    last = e
+                    self._cli = None  # force reconnect on retry
+            raise last  # type: ignore[misc]
+
+    async def skip(self) -> str:
+        async def op(cli):
+            await cli.next()
+            return _fmt_song(await cli.currentsong())
+        return await self._retry(op)
+
+    async def currentsong(self) -> dict:
+        return await self._retry(lambda cli: cli.currentsong())
+
+    async def status(self) -> dict:
+        return await self._retry(lambda cli: cli.status())
+
+    async def playlistinfo(self, pos: int) -> list:
+        return await self._retry(lambda cli: cli.playlistinfo(pos))
+
+
+def _flat(v):
+    """MPD tags can be lists (multi-value); flatten to a comma-joined string
+    with empties removed. Returns None for missing/empty so callers can skip
+    fields without empty parens."""
+    if v is None:
+        return None
+    if isinstance(v, list):
+        v = ", ".join(x for x in v if x)
+    v = (v or "").strip()
+    return v or None
+
+
+def _fmt_song(song: dict) -> str:
+    artist = _flat(song.get("artist") or song.get("albumartist")) or ""
+    title  = _flat(song.get("title")) or (song.get("file") or "").rsplit("/", 1)[-1]
+    out = f"{artist} — {title}".strip(" —")
+    return out or "(unknown track)"
+
+
+def _fmt_info(song: dict) -> str:
+    """Compose the !info reply: 'Artist — Title · Album (Year) · Genre'.
+    Skip any segment whose underlying tag is missing."""
+    head = _fmt_song(song)
+    parts = [head] if head != "(unknown track)" else []
+    album = _flat(song.get("album"))
+    year  = _flat(song.get("date"))
+    if year:
+        # MPD often stores ISO dates ('2018-04-12') — show year only.
+        year = year.split("-", 1)[0]
+    if album and year:
+        parts.append(f"{album} ({year})")
+    elif album:
+        parts.append(album)
+    elif year:
+        parts.append(f"({year})")
+    genre = _flat(song.get("genre"))
+    if genre:
+        parts.append(genre)
+    return " · ".join(parts) if parts else "(unknown track)"
+
+
+# ─── Twitch IRC ─────────────────────────────────────────────────────────────
+
+class TwitchBot:
+    def __init__(self, nick: str, token: str, channel: str, mpd: Mpd):
+        self.nick    = nick.lower()
+        self.token   = token if token.startswith("oauth:") else f"oauth:{token}"
+        self.channel = "#" + channel.lower().lstrip("#")
+        self.mpd     = mpd
+        # Per-user !skip cooldown — keyed by lowercased nick. The dict grows
+        # unboundedly with viewer count over a stream session; not worth
+        # pruning at typical chat sizes (one float per chatter).
+        self._skip_seen: dict[str, float] = {}
+
+    async def _send(self, writer: asyncio.StreamWriter, raw: str):
+        writer.write((raw + "\r\n").encode("utf-8"))
+        await writer.drain()
+
+    async def _say(self, writer: asyncio.StreamWriter, msg: str):
+        # twitch chat lines max ~500 chars; truncate defensively, strip newlines
+        msg = msg.replace("\r", " ").replace("\n", " ")[:480]
+        await self._send(writer, f"PRIVMSG {self.channel} :{msg}")
+
+    async def run(self):
+        """Connect/auth/listen loop with quiet exponential backoff.
+
+        Mirrors the connect-quietly pattern in bridges/mpd-state.py:
+        first failure prints once, then silent retry until the connection
+        comes back. Auth failure is fatal — no point retrying with a bad token.
+        """
+        backoff = 2
+        BACKOFF_MAX = 30
+        prev_status = None  # None | "up" | "down"
+        ctx = ssl.create_default_context()
+
+        while True:
+            try:
+                reader, writer = await asyncio.open_connection(
+                    IRC_HOST, IRC_PORT, ssl=ctx,
+                )
+                try:
+                    await self._send(writer, f"PASS {self.token}")
+                    await self._send(writer, f"NICK {self.nick}")
+                    await self._send(writer, f"JOIN {self.channel}")
+
+                    if prev_status != "up":
+                        print(f"[twitch] connected → {self.channel} as {self.nick}",
+                              flush=True)
+                    prev_status = "up"
+                    backoff = 2
+
+                    while True:
+                        line_bytes = await asyncio.wait_for(
+                            reader.readline(), timeout=PING_TIMEOUT,
+                        )
+                        if not line_bytes:
+                            raise ConnectionError("server closed connection")
+                        line = line_bytes.decode("utf-8", errors="replace").rstrip("\r\n")
+                        await self._handle(writer, line)
+                finally:
+                    writer.close()
+                    try:
+                        await writer.wait_closed()
+                    except Exception:
+                        pass
+            except RuntimeError as e:
+                # auth-failed and similar fatals — let systemd flag it
+                print(f"[twitch] fatal: {e}", file=sys.stderr, flush=True)
+                raise
+            except (asyncio.TimeoutError, ConnectionError, OSError) as e:
+                if prev_status == "up":
+                    print(f"[twitch] disconnected ({type(e).__name__}: {e}) — retrying",
+                          flush=True)
+                elif prev_status is None:
+                    print(f"[twitch] unreachable ({type(e).__name__}) — will retry silently",
+                          flush=True)
+                prev_status = "down"
+                await asyncio.sleep(backoff)
+                backoff = min(backoff * 2, BACKOFF_MAX)
+
+    async def _handle(self, writer: asyncio.StreamWriter, line: str):
+        if DEBUG_RAW:
+            print(f"[rx] {line}", flush=True)
+
+        # PING/PONG keepalive — twitch sends `PING :tmi.twitch.tv` periodically
+        if line.startswith("PING "):
+            await self._send(writer, "PONG " + line[5:])
+            return
+
+        # NOTICE on bad creds: ":tmi.twitch.tv NOTICE * :Login authentication failed"
+        if " NOTICE " in line and "authentication failed" in line.lower():
+            raise RuntimeError("twitch auth failed — check TWITCH_KEY / TWITCH_NICK")
+
+        # PRIVMSG format: ":user!user@user.tmi.twitch.tv PRIVMSG #chan :body"
+        if " PRIVMSG " not in line:
+            return
+        try:
+            prefix, rest = line.split(" PRIVMSG ", 1)
+            user = prefix[1:].split("!", 1)[0]
+            _, _, body = rest.partition(":")
+        except ValueError:
+            return
+
+        # Twitch's anti-duplicate logic appends an invisible Tags-block
+        # codepoint (U+E0000–U+E007F) to back-to-back identical messages
+        # from the same sender within ~30s. Without stripping it, every
+        # other `!skip` in a series silently fails to match.
+        body = "".join(c for c in body if not (0xE0000 <= ord(c) <= 0xE007F))
+        head = body.strip().split(" ", 1)[0].lower()
+        if head == "!skip":
+            await self._cmd_skip(writer, user)
+        elif head == "!queue":
+            await self._cmd_queue(writer, user)
+        elif head == "!info":
+            await self._cmd_info(writer, user)
+
+    async def _cmd_skip(self, writer: asyncio.StreamWriter, user: str):
+        # Per-user cooldown: each chatter gets one skip per SKIP_COOLDOWN
+        # seconds. Reject with a wait-time hint so the user knows it's their
+        # own gate, not the bot being broken.
+        now = time.monotonic()
+        ukey = user.lower()
+        last = self._skip_seen.get(ukey, 0.0)
+        wait = SKIP_COOLDOWN - (now - last)
+        if wait > 0:
+            await self._say(
+                writer,
+                f"@{user} you can only !skip once per minute (wait {int(wait)+1}s)",
+            )
+            return
+        try:
+            now_playing = await self.mpd.skip()
+        except Exception as e:
+            print(f"[skip] failed for @{user}: {type(e).__name__}: {e}", flush=True)
+            await self._say(writer, f"@{user} couldn't skip — MPD didn't respond")
+            return
+        self._skip_seen[ukey] = now
+        print(f"[skip] @{user} → {now_playing}", flush=True)
+        await self._say(writer, f"⏭ skipped by @{user} → now: {now_playing}")
+
+    async def _cmd_queue(self, writer: asyncio.StreamWriter, user: str):
+        # Read-only; no cooldown. Pulls current pos from status, then peeks
+        # the next QUEUE_PEEK tracks one-by-one (small N — full playlistinfo
+        # would dump the whole queue).
+        try:
+            status = await self.mpd.status()
+            pos    = int(status.get("song", -1))
+            total  = int(status.get("playlistlength") or 0)
+        except Exception as e:
+            print(f"[queue] failed for @{user}: {type(e).__name__}: {e}", flush=True)
+            await self._say(writer, f"@{user} couldn't read queue — MPD didn't respond")
+            return
+        if pos < 0 or pos + 1 >= total:
+            await self._say(writer, "🎵 nothing else queued")
+            return
+        upcoming = []
+        for i, p in enumerate(range(pos + 1, min(pos + 1 + QUEUE_PEEK, total)), start=1):
+            try:
+                rows = await self.mpd.playlistinfo(p)
+                if rows:
+                    upcoming.append(f"{i}) {_fmt_song(rows[0])}")
+            except Exception:
+                continue
+        if not upcoming:
+            await self._say(writer, "🎵 nothing else queued")
+            return
+        await self._say(writer, "🎵 next: " + " · ".join(upcoming))
+
+    async def _cmd_info(self, writer: asyncio.StreamWriter, user: str):
+        try:
+            song = await self.mpd.currentsong()
+        except Exception as e:
+            print(f"[info] failed for @{user}: {type(e).__name__}: {e}", flush=True)
+            await self._say(writer, f"@{user} couldn't read track info — MPD didn't respond")
+            return
+        if not song:
+            await self._say(writer, "ℹ nothing playing")
+            return
+        await self._say(writer, "ℹ " + _fmt_info(song))
+
+
+# ─── Mattermost "going live" notifications ──────────────────────────────────
+
+def _fetch_status(url: str) -> dict:
+    """GET the status JSON. Raises on transport/parse errors so live_watch()
+    can log + back off uniformly."""
+    req = urllib.request.Request(url, method="GET",
+                                 headers={"User-Agent": "obs-twitch-bot/1.0"})
+    with urllib.request.urlopen(req, timeout=10) as r:
+        return json.loads(r.read().decode("utf-8"))
+
+
+def _post_mattermost(hook_url: str, channel: str, title: str, game: str) -> None:
+    """POST a single going-live notification. Markdown renders in Mattermost."""
+    parts = [f"🔴 **{channel}** is live on Twitch"]
+    if title:
+        parts.append(f"> {title}")
+    if game:
+        parts.append(f"_{game}_")
+    parts.append(f"https://twitch.tv/{channel}")
+    body = json.dumps({"text": "\n".join(parts)}).encode("utf-8")
+    req = urllib.request.Request(
+        hook_url, method="POST", data=body,
+        headers={"Content-Type": "application/json",
+                 "User-Agent":   "obs-twitch-bot/1.0"},
+    )
+    with urllib.request.urlopen(req, timeout=10) as r:
+        if r.status >= 300:
+            raise RuntimeError(f"mattermost hook returned HTTP {r.status}")
+
+
+async def live_watch(mm_hook: str, channel: str, status_url: str = STATUS_URL):
+    """Poll the status service; POST to Mattermost on offline→live transitions.
+
+    Transition detection is keyed on `started_at`, not just the `live` flag, so
+    a brief Helix hiccup (live=true → false → true within one stream session,
+    same `started_at`) doesn't double-fire.
+
+    Cold-start during an ongoing stream is intentionally silent: we record the
+    current `started_at` so we won't fire for it later, but we don't announce
+    it (we can't tell "they just went live" from "the bot restarted mid-stream"
+    without prior offline observation). Once we see live=False at least once,
+    the next started_at change becomes a real transition we'll announce.
+    """
+    last_announced = None  # started_at we've already handled (announced or recorded)
+    seen_offline   = False  # have we observed live=False since last_announced?
+
+    while True:
+        try:
+            data    = await asyncio.to_thread(_fetch_status, status_url)
+            twitch  = (data or {}).get("twitch") or {}
+            live    = bool(twitch.get("live"))
+            started = (twitch.get("started_at") or None) if live else None
+        except Exception as e:
+            print(f"[live] poll failed: {type(e).__name__}: {e}", flush=True)
+            await asyncio.sleep(STATUS_POLL_S)
+            continue
+
+        if not live:
+            seen_offline = True
+        elif started:
+            if last_announced is None and not seen_offline:
+                # cold start mid-stream: lock in this started_at so we won't
+                # falsely announce it later
+                last_announced = started
+            elif started != last_announced and seen_offline:
+                title = twitch.get("title") or ""
+                game  = twitch.get("game")  or ""
+                try:
+                    await asyncio.to_thread(_post_mattermost, mm_hook, channel, title, game)
+                    print(f"[live] {channel} went live → posted to mattermost "
+                          f"(title={title!r}, game={game!r})", flush=True)
+                except Exception as e:
+                    # log but don't retry — a missed notification is better
+                    # than a duplicate; the next genuine transition will fire
+                    print(f"[live] mattermost post failed: {type(e).__name__}: {e}",
+                          flush=True)
+                last_announced = started
+                seen_offline   = False
+
+        await asyncio.sleep(STATUS_POLL_S)
+
+
+# ─── entrypoint ─────────────────────────────────────────────────────────────
+
+async def main():
+    env = {**load_env(ENV), **os.environ}  # process env wins over .env
+    token   = env.get("TWITCH_ACCESS_TOKEN", "").strip()
+    nick    = env.get("TWITCH_NICK", "").strip()
+    channel = env.get("TWITCH_CHANNEL", nick).strip()
+    mm_hook = env.get("MM_HOOK", "").strip()
+
+    missing = [k for k, v in (("TWITCH_ACCESS_TOKEN", token), ("TWITCH_NICK", nick)) if not v]
+    if missing:
+        print(f"[err] missing in {ENV}: {', '.join(missing)}", file=sys.stderr)
+        sys.exit(1)
+
+    bot   = TwitchBot(nick=nick, token=token, channel=channel, mpd=Mpd())
+    tasks = [bot.run()]
+    if mm_hook:
+        print(f"[live] watching {STATUS_URL} → mattermost on offline→live", flush=True)
+        tasks.append(live_watch(mm_hook, channel))
+    else:
+        print("[live] MM_HOOK unset — going-live notifications disabled", flush=True)
+    await asyncio.gather(*tasks)
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        sys.exit(0)