#!/usr/bin/env python3 """ Twitch chat → MPD control bot. Connects to Twitch IRC over TLS, joins the configured channel, and on `!skip` advances MPD to the next track. The new track shows up on stream because bridges/mpd-state.py is already broadcasting MPD state to the loading overlay. 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 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 os import ssl import sys import time 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 = 5.0 # seconds between successful !skip invocations # 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 skip(self) -> str: async with self._lock: last = None for attempt in (1, 2): try: await self._ensure() await self._cli.next() return _fmt_song(await self._cli.currentsong()) except Exception as e: last = e self._cli = None # force reconnect on retry raise last # type: ignore[misc] def _fmt_song(song: dict) -> str: artist = song.get("artist") or song.get("albumartist") or "" title = song.get("title") or song.get("file", "").rsplit("/", 1)[-1] if isinstance(artist, list): artist = ", ".join(a for a in artist if a) if isinstance(title, list): title = title[0] if title else "" out = f"{artist} — {title}".strip(" —") return out or "(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 self._last_skip = 0.0 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) async def _cmd_skip(self, writer: asyncio.StreamWriter, user: str): # Silent rate-limit so a flurry of !skip from chat doesn't multi-skip # or spam the channel with replies. First click within the window wins. now = time.monotonic() if now - self._last_skip < SKIP_COOLDOWN: 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._last_skip = now print(f"[skip] @{user} → {now_playing}", flush=True) await self._say(writer, f"⏭ skipped by @{user} → now: {now_playing}") # ─── 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() 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()) await bot.run() if __name__ == "__main__": try: asyncio.run(main()) except KeyboardInterrupt: sys.exit(0)