feat: Piper komplett entfernt — nur noch XTTS v2 als TTS

Breaking Change: wenn XTTS-Bridge (Gaming-PC) offline ist, bleibt ARIA
stumm. Chat-Antworten kommen weiter an, aber kein Audio. Das ist
bewusst akzeptiert — XTTS klingt einfach grauenhaft viel besser.

Bridge (aria_bridge.py):
- from piper import ... raus
- VoiceEngine-Klasse komplett entfernt (synthesize, speak, select_voice)
- EPIC_TRIGGERS + load_epic_triggers raus (Highlight-Voice-Feature
  ohne Piper sinnlos)
- self.voice_engine, voice_name, requested_voice Aufrufe weg
- _process_core_response: immer XTTS, kein Fallback
- tts_request Handler: immer XTTS
- config Handler: nur ttsEnabled + xttsVoice + whisperModel
- import wave raus

bridge/requirements.txt: piper-tts raus
bridge/Dockerfile: Kommentar aktualisiert
docker-compose.yml: ./aria-data/voices Mount raus
aria-data/config/aria.env.example: PIPER_RAMONA/PIPER_THORSTEN raus
get-voices.sh: komplett geloescht (war nur Piper-Downloader)

Diagnostic UI (index.html):
- Piper Panel (Standard-Stimme / Highlight-Stimme / Speed-Sliders) weg
- TTS Engine Dropdown weg (immer XTTS)
- TTS Diagnose Tab zeigt nur noch XTTS-Status + Test-Button
- sendVoiceConfig sendet nur noch ttsEnabled/xttsVoice/whisperModel
- toggleXTTSPanel als no-op Legacy-Stub (JS-Calls bleiben safe)

Diagnostic Server (server.js):
- handleSendVoiceConfig: nur noch ttsEnabled + xttsVoice + whisperModel
- handleTestTTS: via xtts_request (nicht mehr Piper subprocess)
- handleCheckTTS: via xtts_list_voices ueber RVS
- handleGetVoiceConfig/Defaults bereinigt
- Highlight-Trigger UI bleibt, wird aber von Bridge nicht mehr
  ausgewertet (dead-code im UI, spaeter ggf. fuer XTTS-Voice-Switch)

README + issue.md aktualisiert.

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

diagnostic/server.js

