Vorlesen: Piper im Hub statt Sprachausgabe im Browser

In OBS' Browser-Quelle kam `speechSynthesis` amerikanisch heraus: der
eingebaute Browser sah keine deutsche Stimme, und die Seite nahm die erste
beliebige. Welche Stimmen es gibt, haengt am Rechner, der streamt.

Jetzt spricht der Hub mit Piper (lokal im LXC, 200 Zeichen in 0,7 s). Die
WAV liegt kurz im Speicher, `/tts` holt sie unter /tts/audio/<id> mit dem
Overlay-Schluessel und spielt sie ueber <audio> ab - das laeuft sicher ueber
OBS' Tonspur. Der Browser springt nur noch mit einer deutschen Stimme ein,
sonst wird nur angezeigt. Stimme und Sprecher stehen in rewards.tts.

Dazu:

- `abdulive rewards:anlegen`: Belohnung ueber die API anlegen. Nur die App,
  die sie angelegt hat, darf Einloesungen abschliessen oder erstatten.
- Einloesungen werden nach der Aktion als FULFILLED markiert, statt in
  Twitchs Warteschlange liegen zu bleiben.
- Wortfilter normalisiert vorher: Leetspeak, Punkte dazwischen, gezogene
  Buchstaben, Akzente. Kurze Eintraege nur am Wortanfang.
- Der Testknopf "Vorlesen" geht durch Piper und prueft so die echte Stimme.
- scripts/install-piper.sh richtet Piper und Stimme im LXC ein.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>

apps/hub/src/index.ts

@@ -32,9 +32,11 @@ import { readSecrets } from '#twitch/secrets.ts';
 import { createEventSub } from '#twitch/eventsub.ts';
 import { createIrc, type UserNotice } from '#twitch/irc.ts';
 import { streamWechsel } from '#twitch/stream-state.ts';
+import { piperFehlt, sprechen, stimmenPfad } from '#media/piper.ts';
 import {
   ausEventSub, createDrossel, createWarteschlange, entscheiden,
 } from './rewards.ts';
+import { createAudioAblage } from './audio-ablage.ts';
 import { createAnnouncer, type StreamInfo } from '../../broadcaster/src/golive.ts';
 import { createSpikeDetector } from '../../ingest/src/spike.ts';
 import { createBus, type AlertEvent, type Bus } from '../../overlay-server/src/bus.ts';
