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
This commit is contained in:
ZeasyAlexandClaude Opus 5 committed
1 parent
4ceb61f095
commit
d07c18441b
82 files changed
+2775
-838
No files matched your search
@@ -1,12 +0,0 @@
|
||||
{
|
||||
"name": "@abdulive/core",
|
||||
"version": "0.1.0",
|
||||
"private": true,
|
||||
"type": "module",
|
||||
"main": "dist/index.js",
|
||||
"scripts": {
|
||||
"build": "tsc -p tsconfig.json",
|
||||
"typecheck": "tsc -p tsconfig.json --noEmit",
|
||||
"test": "node --test"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
// Konfiguration und Pfade. Alles, was kein Geheimnis ist, steht in
|
||||
// config/config.yaml; Zugangsdaten liegen woanders (siehe #twitch/secrets.ts).
|
||||
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { parseYaml, type YamlMap } from './yaml.ts';
|
||||
|
||||
export const paths = {
|
||||
config: process.env.CONFIG_DIR || '/app/config',
|
||||
db: process.env.DB_DIR || '/db',
|
||||
work: process.env.WORK_DIR || '/work',
|
||||
clips: process.env.CLIPS_DIR || '/app/data/clips',
|
||||
replay: process.env.REPLAY_DIR || '/replay',
|
||||
models: process.env.MODEL_DIR || '/models',
|
||||
};
|
||||
|
||||
export type Config = {
|
||||
channel: { login: string; userId: string; language: string; timezone: string };
|
||||
bot: { login: string };
|
||||
ingest: {
|
||||
viewerPollSeconds: number;
|
||||
chattersPollSeconds: number;
|
||||
sessionGapMinutes: number;
|
||||
spike: {
|
||||
windowSeconds: number; baselineMinutes: number; factor: number;
|
||||
minDelta: number; cooldownSeconds: number; armed: boolean; laughEmotes: string[];
|
||||
};
|
||||
};
|
||||
obs: { url: string; replayBufferSeconds: number; chapterScenes: string[] };
|
||||
ingestServer: { port: number };
|
||||
dashboard: { port: number };
|
||||
raw: YamlMap;
|
||||
};
|
||||
|
||||
const DEFAULTS = {
|
||||
channel: { login: 'abdulive_', userId: '', language: 'de', timezone: 'Europe/Berlin' },
|
||||
bot: { login: '' },
|
||||
ingest: {
|
||||
viewerPollSeconds: 60,
|
||||
chattersPollSeconds: 300,
|
||||
sessionGapMinutes: 5,
|
||||
spike: {
|
||||
windowSeconds: 15, baselineMinutes: 10, factor: 3, minDelta: 4,
|
||||
cooldownSeconds: 60, armed: false,
|
||||
laughEmotes: ['KEKW', 'LUL', 'OMEGALUL', 'PogChamp', 'Pog'],
|
||||
},
|
||||
},
|
||||
obs: { url: 'ws://host.docker.internal:4455', replayBufferSeconds: 90, chapterScenes: [] },
|
||||
ingestServer: { port: 4790 },
|
||||
dashboard: { port: 4792 },
|
||||
};
|
||||
|
||||
function merge<T>(base: T, over: unknown): T {
|
||||
if (over === null || over === undefined) return base;
|
||||
if (typeof base !== 'object' || base === null || Array.isArray(base)) return over as T;
|
||||
if (typeof over !== 'object' || over === null || Array.isArray(over)) return base;
|
||||
const out: Record<string, unknown> = { ...(base as Record<string, unknown>) };
|
||||
for (const [k, v] of Object.entries(over)) {
|
||||
out[k] = k in out ? merge((base as Record<string, unknown>)[k], v) : v;
|
||||
}
|
||||
return out as T;
|
||||
}
|
||||
|
||||
let cached: Config | null = null;
|
||||
|
||||
export function loadConfig(): Config {
|
||||
if (cached) return cached;
|
||||
const file = path.join(paths.config, 'config.yaml');
|
||||
let raw: YamlMap = {};
|
||||
if (fs.existsSync(file)) {
|
||||
raw = parseYaml(fs.readFileSync(file, 'utf8'));
|
||||
}
|
||||
cached = { ...merge(DEFAULTS, raw), raw } as Config;
|
||||
return cached;
|
||||
}
|
||||
|
||||
export type Rect = { x: number; y: number; w: number; h: number };
|
||||
export type LayoutProfile = {
|
||||
description?: string;
|
||||
cam: { crop: Rect; band: { w: number; h: number } };
|
||||
game: { crop: Rect; band: { w: number; h: number } };
|
||||
};
|
||||
export type Layout = {
|
||||
source: { width: number; height: number };
|
||||
target: { width: number; height: number };
|
||||
profiles: Record<string, LayoutProfile>;
|
||||
};
|
||||
|
||||
export function loadLayout(): Layout {
|
||||
const file = path.join(paths.config, 'layout.yaml');
|
||||
return parseYaml(fs.readFileSync(file, 'utf8')) as unknown as Layout;
|
||||
}
|
||||
@@ -1,2 +0,0 @@
|
||||
// @abdulive/core — siehe docs/01-architecture.md
|
||||
export {};
|
||||
@@ -0,0 +1,63 @@
|
||||
// Logger mit Maskierung. Zugangsdaten duerfen nie in einem Log landen -
|
||||
// Logs werden weitergegeben, in Issues gepastet und im Zweifel im Stream
|
||||
// gezeigt. Siehe ADR-0005.
|
||||
|
||||
export type Level = 'debug' | 'info' | 'warn' | 'error';
|
||||
|
||||
const ORDER: Record<Level, number> = { debug: 10, info: 20, warn: 30, error: 40 };
|
||||
const MIN = ORDER[(process.env.LOG_LEVEL as Level) || 'info'] ?? ORDER.info;
|
||||
|
||||
// Feldnamen, deren Wert nie ausgegeben wird
|
||||
const SECRET_KEYS =
|
||||
/(secret|token|password|passwort|authorization|client_?id|refresh|api_?key|webhook)/i;
|
||||
|
||||
// Muster, die auch in freiem Text maskiert werden
|
||||
const SECRET_PATTERNS: Array<[RegExp, string]> = [
|
||||
[/oauth:[A-Za-z0-9]+/g, 'oauth:•••'],
|
||||
[/\b[a-z0-9]{30}\b/g, '•••'], // Twitch Client-ID / Token
|
||||
[/\bBearer\s+\S+/gi, 'Bearer •••'],
|
||||
];
|
||||
|
||||
export function mask(value: unknown): unknown {
|
||||
if (typeof value === 'string') {
|
||||
let out = value;
|
||||
for (const [re, replacement] of SECRET_PATTERNS) out = out.replace(re, replacement);
|
||||
return out;
|
||||
}
|
||||
if (Array.isArray(value)) return value.map(mask);
|
||||
if (value && typeof value === 'object') {
|
||||
const out: Record<string, unknown> = {};
|
||||
for (const [k, v] of Object.entries(value)) {
|
||||
out[k] = SECRET_KEYS.test(k) ? (v == null ? v : '•••') : mask(v);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
function emit(level: Level, scope: string, msg: string, extra?: unknown) {
|
||||
if (ORDER[level] < MIN) return;
|
||||
const ts = new Date().toISOString().slice(11, 23);
|
||||
const tag = level.toUpperCase().padEnd(5);
|
||||
let line = `${ts} ${tag} [${scope}] ${String(mask(msg))}`;
|
||||
if (extra !== undefined) line += ` ${JSON.stringify(mask(extra))}`;
|
||||
(level === 'error' || level === 'warn' ? console.error : console.log)(line);
|
||||
}
|
||||
|
||||
export type Logger = {
|
||||
debug(msg: string, extra?: unknown): void;
|
||||
info(msg: string, extra?: unknown): void;
|
||||
warn(msg: string, extra?: unknown): void;
|
||||
error(msg: string, extra?: unknown): void;
|
||||
child(sub: string): Logger;
|
||||
};
|
||||
|
||||
export function logger(scope: string): Logger {
|
||||
return {
|
||||
debug: (m, e) => emit('debug', scope, m, e),
|
||||
info: (m, e) => emit('info', scope, m, e),
|
||||
warn: (m, e) => emit('warn', scope, m, e),
|
||||
error: (m, e) => emit('error', scope, m, e),
|
||||
child: (sub) => logger(`${scope}:${sub}`),
|
||||
};
|
||||
}
|
||||
@@ -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; }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
// Minimaler YAML-Leser fuer unsere eigenen Konfigurationsdateien.
|
||||
//
|
||||
// Deckt genau das ab, was config/*.yaml benutzt: verschachtelte Maps ueber
|
||||
// Einrueckung, Skalare, Inline-Maps `{a: 1, b: 2}`, Listen aus Skalaren und
|
||||
// Blockskalare (`>` / `|`). Bewusst kein vollstaendiges YAML - das Projekt
|
||||
// kommt ohne npm-Abhaengigkeiten aus, und der Sprachumfang, den wir selbst
|
||||
// schreiben, ist ueberschaubar.
|
||||
|
||||
export type YamlValue = string | number | boolean | null | YamlValue[] | { [k: string]: YamlValue };
|
||||
export type YamlMap = { [k: string]: YamlValue };
|
||||
|
||||
function scalar(raw: string): YamlValue {
|
||||
const s = raw.trim();
|
||||
if (s === '' || s === '~' || s === 'null') return null;
|
||||
if (s === 'true') return true;
|
||||
if (s === 'false') return false;
|
||||
if (/^-?\d+$/.test(s)) return Number.parseInt(s, 10);
|
||||
if (/^-?\d*\.\d+$/.test(s)) return Number.parseFloat(s);
|
||||
if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
|
||||
return s.slice(1, -1);
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
function flowMap(raw: string): YamlMap {
|
||||
const out: YamlMap = {};
|
||||
for (const part of raw.slice(1, -1).split(',')) {
|
||||
if (!part.trim()) continue;
|
||||
const i = part.indexOf(':');
|
||||
if (i === -1) continue;
|
||||
out[part.slice(0, i).trim()] = scalar(part.slice(i + 1));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
function stripComment(line: string): string {
|
||||
let quote: string | null = null;
|
||||
for (let i = 0; i < line.length; i++) {
|
||||
const c = line[i]!;
|
||||
if (quote) {
|
||||
if (c === quote) quote = null;
|
||||
} else if (c === '"' || c === "'") {
|
||||
quote = c;
|
||||
} else if (c === '#' && (i === 0 || /\s/.test(line[i - 1]!))) {
|
||||
return line.slice(0, i);
|
||||
}
|
||||
}
|
||||
return line;
|
||||
}
|
||||
|
||||
type Frame = { indent: number; target: YamlMap; listKey?: string };
|
||||
|
||||
export function parseYaml(text: string): YamlMap {
|
||||
const lines = text.split(/\r?\n/);
|
||||
const root: YamlMap = {};
|
||||
const stack: Frame[] = [{ indent: -1, target: root }];
|
||||
let i = 0;
|
||||
|
||||
while (i < lines.length) {
|
||||
const line = stripComment(lines[i]!);
|
||||
if (!line.trim()) { i++; continue; }
|
||||
|
||||
const indent = line.length - line.trimStart().length;
|
||||
const body = line.trim();
|
||||
|
||||
while (stack.length > 1 && indent <= stack[stack.length - 1]!.indent) stack.pop();
|
||||
const frame = stack[stack.length - 1]!;
|
||||
|
||||
if (body.startsWith('- ')) {
|
||||
const key = frame.listKey;
|
||||
const list = key ? frame.target[key] : undefined;
|
||||
if (Array.isArray(list)) list.push(scalar(body.slice(2)));
|
||||
i++;
|
||||
continue;
|
||||
}
|
||||
|
||||
const colon = body.indexOf(':');
|
||||
if (colon === -1) { i++; continue; }
|
||||
const key = body.slice(0, colon).trim();
|
||||
const rest = body.slice(colon + 1).trim();
|
||||
|
||||
if (rest === '') {
|
||||
// Verschachtelte Map, Liste oder leerer Wert - die naechste
|
||||
// inhaltstragende Zeile entscheidet
|
||||
let j = i + 1;
|
||||
while (j < lines.length && !stripComment(lines[j]!).trim()) j++;
|
||||
const next = j < lines.length ? stripComment(lines[j]!) : '';
|
||||
const nextIndent = next ? next.length - next.trimStart().length : -1;
|
||||
if (next && nextIndent > indent && next.trim().startsWith('- ')) {
|
||||
frame.target[key] = [];
|
||||
stack.push({ indent, target: frame.target, listKey: key });
|
||||
} else if (next && nextIndent > indent) {
|
||||
const child: YamlMap = {};
|
||||
frame.target[key] = child;
|
||||
stack.push({ indent, target: child });
|
||||
} else {
|
||||
frame.target[key] = null;
|
||||
}
|
||||
} else if (rest === '>' || rest === '|' || rest === '>-' || rest === '|-') {
|
||||
const parts: string[] = [];
|
||||
let j = i + 1;
|
||||
for (; j < lines.length; j++) {
|
||||
const raw = lines[j]!;
|
||||
if (!raw.trim()) { parts.push(''); continue; }
|
||||
if (raw.length - raw.trimStart().length <= indent) break;
|
||||
parts.push(raw.trim());
|
||||
}
|
||||
frame.target[key] = rest.startsWith('>') ? parts.join(' ').trim() : parts.join('\n');
|
||||
i = j;
|
||||
continue;
|
||||
} else if (rest.startsWith('{')) {
|
||||
frame.target[key] = flowMap(rest);
|
||||
} else if (rest.startsWith('[')) {
|
||||
frame.target[key] = rest.slice(1, -1).split(',').map(scalar).filter((v) => v !== null);
|
||||
} else {
|
||||
frame.target[key] = scalar(rest);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
|
||||
return root;
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
{
|
||||
"extends": "../../tsconfig.base.json",
|
||||
"compilerOptions": { "outDir": "dist", "rootDir": "src" },
|
||||
"include": ["src"]
|
||||
}
|
||||
Reference in new issue
Block a user