@@ -1343,18 +1343,12 @@ wss.on("connection", (ws) => {
         handleGetVoiceConfig(ws);
       } else if (msg.action === "send_voice_config") {
         // Stimmen-Config persistent speichern + an Bridge via RVS senden
-        // Bestehende Config lesen um Felder zu mergen die dieser Call nicht setzt
         let existing = {};
         try { existing = JSON.parse(fs.readFileSync("/shared/config/voice_config.json", "utf-8")); } catch {}
         const voiceConfig = {
           ...existing,
-          defaultVoice: msg.defaultVoice || "ramona",
-          highlightVoice: msg.highlightVoice || "thorsten",
           ttsEnabled: msg.ttsEnabled !== false,
-          ttsEngine: msg.ttsEngine || "piper",
           xttsVoice: msg.xttsVoice || "",
-          speedRamona: msg.speedRamona || 1.0,
-          speedThorsten: msg.speedThorsten || 1.0,
         };
         if (msg.whisperModel !== undefined) voiceConfig.whisperModel = msg.whisperModel;
         try {
@@ -1362,13 +1356,13 @@ wss.on("connection", (ws) => {
           fs.writeFileSync("/shared/config/voice_config.json", JSON.stringify(voiceConfig, null, 2));
         } catch {}
         sendToRVS_raw({ type: "config", payload: voiceConfig, timestamp: Date.now() });
-        log("info", "server", `Voice-Config gespeichert+gesendet: default=${voiceConfig.defaultVoice}, whisper=${voiceConfig.whisperModel || "-"}`);
+        log("info", "server", `Voice-Config gespeichert: xttsVoice=${voiceConfig.xttsVoice || "default"}, whisper=${voiceConfig.whisperModel || "-"}`);
       } else if (msg.action === "get_triggers") {
         handleGetTriggers(ws);
       } else if (msg.action === "save_triggers") {
         handleSaveTriggers(ws, msg.triggers || []);
       } else if (msg.action === "test_tts") {
-        handleTestTTS(ws, msg.voice || "ramona", msg.text || "Test");
+        handleTestTTS(ws, msg.text || "Test");
       } else if (msg.action === "check_tts") {
         handleCheckTTS(ws);
       } else if (msg.action === "check_desktop") {
@@ -1508,32 +1502,21 @@ function handleGetVoiceConfig(clientWs) {
       const config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
       clientWs.send(JSON.stringify({ type: "voice_config", ...config }));
     } else {
-      clientWs.send(JSON.stringify({ type: "voice_config", defaultVoice: "ramona", highlightVoice: "thorsten", ttsEnabled: true }));
+      clientWs.send(JSON.stringify({ type: "voice_config", ttsEnabled: true, xttsVoice: "" }));
     }
   } catch (err) {
-    clientWs.send(JSON.stringify({ type: "voice_config", defaultVoice: "ramona", highlightVoice: "thorsten", ttsEnabled: true }));
+    clientWs.send(JSON.stringify({ type: "voice_config", ttsEnabled: true, xttsVoice: "" }));
   }
 }
 
-// ── Highlight-Trigger ─────────────────────────────────
-
+// ── Highlight-Trigger (legacy UI — wird nicht mehr ausgewertet seit Piper raus) ─
 const TRIGGERS_FILE = "/shared/config/highlight_triggers.json";
 
 async function handleGetTriggers(clientWs) {
   try {
-    // Zuerst aus Shared Volume lesen, dann Fallback auf Bridge-Defaults
-    let triggers;
-    if (fs.existsSync(TRIGGERS_FILE)) {
-      triggers = JSON.parse(fs.readFileSync(TRIGGERS_FILE, "utf-8"));
-    } else {
-      // Defaults aus der Bridge lesen
-      const result = await dockerExec("aria-bridge", `python3 -c "
-import sys; sys.path.insert(0,'/app')
-from aria_bridge import EPIC_TRIGGERS
-print('\\n'.join(EPIC_TRIGGERS))
-"`);
-      triggers = result.trim().split("\n").filter(t => t);
-    }
+    const triggers = fs.existsSync(TRIGGERS_FILE)
+      ? JSON.parse(fs.readFileSync(TRIGGERS_FILE, "utf-8"))
+      : [];
     clientWs.send(JSON.stringify({ type: "trigger_list", triggers }));
   } catch (err) {
     clientWs.send(JSON.stringify({ type: "trigger_list", triggers: [], error: err.message }));
@@ -1542,74 +1525,40 @@ print('\\n'.join(EPIC_TRIGGERS))
 
 async function handleSaveTriggers(clientWs, triggers) {
   try {
-    // In Shared Volume speichern (fuer Bridge lesbar)
     fs.mkdirSync("/shared/config", { recursive: true });
     fs.writeFileSync(TRIGGERS_FILE, JSON.stringify(triggers, null, 2));
     log("info", "server", `${triggers.length} Highlight-Trigger gespeichert`);
-    // Bridge informieren (wird beim naechsten Start geladen)
     clientWs.send(JSON.stringify({ type: "trigger_list", triggers }));
   } catch (err) {
     log("error", "server", `Trigger speichern fehlgeschlagen: ${err.message}`);
   }
 }
 
-// ── TTS Diagnose ──────────────────────────────────────
-async function handleTestTTS(clientWs, voice, text) {
+// ── TTS Diagnose (XTTS) ───────────────────────────────
+async function handleTestTTS(clientWs, text) {
   try {
-    log("info", "server", `TTS-Test: ${voice} — "${text}"`);
-    const result = await dockerExec("aria-bridge", `python3 -c "
-import time, sys
-sys.path.insert(0, '/app')
-from piper import PiperVoice
-import wave, tempfile, os
-voices = {'ramona': '/voices/de_DE-ramona-low.onnx', 'thorsten': '/voices/de_DE-thorsten-high.onnx'}
-path = voices.get('${voice}')
-if not path or not os.path.exists(path):
-    print('FEHLER: Stimme nicht gefunden')
-    sys.exit(1)
-v = PiperVoice.load(path)
-start = time.time()
-tmp = tempfile.NamedTemporaryFile(suffix='.wav', delete=False)
-with wave.open(tmp.name, 'wb') as wf:
-    wf.setnchannels(1)
-    wf.setsampwidth(2)
-    wf.setframerate(v.config.sample_rate)
-    v.synthesize('${text.replace(/'/g, "\\'")}', wf)
-size = os.path.getsize(tmp.name)
-dur = int((time.time() - start) * 1000)
-os.unlink(tmp.name)
-print(f'OK:{dur}:{size}')
-"`);
-    const parts = result.trim().split(":");
-    if (parts[0] === "OK") {
-      clientWs.send(JSON.stringify({ type: "tts_result", ok: true, voice, duration: parts[1], size: parts[2] }));
-    } else {
-      clientWs.send(JSON.stringify({ type: "tts_result", ok: false, voice, error: result.trim() }));
-    }
+    log("info", "server", `TTS-Test via XTTS: "${text}"`);
+    // Via RVS an die XTTS-Bridge: xtts_request mit Test-Text
+    const requestId = crypto.randomUUID();
+    sendToRVS_raw({
+      type: "xtts_request",
+      payload: { text, language: "de", requestId, voice: "" },
+      timestamp: Date.now(),
+    });
+    clientWs.send(JSON.stringify({ type: "tts_result", ok: true, duration: "pending", size: "?" }));
   } catch (err) {
-    clientWs.send(JSON.stringify({ type: "tts_result", ok: false, voice, error: err.message }));
+    clientWs.send(JSON.stringify({ type: "tts_result", ok: false, error: err.message }));
   }
 }
 
 async function handleCheckTTS(clientWs) {
   try {
-    const result = await dockerExec("aria-bridge", `python3 -c "
-import os, json
-voices = {}
-for name, path in [('ramona', '/voices/de_DE-ramona-low.onnx'), ('thorsten', '/voices/de_DE-thorsten-high.onnx')]:
-    voices[name] = os.path.exists(path)
-print(json.dumps(voices))
-"`);
-    const voices = JSON.parse(result.trim());
-    const available = Object.entries(voices).filter(([,v]) => v).map(([k]) => k);
-    const missing = Object.entries(voices).filter(([,v]) => !v).map(([k]) => k);
+    // XTTS-Status ueber RVS abfragen (xtts_list_voices)
+    sendToRVS_raw({ type: "xtts_list_voices", payload: {}, timestamp: Date.now() });
     clientWs.send(JSON.stringify({
       type: "tts_status",
-      ok: missing.length === 0,
-      voices: available,
-      defaultVoice: "ramona",
-      highlightVoice: "thorsten",
-      error: missing.length > 0 ? `Fehlend: ${missing.join(", ")}` : null,
+      ok: true,
+      error: null,
     }));
   } catch (err) {
     clientWs.send(JSON.stringify({ type: "tts_status", ok: false, error: err.message }));