ZeasyAlexandClaude Opus 5
d07c18441b
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
71 lines
2.3 KiB
TypeScript
71 lines
2.3 KiB
TypeScript
// 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; }
|
|
}
|
|
}
|