feat: add multi-server support

Connect to multiple IRC servers concurrently from a single config file.
Plugins are loaded once and shared; per-server state is isolated via
separate SQLite databases and per-bot runtime state (bot._pstate).

- Add build_server_configs() for [servers.*] config layout
- Bot.__init__ gains name parameter, _pstate dict for plugin isolation
- cli.py runs multiple bots via asyncio.gather
- 9 stateful plugins migrated from module-level dicts to _ps(bot) pattern
- Backward compatible: legacy [server] config works unchanged

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

plugins/twitch.py

@@ -23,11 +23,15 @@ _FETCH_TIMEOUT = 10
 _MAX_TITLE_LEN = 80
 _MAX_STREAMERS = 20
 
-# -- Module-level tracking ---------------------------------------------------
+# -- Per-bot runtime state ---------------------------------------------------
 
-_pollers: dict[str, asyncio.Task] = {}
-_streamers: dict[str, dict] = {}
-_errors: dict[str, int] = {}
+def _ps(bot):
+    """Per-bot plugin runtime state."""
+    return bot._pstate.setdefault("twitch", {
+        "pollers": {},
+        "streamers": {},
+        "errors": {},
+    })
 
 
 # -- Pure helpers ------------------------------------------------------------
@@ -149,12 +153,13 @@ def _delete(bot, key: str) -> None:
 
 async def _poll_once(bot, key: str, announce: bool = True) -> None:
     """Single poll cycle for one Twitch streamer."""
-    data = _streamers.get(key)
+    ps = _ps(bot)
+    data = ps["streamers"].get(key)
     if data is None:
         data = _load(bot, key)
     if data is None:
         return
-    _streamers[key] = data
+    ps["streamers"][key] = data
 
     login = data["login"]
 
@@ -166,13 +171,13 @@ async def _poll_once(bot, key: str, announce: bool = True) -> None:
 
     if result["error"]:
         data["last_error"] = result["error"]
-        _errors[key] = _errors.get(key, 0) + 1
-        _streamers[key] = data
+        ps["errors"][key] = ps["errors"].get(key, 0) + 1
+        ps["streamers"][key] = data
         _save(bot, key, data)
         return
 
     data["last_error"] = ""
-    _errors[key] = 0
+    ps["errors"][key] = 0
 
     was_live = data.get("was_live", False)
     old_stream_id = data.get("stream_id", "")
@@ -202,7 +207,7 @@ async def _poll_once(bot, key: str, announce: bool = True) -> None:
     else:
         data["was_live"] = False
 
-    _streamers[key] = data
+    ps["streamers"][key] = data
     _save(bot, key, data)
 
 
@@ -210,11 +215,12 @@ async def _poll_loop(bot, key: str) -> None:
     """Infinite poll loop for one Twitch streamer."""
     try:
         while True:
-            data = _streamers.get(key) or _load(bot, key)
+            ps = _ps(bot)
+            data = ps["streamers"].get(key) or _load(bot, key)
             if data is None:
                 return
             interval = data.get("interval", _DEFAULT_INTERVAL)
-            errs = _errors.get(key, 0)
+            errs = ps["errors"].get(key, 0)
             if errs >= 5:
                 interval = min(interval * 2, _MAX_INTERVAL)
             await asyncio.sleep(interval)
@@ -225,34 +231,37 @@ async def _poll_loop(bot, key: str) -> None:
 
 def _start_poller(bot, key: str) -> None:
     """Create and track a poller task."""
-    existing = _pollers.get(key)
+    ps = _ps(bot)
+    existing = ps["pollers"].get(key)
     if existing and not existing.done():
         return
     task = asyncio.create_task(_poll_loop(bot, key))
-    _pollers[key] = task
+    ps["pollers"][key] = task
 
 
-def _stop_poller(key: str) -> None:
+def _stop_poller(bot, key: str) -> None:
     """Cancel and remove a poller task."""
-    task = _pollers.pop(key, None)
+    ps = _ps(bot)
+    task = ps["pollers"].pop(key, None)
     if task and not task.done():
         task.cancel()
-    _streamers.pop(key, None)
-    _errors.pop(key, 0)
+    ps["streamers"].pop(key, None)
+    ps["errors"].pop(key, 0)
 
 
 # -- Restore on connect -----------------------------------------------------
 
 def _restore(bot) -> None:
     """Rebuild pollers from persisted state."""
+    ps = _ps(bot)
     for key in bot.state.keys("twitch"):
-        existing = _pollers.get(key)
+        existing = ps["pollers"].get(key)
         if existing and not existing.done():
             continue
         data = _load(bot, key)
         if data is None:
             continue
-        _streamers[key] = data
+        ps["streamers"][key] = data
         _start_poller(bot, key)
 
 
@@ -329,9 +338,10 @@ async def cmd_twitch(bot, message):
         if data is None:
             await bot.reply(message, f"No streamer '{name}' in this channel")
             return
-        _streamers[key] = data
+        ps = _ps(bot)
+        ps["streamers"][key] = data
         await _poll_once(bot, key, announce=True)
-        data = _streamers.get(key, data)
+        data = ps["streamers"].get(key, data)
         if data.get("last_error"):
             await bot.reply(message, f"{name}: error -- {data['last_error']}")
         elif data.get("was_live"):
@@ -417,7 +427,7 @@ async def cmd_twitch(bot, message):
             "last_error": "",
         }
         _save(bot, key, data)
-        _streamers[key] = data
+        _ps(bot)["streamers"][key] = data
         _start_poller(bot, key)
 
         reply = f"Following '{name}' ({display_name})"
@@ -446,7 +456,7 @@ async def cmd_twitch(bot, message):
             await bot.reply(message, f"No streamer '{name}' in this channel")
             return
 
-        _stop_poller(key)
+        _stop_poller(bot, key)
         _delete(bot, key)
         await bot.reply(message, f"Unfollowed '{name}'")
         return