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

packages/core/src/retry.ts

@@ -0,0 +1,70 @@
+// Wiederholung mit exponentiellem Backoff und Jitter. Jeder Netzwerkaufruf
+// laeuft hierdurch - siehe docs/01-architecture.md, Abschnitt Fehlerverhalten.
+
+export type RetryOptions = {
+  attempts?: number;
+  baseMs?: number;
+  maxMs?: number;
+  onRetry?: (err: unknown, attempt: number, waitMs: number) => void;
+  signal?: AbortSignal;
+};
+
+export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(new Error('abgebrochen'));
+    const t = setTimeout(resolve, ms);
+    signal?.addEventListener('abort', () => { clearTimeout(t); reject(new Error('abgebrochen')); },
+      { once: true });
+  });
+}
+
+export async function retry<T>(fn: () => Promise<T>, opts: RetryOptions = {}): Promise<T> {
+  const attempts = opts.attempts ?? 5;
+  const base = opts.baseMs ?? 500;
+  const max = opts.maxMs ?? 30_000;
+  let lastErr: unknown;
+
+  for (let i = 0; i < attempts; i++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastErr = err;
+      if (i === attempts - 1) break;
+      const backoff = Math.min(max, base * 2 ** i);
+      const wait = Math.round(backoff * (0.5 + Math.random() * 0.5));
+      opts.onRetry?.(err, i + 1, wait);
+      await sleep(wait, opts.signal);
+    }
+  }
+  throw lastErr;
+}
+
+/**
+ * Haelt eine Verbindung dauerhaft am Leben: `connect` wird nach jedem Ende
+ * neu aufgerufen, mit wachsender Pause. Der Zaehler wird zurueckgesetzt,
+ * sobald eine Verbindung laenger als `stableMs` gehalten hat - sonst waechst
+ * die Pause nach Tagen Laufzeit ins Absurde.
+ */
+export async function forever(
+  connect: (signal: AbortSignal) => Promise<void>,
+  opts: { signal: AbortSignal; baseMs?: number; maxMs?: number; stableMs?: number;
+          onWait?: (ms: number, failures: number) => void }
+): Promise<void> {
+  const base = opts.baseMs ?? 1000;
+  const max = opts.maxMs ?? 60_000;
+  const stable = opts.stableMs ?? 60_000;
+  let failures = 0;
+
+  while (!opts.signal.aborted) {
+    const started = Date.now();
+    try {
+      await connect(opts.signal);
+    } catch { /* Ursache hat der Aufrufer schon geloggt */ }
+    if (opts.signal.aborted) return;
+    if (Date.now() - started > stable) failures = 0;
+    failures++;
+    const wait = Math.min(max, base * 2 ** (failures - 1));
+    opts.onWait?.(wait, failures);
+    try { await sleep(wait, opts.signal); } catch { return; }
+  }
+}