@@ -94,24 +96,63 @@ export async function runHub(): Promise<void> {
   const warteschlange = createWarteschlange();
   const drossel = createDrossel();
 
-  /** Punkte zurueckgeben. Ohne den Scope nicht moeglich - dann nur melden. */
-  const erstatten = async (rewardId: string, redemptionId: string): Promise<void> => {
+  /**
+   * Eine Einloesung abschliessen (FULFILLED) oder die Punkte zurueckgeben
+   * (CANCELED). Geht nur bei Belohnungen, die das Toolkit selbst angelegt hat
+   * (`abdulive rewards:anlegen`) - sonst lehnt Twitch ab, und es bleibt bei
+   * einer Warnung.
+   */
+  const einloesungSetzen = async (
+    rewardId: string, redemptionId: string, status: 'FULFILLED' | 'CANCELED',
+  ): Promise<void> => {
+    const was = status === 'CANCELED' ? 'Punkte nicht erstattet' : 'Einloesung nicht abgeschlossen';
     if (!state.broadcasterId) return;
     if (!helix.hasScope('channel:manage:redemptions')) {
-      log.warn('Punkte nicht erstattet: dem verbundenen Konto fehlt ' +
+      log.warn(`${was}: dem verbundenen Konto fehlt ` +
         'channel:manage:redemptions. Einmal neu verbinden unter /setup.');
       return;
     }
     try {
-      await helix.setRedemptionStatus(state.broadcasterId, rewardId, redemptionId, 'CANCELED');
+      await helix.setRedemptionStatus(state.broadcasterId, rewardId, redemptionId, status);
     } catch (err) {
-      log.warn(`Punkte nicht erstattet: ${(err as Error).message}`);
+      log.warn(`${was}: ${(err as Error).message}`);
     }
   };
+  const erstatten = (rewardId: string, redemptionId: string): Promise<void> =>
+    einloesungSetzen(rewardId, redemptionId, 'CANCELED');
 
-  const vorlesen = (id: string, name: string, text: string): void => {
-    bus.publish({ kind: 'tts', id, name, text });
+  // ---- Vorlesen. Die Stimme entsteht hier im Hub (Piper), nicht im Browser:
+  // dort haengt sie am Rechner, der streamt, und kam in OBS amerikanisch.
+  const stimme = {
+    model: stimmenPfad(cfg.rewards.tts.stimme),
+    ...(typeof cfg.rewards.tts.sprecher === 'number' ? { speaker: cfg.rewards.tts.sprecher } : {}),
+  };
+  const audio = createAudioAblage();
+  const stimmeFehlt = piperFehlt(stimme);
+  if (stimmeFehlt.length) {
+    log.warn(`Vorlesen ohne Stimme - es fehlt: ${stimmeFehlt.join(', ')}. ` +
+      'Einrichten mit scripts/install-piper.sh. Bis dahin wird nur angezeigt.');
+  }
+
+  const vorlesen = async (
+    id: string, name: string, text: string,
+    /** Fehlt beim Testknopf - dann gibt es bei Twitch nichts abzuschliessen. */
+    einloesung?: { rewardId: string; redemptionId: string },
+  ): Promise<void> => {
+    let mitTon = false;
+    try {
+      audio.ablegen(id, await sprechen(text, stimme));
+      mitTon = true;
+    } catch (err) {
+      // Lieber stumm anzeigen als gar nicht: wer Punkte ausgegeben hat, soll
+      // seine Nachricht wenigstens im Bild sehen.
+      log.warn(`Nicht gesprochen, nur angezeigt: ${(err as Error).message}`);
+    }
+    bus.publish({ kind: 'tts', id, name, text, audio: mitTon });
     log.info(`Wird vorgelesen (${name}): ${text.slice(0, 60)}`);
+    // Auch ohne Ton abgeschlossen: angezeigt wurde es, und eine Einloesung,
+    // die ewig in Twitchs Warteschlange haengt, raeumt niemand auf.
+    if (einloesung) void einloesungSetzen(einloesung.rewardId, einloesung.redemptionId, 'FULFILLED');
   };
 
   const behandleEinloesung = (roh: Record<string, unknown>): void => {
@@ -149,10 +190,11 @@ export async function runHub(): Promise<void> {
         if (ent.aktion === 'konfetti') bus.publish({ kind: 'konfetti', staerke: 1 });
         if (ent.aktion === 'emote-regen') bus.publish({ kind: 'hype', score: 5, rate: 40 });
         log.info(`${e.userName} hat "${e.rewardTitle}" eingeloest -> ${ent.aktion}`);
+        void einloesungSetzen(e.rewardId, e.id, 'FULFILLED');
         break;
 
       case 'vorlesen':
-        vorlesen(ulid(), e.userName, ent.text);
+        void vorlesen(ulid(), e.userName, ent.text, { rewardId: e.rewardId, redemptionId: e.id });
         break;
 
       case 'warteschlange':
@@ -279,6 +321,7 @@ export async function runHub(): Promise<void> {
         goLive: announcer.lastResult() ?? 'noch nichts',
         overlayClients: bus.clients(),
         ttsWartend: warteschlange.liste().length,
+        ttsStimme: stimmeFehlt.length ? `fehlt: ${stimmeFehlt.join(', ')}` : 'bereit',
         spikeArmed: spikes.isArmed(),
         note: state.chatAnonymous
           ? 'Chat wird anonym mitgelesen. Zum Senden und fuer Helix: Einrichtung unter /setup.'
@@ -291,7 +334,7 @@ export async function runHub(): Promise<void> {
       freigeben: (id) => {
         const w = warteschlange.entnehmen(id);
         if (!w) return false;
-        vorlesen(w.id, w.name, w.text);
+        void vorlesen(w.id, w.name, w.text, { rewardId: w.rewardId, redemptionId: w.redemptionId });
         return true;
       },
       ablehnen: (id) => {
@@ -307,8 +350,11 @@ export async function runHub(): Promise<void> {
         if (alle.length) log.info(`${alle.length} wartende Nachricht(en) abgelehnt`);
         return alle.length;
       },
+      probe: (name, text) => { void vorlesen(ulid(), name, text); },
+      audio: (id) => audio.holen(id),
       still: () => {
         bus.publish({ kind: 'still' });
+        audio.leeren();
         const alle = warteschlange.leeren();
         for (const w of alle) void erstatten(w.rewardId, w.redemptionId);
         log.warn('Panikschalter: Vorlesen gestoppt und Warteschlange geleert');