S1: Einrichtungs-Assistent, Twitch-Auth, Datenbank und Chat-Aufnahme

Zugangsdaten kommen jetzt aus der App statt aus einer .env: ein Einrichtungs-Assistent auf http://localhost:4792/setup nimmt Client-ID, Secret und OBS-Passwort entgegen, der OAuth-Rueckruf laeuft auf denselben Server. Gespeichert wird verschlueselt (AES-256-GCM) in einem Volume, bewusst nicht in der Datenbank - die wird auf die Windows-Seite gesichert. Siehe ADR-0005. Technikbasis vereinfacht: Node 24 bringt node:sqlite, WebSocket, fetch und die Ausfuehrung von TypeScript mit. Das Projekt hat damit null Laufzeitabhaengigkeiten und keinen Build-Schritt; pnpm-Workspaces und die Paketmanifeste sind entfallen, Importe laufen ueber die imports-Map der Wurzel-package.json. erasableSyntaxOnly verhindert Syntax, die das Type Stripping stillschweigend entfernen wuerde. Siehe Nachtrag 2 in ADR-0001. Enthalten: - packages/core: Config, Layout, Logger mit Secret-Maskierung, Retry, YAML - packages/db: Migrationen, Repositories, alle SQL-Anweisungen an einem Ort - packages/twitch: Secret-Speicher, OAuth, Helix mit Token-Bucket, IRC - apps/ingest: Daemon, Einrichtungsseite, Spike-Erkennung - 20 Tests (IRC-Parser, Spike-Detektor, Datenbankschicht) Der Chat verbindet sich anonym, solange nichts hinterlegt ist - damit laesst sich die Datenaufnahme pruefen, bevor die Twitch-Apps existieren. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_013VTGjd92LsDDWF3frd9FTB
2026-09-09 09:56:55 +02:00
1 parent 4ceb61f095
commit d07c18441b
@@ -0,0 +1,202 @@
+// Twitch-Chat ueber IRC (WebSocket). Warum IRC und nicht EventSub: die
+// IRCv3-Tags enthalten first-msg, returning-chatter, msg-id, badges und
+// Emote-Positionen - genau das, woran Community-Gedaechtnis und
+// Spike-Erkennung haengen. Siehe ADR-0003.
+//
+// Ohne Zugangsdaten wird anonym verbunden (justinfan). Dann kann man mitlesen,
+// aber nicht schreiben - reicht, um die Datenaufnahme zu pruefen, bevor die
+// Twitch-Apps eingerichtet sind.
+
+import { logger } from '#core/logger.ts';
+import { forever } from '#core/retry.ts';
+import type { ChatMessage } from '#shared/events.ts';
+import { accessToken } from './oauth.ts';
+import { readSecrets } from './secrets.ts';
+
+const log = logger('irc');
+const URL_WS = 'wss://irc-ws.chat.twitch.tv:443';
+
+export type IrcMessage = { tags: Record<string, string>; prefix: string; command: string; params: string[] };
+
+/** IRCv3-Zeile zerlegen: `@tags :prefix COMMAND params :trailing` */
+export function parseLine(line: string): IrcMessage | null {
+  if (!line) return null;
+  let rest = line;
+  const tags: Record<string, string> = {};
+
+  if (rest.startsWith('@')) {
+    const sp = rest.indexOf(' ');
+    for (const pair of rest.slice(1, sp).split(';')) {
+      const eq = pair.indexOf('=');
+      const k = eq === -1 ? pair : pair.slice(0, eq);
+      const v = eq === -1 ? '' : pair.slice(eq + 1);
+      tags[k] = v
+        .replace(/\\s/g, ' ').replace(/\\n/g, '\n').replace(/\\r/g, '\r')
+        .replace(/\\:/g, ';').replace(/\\\\/g, '\\');
+    }
+    rest = rest.slice(sp + 1);
+  }
+
+  let prefix = '';
+  if (rest.startsWith(':')) {
+    const sp = rest.indexOf(' ');
+    prefix = rest.slice(1, sp);
+    rest = rest.slice(sp + 1);
+  }
+
+  const trailingAt = rest.indexOf(' :');
+  const head = trailingAt === -1 ? rest : rest.slice(0, trailingAt);
+  const parts = head.split(' ').filter(Boolean);
+  const command = parts.shift() ?? '';
+  if (trailingAt !== -1) parts.push(rest.slice(trailingAt + 2));
+  return { tags, prefix, command, params: parts };
+}
+
+function parseEmotes(tag: string | undefined, text: string): ChatMessage['emotes'] {
+  if (!tag) return [];
+  const out: ChatMessage['emotes'] = [];
+  const chars = [...text];
+  for (const part of tag.split('/')) {
+    const [id, ranges] = part.split(':');
+    if (!id || !ranges) continue;
+    const spans = ranges.split(',');
+    const first = spans[0]?.split('-');
+    const name = first && first[0] !== undefined && first[1] !== undefined
+      ? chars.slice(Number(first[0]), Number(first[1]) + 1).join('')
+      : id;
+    out.push({ id, name, count: spans.length });
+  }
+  return out;
+}
+
+export function toChatMessage(m: IrcMessage): ChatMessage | null {
+  if (m.command !== 'PRIVMSG') return null;
+  const text = m.params[1] ?? '';
+  const login = m.prefix.split('!')[0] ?? '';
+  const userId = m.tags['user-id'];
+  if (!userId) return null;
+  const badges = m.tags['badges'] ?? '';
+  return {
+    id: m.tags['id'] ?? `${userId}-${Date.now()}`,
+    ts: new Date(Number(m.tags['tmi-sent-ts'] ?? Date.now())).toISOString(),
+    userId,
+    login,
+    displayName: m.tags['display-name'] || login,
+    text,
+    emotes: parseEmotes(m.tags['emotes'], text),
+    isFirst: m.tags['first-msg'] === '1',
+    isReturning: m.tags['returning-chatter'] === '1',
+    isCommand: text.startsWith('!'),
+    isMod: m.tags['mod'] === '1' || badges.includes('broadcaster'),
+    isSub: m.tags['subscriber'] === '1',
+    isBroadcaster: badges.includes('broadcaster'),
+    bits: Number(m.tags['bits'] ?? 0),
+    color: m.tags['color'] || null,
+  };
+}
+
+export type IrcHandlers = {
+  onMessage: (msg: ChatMessage) => void;
+  onNotice?: (text: string) => void;
+  onConnected?: (anonymous: boolean) => void;
+};
+
+export type IrcClient = {
+  /** Haelt die Verbindung dauerhaft; kehrt erst bei `signal.abort` zurueck. */
+  run: (signal: AbortSignal) => Promise<void>;
+  /** Sendet in den Chat. Anonym verbundene Clients koennen nicht senden. */
+  say: (text: string) => boolean;
+  isAnonymous: () => boolean;
+};
+
+export function createIrc(channel: string, handlers: IrcHandlers): IrcClient {
+  let send: ((text: string) => boolean) | null = null;
+  let anonymous = true;
+
+  return {
+    run: (signal) => forever(
+      async (sig) => {
+        const conn = await connectOnce(channel, handlers, sig, (fn, anon) => {
+          send = fn; anonymous = anon;
+        });
+        void conn;
+      },
+      {
+        signal,
+        onWait: (ms, n) =>
+          log.warn(`Chat getrennt, neuer Versuch in ${Math.round(ms / 1000)} s (${n}.)`),
+      }
+    ),
+    say: (text) => (send ? send(text) : false),
+    isAnonymous: () => anonymous,
+  };
+}
+
+function connectOnce(
+  channel: string,
+  handlers: IrcHandlers,
+  signal: AbortSignal,
+  ready: (say: (text: string) => boolean, anonymous: boolean) => void
+): Promise<void> {
+  return new Promise<void>((_resolve, reject) => {
+    const ws = new WebSocket(URL_WS);
+    let anonymous = true;
+    let joined = false;
+    let alive: ReturnType<typeof setInterval> | null = null;
+
+    const shutdown = (why: string) => {
+      if (alive) clearInterval(alive);
+      try { ws.close(); } catch { /* schon zu */ }
+      reject(new Error(why));
+    };
+    signal.addEventListener('abort', () => shutdown('abgebrochen'), { once: true });
+
+    ws.addEventListener('open', () => {
+      void (async () => {
+        ws.send('CAP REQ :twitch.tv/tags twitch.tv/commands');
+        const bot = readSecrets().tokens.bot;
+        if (bot) {
+          try {
+            ws.send(`PASS oauth:${await accessToken('bot')}`);
+            ws.send(`NICK ${bot.login}`);
+            anonymous = false;
+          } catch (err) {
+            log.warn(`Bot-Token nicht nutzbar, lese anonym mit: ${(err as Error).message}`);
+          }
+        }
+        if (anonymous) ws.send(`NICK justinfan${10_000 + Math.floor(Math.random() * 80_000)}`);
+        ws.send(`JOIN #${channel.toLowerCase()}`);
+      })();
+    });
+
+    ws.addEventListener('message', (ev) => {
+      for (const line of String(ev.data).split('\r\n')) {
+        const m = parseLine(line);
+        if (!m) continue;
+
+        if (m.command === 'PING') { ws.send(`PONG :${m.params[0] ?? 'tmi.twitch.tv'}`); continue; }
+        if (m.command === 'JOIN' && !joined) {
+          joined = true;
+          log.info(`Chat verbunden mit #${channel}${anonymous ? ' (anonym, nur lesend)' : ''}`);
+          ready((text) => {
+            if (anonymous || ws.readyState !== WebSocket.OPEN) return false;
+            ws.send(`PRIVMSG #${channel.toLowerCase()} :${text}`);
+            return true;
+          }, anonymous);
+          handlers.onConnected?.(anonymous);
+          // Twitch schliesst stille Verbindungen; alle 4 Minuten ein Lebenszeichen
+          alive = setInterval(() => { try { ws.send('PING :keepalive'); } catch { /* egal */ } }, 240_000);
+          continue;
+        }
+        if (m.command === 'NOTICE') { handlers.onNotice?.(m.params[1] ?? ''); continue; }
+        if (m.command === 'PRIVMSG') {
+          const msg = toChatMessage(m);
+          if (msg) handlers.onMessage(msg);
+        }
+      }
+    });
+
+    ws.addEventListener('error', () => shutdown('WebSocket-Fehler'));
+    ws.addEventListener('close', (ev) => shutdown(`Verbindung geschlossen (${ev.code})`));
+  });
+}