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"]
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
-- Grundschema. Siehe docs/03-data-model.md.
|
||||
-- Zugangsdaten stehen bewusst NICHT hier drin (ADR-0005) - diese Datei
|
||||
-- wird per VACUUM INTO auf die Windows-Seite gesichert.
|
||||
|
||||
CREATE TABLE events (
|
||||
id TEXT PRIMARY KEY,
|
||||
ts TEXT NOT NULL,
|
||||
type TEXT NOT NULL,
|
||||
stream_id TEXT,
|
||||
user_id TEXT,
|
||||
payload TEXT NOT NULL
|
||||
);
|
||||
CREATE INDEX idx_events_ts ON events(ts);
|
||||
CREATE INDEX idx_events_type ON events(type, ts);
|
||||
CREATE INDEX idx_events_strm ON events(stream_id, ts);
|
||||
|
||||
CREATE TABLE streams (
|
||||
id TEXT PRIMARY KEY,
|
||||
started_at TEXT NOT NULL,
|
||||
ended_at TEXT,
|
||||
vod_id TEXT,
|
||||
peak_viewers INTEGER NOT NULL DEFAULT 0,
|
||||
avg_viewers REAL,
|
||||
unique_chatters INTEGER NOT NULL DEFAULT 0,
|
||||
new_followers INTEGER NOT NULL DEFAULT 0
|
||||
);
|
||||
|
||||
CREATE TABLE stream_segments (
|
||||
id INTEGER PRIMARY KEY,
|
||||
stream_id TEXT NOT NULL REFERENCES streams(id),
|
||||
started_at TEXT NOT NULL,
|
||||
ended_at TEXT,
|
||||
title TEXT,
|
||||
category_id TEXT,
|
||||
category TEXT,
|
||||
obs_scene TEXT
|
||||
);
|
||||
CREATE INDEX idx_segments_stream ON stream_segments(stream_id, started_at);
|
||||
|
||||
CREATE TABLE viewer_samples (
|
||||
stream_id TEXT NOT NULL REFERENCES streams(id),
|
||||
ts TEXT NOT NULL,
|
||||
viewers INTEGER NOT NULL,
|
||||
PRIMARY KEY (stream_id, ts)
|
||||
);
|
||||
|
||||
CREATE TABLE users (
|
||||
id TEXT PRIMARY KEY,
|
||||
login TEXT NOT NULL,
|
||||
display_name TEXT NOT NULL,
|
||||
first_seen_at TEXT NOT NULL,
|
||||
last_seen_at TEXT NOT NULL,
|
||||
streams_present INTEGER NOT NULL DEFAULT 0,
|
||||
streams_chatted INTEGER NOT NULL DEFAULT 0,
|
||||
message_count INTEGER NOT NULL DEFAULT 0,
|
||||
is_follower INTEGER NOT NULL DEFAULT 0,
|
||||
followed_at TEXT,
|
||||
is_sub INTEGER NOT NULL DEFAULT 0,
|
||||
sub_tier TEXT,
|
||||
points INTEGER NOT NULL DEFAULT 0,
|
||||
watch_minutes INTEGER NOT NULL DEFAULT 0,
|
||||
greeting TEXT,
|
||||
notes TEXT,
|
||||
pronouns TEXT,
|
||||
muted_greeting INTEGER NOT NULL DEFAULT 0
|
||||
);
|
||||
CREATE INDEX idx_users_login ON users(login);
|
||||
|
||||
CREATE TABLE user_streams (
|
||||
user_id TEXT NOT NULL REFERENCES users(id),
|
||||
stream_id TEXT NOT NULL REFERENCES streams(id),
|
||||
first_ts TEXT NOT NULL,
|
||||
last_ts TEXT NOT NULL,
|
||||
messages INTEGER NOT NULL DEFAULT 0,
|
||||
minutes INTEGER NOT NULL DEFAULT 0,
|
||||
PRIMARY KEY (user_id, stream_id)
|
||||
);
|
||||
|
||||
CREATE TABLE chat_messages (
|
||||
id TEXT PRIMARY KEY,
|
||||
stream_id TEXT REFERENCES streams(id),
|
||||
ts TEXT NOT NULL,
|
||||
user_id TEXT NOT NULL REFERENCES users(id),
|
||||
text TEXT NOT NULL,
|
||||
emotes TEXT,
|
||||
is_first INTEGER NOT NULL DEFAULT 0,
|
||||
is_command INTEGER NOT NULL DEFAULT 0,
|
||||
bits INTEGER NOT NULL DEFAULT 0
|
||||
);
|
||||
CREATE INDEX idx_chat_stream_ts ON chat_messages(stream_id, ts);
|
||||
CREATE INDEX idx_chat_user ON chat_messages(user_id, ts);
|
||||
|
||||
CREATE TABLE clips (
|
||||
id TEXT PRIMARY KEY,
|
||||
twitch_clip_id TEXT,
|
||||
stream_id TEXT REFERENCES streams(id),
|
||||
created_at TEXT NOT NULL,
|
||||
trigger TEXT NOT NULL,
|
||||
trigger_score REAL,
|
||||
source TEXT NOT NULL,
|
||||
raw_path TEXT,
|
||||
vertical_path TEXT,
|
||||
subtitle_path TEXT,
|
||||
duration_s REAL,
|
||||
title TEXT,
|
||||
transcript TEXT,
|
||||
status TEXT NOT NULL,
|
||||
score REAL,
|
||||
uploaded_to TEXT
|
||||
);
|
||||
CREATE INDEX idx_clips_stream ON clips(stream_id, created_at);
|
||||
@@ -1,12 +0,0 @@
|
||||
{
|
||||
"name": "@abdulive/db",
|
||||
"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"
|
||||
}
|
||||
}
|
||||
@@ -1,2 +1,63 @@
|
||||
// @abdulive/db — siehe docs/03-data-model.md
|
||||
export {};
|
||||
// SQLite ueber das eingebaute node:sqlite - keine native Abhaengigkeit,
|
||||
// kein node-gyp, kein Build. Siehe ADR-0002.
|
||||
|
||||
import { DatabaseSync } from 'node:sqlite';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import { paths } from '#core/config.ts';
|
||||
import { logger } from '#core/logger.ts';
|
||||
|
||||
const log = logger('db');
|
||||
const MIGRATIONS = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'migrations');
|
||||
|
||||
export type Db = DatabaseSync;
|
||||
|
||||
let db: Db | null = null;
|
||||
|
||||
export function openDb(file = path.join(paths.db, 'abdulive.db')): Db {
|
||||
if (db) return db;
|
||||
fs.mkdirSync(path.dirname(file), { recursive: true });
|
||||
const handle = new DatabaseSync(file);
|
||||
|
||||
// WAL erlaubt beliebig viele Leser neben einem Schreiber - genau unsere
|
||||
// Topologie. busy_timeout faengt die kurzen Ueberschneidungen ab.
|
||||
handle.exec('PRAGMA journal_mode = WAL');
|
||||
handle.exec('PRAGMA busy_timeout = 5000');
|
||||
handle.exec('PRAGMA foreign_keys = ON');
|
||||
handle.exec('PRAGMA synchronous = NORMAL');
|
||||
|
||||
migrate(handle);
|
||||
db = handle;
|
||||
return db;
|
||||
}
|
||||
|
||||
export function migrate(handle: Db): void {
|
||||
handle.exec('CREATE TABLE IF NOT EXISTS schema_migrations (name TEXT PRIMARY KEY, applied_at TEXT NOT NULL)');
|
||||
const applied = new Set(
|
||||
(handle.prepare('SELECT name FROM schema_migrations').all() as Array<{ name: string }>)
|
||||
.map((r) => r.name)
|
||||
);
|
||||
|
||||
const files = fs.readdirSync(MIGRATIONS).filter((f) => f.endsWith('.sql')).sort();
|
||||
for (const name of files) {
|
||||
if (applied.has(name)) continue;
|
||||
const sql = fs.readFileSync(path.join(MIGRATIONS, name), 'utf8');
|
||||
handle.exec('BEGIN');
|
||||
try {
|
||||
handle.exec(sql);
|
||||
handle.prepare('INSERT INTO schema_migrations (name, applied_at) VALUES (?, ?)')
|
||||
.run(name, new Date().toISOString());
|
||||
handle.exec('COMMIT');
|
||||
log.info(`Migration angewendet: ${name}`);
|
||||
} catch (err) {
|
||||
handle.exec('ROLLBACK');
|
||||
throw new Error(`Migration ${name} fehlgeschlagen: ${(err as Error).message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
export function closeDb(): void {
|
||||
db?.close();
|
||||
db = null;
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import type { ChatMessage } from '#shared/events.ts';
|
||||
import { migrate } from './index.ts';
|
||||
import { repos } from './repos.ts';
|
||||
import { DatabaseSync } from 'node:sqlite';
|
||||
|
||||
function freshDb() {
|
||||
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'abdulive-test-'));
|
||||
const db = new DatabaseSync(path.join(dir, 't.db'));
|
||||
db.exec('PRAGMA foreign_keys = ON');
|
||||
migrate(db);
|
||||
return { db, repo: repos(db), dir };
|
||||
}
|
||||
|
||||
function msg(over: Partial<ChatMessage> = {}): ChatMessage {
|
||||
return {
|
||||
id: `m-${Math.random().toString(36).slice(2)}`,
|
||||
ts: '2026-09-09T20:00:00.000Z',
|
||||
userId: '42', login: 'maxi_2k', displayName: 'maxi_2k',
|
||||
text: 'moin', emotes: [], isFirst: false, isReturning: false,
|
||||
isCommand: false, isMod: false, isSub: false, isBroadcaster: false,
|
||||
bits: 0, color: null, ...over,
|
||||
};
|
||||
}
|
||||
|
||||
test('legt Nutzer an und zaehlt Nachrichten', () => {
|
||||
const { db, repo } = freshDb();
|
||||
repo.openStream('s1', '2026-09-09T19:00:00.000Z');
|
||||
repo.recordMessage(msg(), 's1');
|
||||
repo.recordMessage(msg({ text: 'zweite' }), 's1');
|
||||
|
||||
const user = db.prepare('SELECT * FROM users WHERE id = ?').get('42') as
|
||||
{ message_count: number; login: string; first_seen_at: string };
|
||||
assert.equal(user.message_count, 2);
|
||||
assert.equal(user.login, 'maxi_2k');
|
||||
const n = db.prepare('SELECT COUNT(*) AS n FROM chat_messages').get() as { n: number };
|
||||
assert.equal(n.n, 2);
|
||||
});
|
||||
|
||||
test('Namenswechsel erhaelt die Historie', () => {
|
||||
const { db, repo } = freshDb();
|
||||
repo.openStream('s1', '2026-09-09T19:00:00.000Z');
|
||||
repo.recordMessage(msg(), 's1');
|
||||
// Gleiche user-id, neuer Login - so sieht eine Twitch-Namensaenderung aus
|
||||
repo.recordMessage(msg({ login: 'maxi_neu', displayName: 'Maxi_Neu' }), 's1');
|
||||
|
||||
const rows = db.prepare('SELECT * FROM users').all() as Array<{ login: string; message_count: number }>;
|
||||
assert.equal(rows.length, 1, 'darf keinen zweiten Nutzer angelegt haben');
|
||||
assert.equal(rows[0]!.login, 'maxi_neu');
|
||||
assert.equal(rows[0]!.message_count, 2);
|
||||
});
|
||||
|
||||
test('zaehlt Streams, an denen jemand geschrieben hat', () => {
|
||||
const { repo } = freshDb();
|
||||
repo.openStream('s1', '2026-09-09T19:00:00.000Z');
|
||||
repo.openStream('s2', '2026-09-10T19:00:00.000Z');
|
||||
assert.equal(repo.recordMessage(msg(), 's1').streamsChatted, 1);
|
||||
assert.equal(repo.recordMessage(msg(), 's1').streamsChatted, 1);
|
||||
assert.equal(repo.recordMessage(msg(), 's2').streamsChatted, 2);
|
||||
});
|
||||
|
||||
test('doppelte Nachrichten-IDs werden nicht zweimal gespeichert', () => {
|
||||
const { db, repo } = freshDb();
|
||||
repo.openStream('s1', '2026-09-09T19:00:00.000Z');
|
||||
const m = msg({ id: 'immer-gleich' });
|
||||
repo.recordMessage(m, 's1');
|
||||
repo.recordMessage(m, 's1');
|
||||
const n = db.prepare('SELECT COUNT(*) AS n FROM chat_messages').get() as { n: number };
|
||||
assert.equal(n.n, 1);
|
||||
});
|
||||
|
||||
test('Zuschauerzahlen setzen den Hoechststand', () => {
|
||||
const { repo } = freshDb();
|
||||
repo.openStream('s1', '2026-09-09T19:00:00.000Z');
|
||||
repo.sample('s1', '2026-09-09T19:01:00.000Z', 8);
|
||||
repo.sample('s1', '2026-09-09T19:02:00.000Z', 17);
|
||||
repo.sample('s1', '2026-09-09T19:03:00.000Z', 11);
|
||||
assert.equal(repo.getStream('s1')?.peak_viewers, 17);
|
||||
});
|
||||
|
||||
test('offene Sitzung wird gefunden und geschlossen', () => {
|
||||
const { repo } = freshDb();
|
||||
repo.openStream('s1', '2026-09-09T19:00:00.000Z');
|
||||
assert.equal(repo.latestOpenStream()?.id, 's1');
|
||||
repo.closeStream('s1', '2026-09-09T22:00:00.000Z');
|
||||
assert.equal(repo.latestOpenStream(), undefined);
|
||||
});
|
||||
|
||||
test('erneutes openStream ueberschreibt eine laufende Sitzung nicht', () => {
|
||||
const { repo } = freshDb();
|
||||
repo.openStream('s1', '2026-09-09T19:00:00.000Z');
|
||||
repo.openStream('s1', '2026-09-09T21:00:00.000Z');
|
||||
assert.equal(repo.getStream('s1')?.started_at, '2026-09-09T19:00:00.000Z');
|
||||
});
|
||||
|
||||
test('Nachrichten ohne laufenden Stream gehen trotzdem nicht verloren', () => {
|
||||
const { db, repo } = freshDb();
|
||||
repo.recordMessage(msg(), null);
|
||||
const row = db.prepare('SELECT stream_id FROM chat_messages').get() as { stream_id: string | null };
|
||||
assert.equal(row.stream_id, null);
|
||||
});
|
||||
|
||||
test('unique_chatters zaehlt Personen, nicht Nachrichten', () => {
|
||||
const { repo } = freshDb();
|
||||
repo.openStream('s1', '2026-09-09T19:00:00.000Z');
|
||||
repo.recordMessage(msg({ userId: '1', login: 'a' }), 's1');
|
||||
repo.recordMessage(msg({ userId: '1', login: 'a' }), 's1');
|
||||
repo.recordMessage(msg({ userId: '2', login: 'b' }), 's1');
|
||||
assert.equal(repo.getStream('s1')?.unique_chatters, 2);
|
||||
});
|
||||
@@ -0,0 +1,125 @@
|
||||
// Alle SQL-Anweisungen des Projekts stehen hier. Kein anderer Ort schreibt
|
||||
// SQL - das haelt das Schema an einer Stelle nachvollziehbar.
|
||||
|
||||
import type { Db } from './index.ts';
|
||||
import type { ChatMessage, EventType, StreamEvent } from '#shared/events.ts';
|
||||
import { ulid } from '#shared/events.ts';
|
||||
|
||||
export type StreamRow = {
|
||||
id: string; started_at: string; ended_at: string | null;
|
||||
peak_viewers: number; unique_chatters: number;
|
||||
};
|
||||
|
||||
export function repos(db: Db) {
|
||||
const stmt = {
|
||||
insertEvent: db.prepare(
|
||||
'INSERT OR IGNORE INTO events (id, ts, type, stream_id, user_id, payload) VALUES (?,?,?,?,?,?)'
|
||||
),
|
||||
upsertUser: db.prepare(`
|
||||
INSERT INTO users (id, login, display_name, first_seen_at, last_seen_at, message_count)
|
||||
VALUES (?,?,?,?,?,0)
|
||||
ON CONFLICT(id) DO UPDATE SET
|
||||
login = excluded.login,
|
||||
display_name = excluded.display_name,
|
||||
last_seen_at = excluded.last_seen_at
|
||||
`),
|
||||
bumpUserMessage: db.prepare(
|
||||
'UPDATE users SET message_count = message_count + 1, last_seen_at = ? WHERE id = ?'
|
||||
),
|
||||
getUser: db.prepare('SELECT * FROM users WHERE id = ?'),
|
||||
insertChat: db.prepare(`
|
||||
INSERT OR IGNORE INTO chat_messages
|
||||
(id, stream_id, ts, user_id, text, emotes, is_first, is_command, bits)
|
||||
VALUES (?,?,?,?,?,?,?,?,?)
|
||||
`),
|
||||
openStream: db.prepare(
|
||||
'INSERT OR IGNORE INTO streams (id, started_at) VALUES (?,?)'
|
||||
),
|
||||
closeStream: db.prepare('UPDATE streams SET ended_at = ? WHERE id = ? AND ended_at IS NULL'),
|
||||
getStream: db.prepare('SELECT * FROM streams WHERE id = ?'),
|
||||
latestOpenStream: db.prepare(
|
||||
'SELECT * FROM streams WHERE ended_at IS NULL ORDER BY started_at DESC LIMIT 1'
|
||||
),
|
||||
sample: db.prepare(
|
||||
'INSERT OR REPLACE INTO viewer_samples (stream_id, ts, viewers) VALUES (?,?,?)'
|
||||
),
|
||||
bumpPeak: db.prepare('UPDATE streams SET peak_viewers = ? WHERE id = ? AND peak_viewers < ?'),
|
||||
touchUserStream: db.prepare(`
|
||||
INSERT INTO user_streams (user_id, stream_id, first_ts, last_ts, messages)
|
||||
VALUES (?,?,?,?,?)
|
||||
ON CONFLICT(user_id, stream_id) DO UPDATE SET
|
||||
last_ts = excluded.last_ts,
|
||||
messages = user_streams.messages + excluded.messages
|
||||
`),
|
||||
countUserStreams: db.prepare(
|
||||
'SELECT COUNT(*) AS n FROM user_streams WHERE user_id = ?'
|
||||
),
|
||||
recountChatters: db.prepare(`
|
||||
UPDATE streams SET unique_chatters =
|
||||
(SELECT COUNT(*) FROM user_streams WHERE stream_id = ? AND messages > 0)
|
||||
WHERE id = ?
|
||||
`),
|
||||
recentChat: db.prepare(
|
||||
'SELECT ts, text, user_id FROM chat_messages WHERE ts >= ? ORDER BY ts'
|
||||
),
|
||||
stats: db.prepare(`
|
||||
SELECT
|
||||
(SELECT COUNT(*) FROM chat_messages) AS messages,
|
||||
(SELECT COUNT(*) FROM users) AS users,
|
||||
(SELECT COUNT(*) FROM streams) AS streams,
|
||||
(SELECT COUNT(*) FROM events) AS events
|
||||
`),
|
||||
};
|
||||
|
||||
return {
|
||||
event(type: EventType, payload: unknown, streamId: string | null = null,
|
||||
userId: string | null = null, ts = new Date().toISOString()): StreamEvent {
|
||||
const ev: StreamEvent = { id: ulid(), ts, type, streamId, userId, payload };
|
||||
stmt.insertEvent.run(ev.id, ev.ts, ev.type, ev.streamId, ev.userId, JSON.stringify(payload));
|
||||
return ev;
|
||||
},
|
||||
|
||||
/** Schreibt Nutzer, Nachricht und Anwesenheit in einer Transaktion. */
|
||||
recordMessage(msg: ChatMessage, streamId: string | null): { streamsChatted: number } {
|
||||
db.exec('BEGIN');
|
||||
try {
|
||||
stmt.upsertUser.run(msg.userId, msg.login, msg.displayName, msg.ts, msg.ts);
|
||||
stmt.bumpUserMessage.run(msg.ts, msg.userId);
|
||||
stmt.insertChat.run(
|
||||
msg.id, streamId, msg.ts, msg.userId, msg.text,
|
||||
JSON.stringify(msg.emotes), msg.isFirst ? 1 : 0, msg.isCommand ? 1 : 0, msg.bits
|
||||
);
|
||||
if (streamId) {
|
||||
stmt.touchUserStream.run(msg.userId, streamId, msg.ts, msg.ts, 1);
|
||||
stmt.recountChatters.run(streamId, streamId);
|
||||
}
|
||||
db.exec('COMMIT');
|
||||
} catch (err) {
|
||||
db.exec('ROLLBACK');
|
||||
throw err;
|
||||
}
|
||||
const row = stmt.countUserStreams.get(msg.userId) as { n: number } | undefined;
|
||||
return { streamsChatted: row?.n ?? 0 };
|
||||
},
|
||||
|
||||
openStream(id: string, startedAt: string): void { stmt.openStream.run(id, startedAt); },
|
||||
closeStream(id: string, endedAt: string): void { stmt.closeStream.run(endedAt, id); },
|
||||
getStream(id: string) { return stmt.getStream.get(id) as StreamRow | undefined; },
|
||||
latestOpenStream() { return stmt.latestOpenStream.get() as StreamRow | undefined; },
|
||||
|
||||
sample(streamId: string, ts: string, viewers: number): void {
|
||||
stmt.sample.run(streamId, ts, viewers);
|
||||
stmt.bumpPeak.run(viewers, streamId, viewers);
|
||||
},
|
||||
|
||||
recentChat(sinceIso: string) {
|
||||
return stmt.recentChat.all(sinceIso) as Array<{ ts: string; text: string; user_id: string }>;
|
||||
},
|
||||
|
||||
stats() {
|
||||
return stmt.stats.get() as { messages: number; users: number; streams: number; events: number };
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export type Repos = ReturnType<typeof repos>;
|
||||
@@ -1,5 +0,0 @@
|
||||
{
|
||||
"extends": "../../tsconfig.base.json",
|
||||
"compilerOptions": { "outDir": "dist", "rootDir": "src" },
|
||||
"include": ["src"]
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
{
|
||||
"name": "@abdulive/shared",
|
||||
"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,66 @@
|
||||
// Einheitliches Ereignisformat. Alles, was aus IRC, EventSub, Helix oder OBS
|
||||
// hereinkommt, wird darauf normalisiert und in `events` geschrieben.
|
||||
// Siehe docs/03-data-model.md.
|
||||
|
||||
export type EventType =
|
||||
| 'stream.online' | 'stream.offline' | 'stream.segment_changed'
|
||||
| 'chat.message' | 'chat.first_message' | 'chat.spike'
|
||||
| 'user.arrived' | 'user.returning'
|
||||
| 'follow' | 'subscribe' | 'subgift' | 'cheer'
|
||||
| 'raid.in' | 'raid.out'
|
||||
| 'points.redeemed' | 'shop.redeemed'
|
||||
| 'poll.begin' | 'poll.end'
|
||||
| 'obs.scene_changed' | 'obs.replay_saved'
|
||||
| 'clip.requested' | 'clip.created' | 'clip.rendered';
|
||||
|
||||
export type StreamEvent = {
|
||||
id: string;
|
||||
ts: string; // ISO-8601, UTC
|
||||
type: EventType;
|
||||
streamId: string | null;
|
||||
userId: string | null;
|
||||
payload: unknown;
|
||||
};
|
||||
|
||||
export type ChatMessage = {
|
||||
id: string; // msg-id aus IRC
|
||||
ts: string;
|
||||
userId: string;
|
||||
login: string;
|
||||
displayName: string;
|
||||
text: string;
|
||||
emotes: Array<{ id: string; name: string; count: number }>;
|
||||
isFirst: boolean; // first-msg Tag
|
||||
isReturning: boolean; // returning-chatter Tag
|
||||
isCommand: boolean;
|
||||
isMod: boolean;
|
||||
isSub: boolean;
|
||||
isBroadcaster: boolean;
|
||||
bits: number;
|
||||
color: string | null;
|
||||
};
|
||||
|
||||
export type SpikeEvent = {
|
||||
score: number;
|
||||
rate: number;
|
||||
baseline: number;
|
||||
chatters: number;
|
||||
emoteHits: number;
|
||||
clipMentions: number;
|
||||
windowFrom: string;
|
||||
windowTo: string;
|
||||
overThreshold: boolean;
|
||||
};
|
||||
|
||||
/** ULID-artige, zeitlich sortierbare ID ohne Abhaengigkeit. */
|
||||
const B32 = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
|
||||
export function ulid(now = Date.now()): string {
|
||||
let time = '';
|
||||
let t = now;
|
||||
for (let i = 0; i < 10; i++) { time = B32[t % 32]! + time; t = Math.floor(t / 32); }
|
||||
const rnd = new Uint8Array(16);
|
||||
crypto.getRandomValues(rnd);
|
||||
let tail = '';
|
||||
for (const b of rnd) tail += B32[b % 32]!;
|
||||
return time + tail;
|
||||
}
|
||||
@@ -1,2 +0,0 @@
|
||||
// @abdulive/shared — siehe docs/01-architecture.md
|
||||
export {};
|
||||
@@ -1,5 +0,0 @@
|
||||
{
|
||||
"extends": "../../tsconfig.base.json",
|
||||
"compilerOptions": { "outDir": "dist", "rootDir": "src" },
|
||||
"include": ["src"]
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
{
|
||||
"name": "@abdulive/twitch",
|
||||
"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,118 @@
|
||||
// Helix-Client mit eigenem Token-Bucket. Twitch erlaubt 800 Punkte pro Minute
|
||||
// je Client-ID; wir drosseln selbst, statt uns auf 429 zu verlassen, und
|
||||
// werten `Ratelimit-Remaining` aus dem Antwortkopf aus.
|
||||
|
||||
import { logger } from '#core/logger.ts';
|
||||
import { retry, sleep } from '#core/retry.ts';
|
||||
import { accessToken } from './oauth.ts';
|
||||
import { readSecrets, type Role } from './secrets.ts';
|
||||
|
||||
const log = logger('helix');
|
||||
const BASE = 'https://api.twitch.tv/helix';
|
||||
|
||||
class Bucket {
|
||||
// Keine Parameter-Properties: Node fuehrt die .ts-Datei direkt aus und
|
||||
// entfernt nur Typen; `constructor(private x)` waere zur Laufzeit weg.
|
||||
private tokens: number;
|
||||
private last = Date.now();
|
||||
private capacity: number;
|
||||
private perMinute: number;
|
||||
|
||||
constructor(capacity = 700, perMinute = 700) {
|
||||
this.capacity = capacity;
|
||||
this.perMinute = perMinute;
|
||||
this.tokens = capacity;
|
||||
}
|
||||
|
||||
async take(cost = 1): Promise<void> {
|
||||
for (;;) {
|
||||
const now = Date.now();
|
||||
this.tokens = Math.min(this.capacity, this.tokens + ((now - this.last) / 60_000) * this.perMinute);
|
||||
this.last = now;
|
||||
if (this.tokens >= cost) { this.tokens -= cost; return; }
|
||||
await sleep(Math.ceil(((cost - this.tokens) / this.perMinute) * 60_000) + 50);
|
||||
}
|
||||
}
|
||||
|
||||
/** Uebernimmt den echten Stand aus dem Antwortkopf. */
|
||||
sync(remaining: number | null): void {
|
||||
if (remaining !== null && remaining < this.tokens) this.tokens = remaining;
|
||||
}
|
||||
}
|
||||
|
||||
const bucket = new Bucket();
|
||||
|
||||
export type HelixStream = {
|
||||
id: string; user_id: string; user_login: string; game_id: string; game_name: string;
|
||||
title: string; viewer_count: number; started_at: string; language: string; thumbnail_url: string;
|
||||
};
|
||||
|
||||
export type HelixUser = { id: string; login: string; display_name: string };
|
||||
|
||||
async function call<T>(role: Role, endpoint: string, init: RequestInit = {}): Promise<T> {
|
||||
const app = readSecrets().apps[role];
|
||||
if (!app?.clientId) throw new Error(`Fuer "${role}" ist keine Client-ID hinterlegt.`);
|
||||
|
||||
return await retry(async () => {
|
||||
await bucket.take();
|
||||
const token = await accessToken(role);
|
||||
const res = await fetch(`${BASE}${endpoint}`, {
|
||||
...init,
|
||||
headers: {
|
||||
'Client-Id': app.clientId,
|
||||
Authorization: `Bearer ${token}`,
|
||||
...(init.body ? { 'content-type': 'application/json' } : {}),
|
||||
...init.headers,
|
||||
},
|
||||
});
|
||||
|
||||
const remaining = res.headers.get('ratelimit-remaining');
|
||||
bucket.sync(remaining === null ? null : Number(remaining));
|
||||
|
||||
if (res.status === 429) {
|
||||
const reset = Number(res.headers.get('ratelimit-reset') || 0) * 1000 - Date.now();
|
||||
await sleep(Math.max(1000, Math.min(60_000, reset)));
|
||||
throw new Error('Rate Limit erreicht');
|
||||
}
|
||||
if (!res.ok) {
|
||||
const text = await res.text();
|
||||
throw new Error(`Helix ${endpoint}: HTTP ${res.status} ${text.slice(0, 200)}`);
|
||||
}
|
||||
if (res.status === 204) return undefined as T;
|
||||
return await res.json() as T;
|
||||
}, { attempts: 4, onRetry: (err, n, ms) => log.warn(`Wiederhole ${endpoint} (${n}) in ${ms} ms`, { err: String(err) }) });
|
||||
}
|
||||
|
||||
export const helix = {
|
||||
async userByLogin(login: string): Promise<HelixUser | null> {
|
||||
const r = await call<{ data: HelixUser[] }>('broadcaster', `/users?login=${encodeURIComponent(login)}`);
|
||||
return r.data[0] ?? null;
|
||||
},
|
||||
|
||||
async streamByUserId(userId: string): Promise<HelixStream | null> {
|
||||
const r = await call<{ data: HelixStream[] }>('broadcaster', `/streams?user_id=${userId}`);
|
||||
return r.data[0] ?? null;
|
||||
},
|
||||
|
||||
async chatters(broadcasterId: string, moderatorId: string): Promise<string[]> {
|
||||
const out: string[] = [];
|
||||
let cursor = '';
|
||||
do {
|
||||
const q = `/chat/chatters?broadcaster_id=${broadcasterId}&moderator_id=${moderatorId}&first=1000` +
|
||||
(cursor ? `&after=${cursor}` : '');
|
||||
const r = await call<{ data: Array<{ user_id: string }>; pagination?: { cursor?: string } }>(
|
||||
'broadcaster', q);
|
||||
for (const c of r.data) out.push(c.user_id);
|
||||
cursor = r.pagination?.cursor ?? '';
|
||||
} while (cursor);
|
||||
return out;
|
||||
},
|
||||
|
||||
async createClip(broadcasterId: string): Promise<{ id: string; edit_url: string }> {
|
||||
const r = await call<{ data: Array<{ id: string; edit_url: string }> }>(
|
||||
'broadcaster', `/clips?broadcaster_id=${broadcasterId}`, { method: 'POST' });
|
||||
const clip = r.data[0];
|
||||
if (!clip) throw new Error('Twitch hat keinen Clip zurueckgegeben');
|
||||
return clip;
|
||||
},
|
||||
};
|
||||
@@ -1,2 +0,0 @@
|
||||
// @abdulive/twitch — siehe docs/02-twitch-integration.md
|
||||
export {};
|
||||
@@ -0,0 +1,59 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import { parseLine, toChatMessage } from './irc.ts';
|
||||
|
||||
const LINE =
|
||||
'@badge-info=subscriber/8;badges=broadcaster/1,subscriber/6;color=#1E90FF;' +
|
||||
'display-name=Nic_OOo;emotes=25:0-4/1902:6-10;first-msg=0;id=abc-123;mod=0;' +
|
||||
'returning-chatter=0;subscriber=1;tmi-sent-ts=1757404800000;user-id=98765 ' +
|
||||
':nic_ooo!nic_ooo@nic_ooo.tmi.twitch.tv PRIVMSG #abdulive_ :Kappa Keepo mehr Rost als Farbe';
|
||||
|
||||
test('zerlegt eine PRIVMSG mit Tags', () => {
|
||||
const m = parseLine(LINE);
|
||||
assert.ok(m);
|
||||
assert.equal(m.command, 'PRIVMSG');
|
||||
assert.equal(m.params[0], '#abdulive_');
|
||||
assert.equal(m.params[1], 'Kappa Keepo mehr Rost als Farbe');
|
||||
assert.equal(m.tags['user-id'], '98765');
|
||||
assert.equal(m.tags['display-name'], 'Nic_OOo');
|
||||
});
|
||||
|
||||
test('entschluesselt escapte Tag-Werte', () => {
|
||||
const m = parseLine('@system-msg=Ein\\sTest\\szur\\sSache;id=x :tmi.twitch.tv USERNOTICE #k');
|
||||
assert.equal(m?.tags['system-msg'], 'Ein Test zur Sache');
|
||||
});
|
||||
|
||||
test('uebersetzt in eine ChatMessage', () => {
|
||||
const msg = toChatMessage(parseLine(LINE)!);
|
||||
assert.ok(msg);
|
||||
assert.equal(msg.userId, '98765');
|
||||
assert.equal(msg.login, 'nic_ooo');
|
||||
assert.equal(msg.displayName, 'Nic_OOo');
|
||||
assert.equal(msg.isBroadcaster, true);
|
||||
assert.equal(msg.isSub, true);
|
||||
assert.equal(msg.isFirst, false);
|
||||
assert.equal(msg.isCommand, false);
|
||||
assert.equal(msg.ts, new Date(1757404800000).toISOString());
|
||||
// Emote-Namen werden aus den Positionsangaben zurueckgelesen
|
||||
assert.deepEqual(msg.emotes.map((e) => e.name).sort(), ['Kappa', 'Keepo']);
|
||||
});
|
||||
|
||||
test('erkennt Befehle und Erstchatter', () => {
|
||||
const line =
|
||||
'@first-msg=1;id=y;tmi-sent-ts=1757404800000;user-id=42;display-name=Neu ' +
|
||||
':neu!neu@neu.tmi.twitch.tv PRIVMSG #abdulive_ :!clip';
|
||||
const msg = toChatMessage(parseLine(line)!)!;
|
||||
assert.equal(msg.isFirst, true);
|
||||
assert.equal(msg.isCommand, true);
|
||||
});
|
||||
|
||||
test('ignoriert Nachrichten ohne user-id', () => {
|
||||
const line = ':tmi.twitch.tv PRIVMSG #abdulive_ :ohne Tags';
|
||||
assert.equal(toChatMessage(parseLine(line)!), null);
|
||||
});
|
||||
|
||||
test('PING wird als solches erkannt', () => {
|
||||
const m = parseLine('PING :tmi.twitch.tv');
|
||||
assert.equal(m?.command, 'PING');
|
||||
assert.equal(m?.params[0], 'tmi.twitch.tv');
|
||||
});
|
||||
@@ -0,0 +1,202 @@
|
||||
// Twitch-Chat ueber IRC (WebSocket). Warum IRC und nicht EventSub: die
|
||||
// IRCv3-Tags enthalten first-msg, returning-chatter, msg-id, badges und
|
||||
// Emote-Positionen - genau das, woran Community-Gedaechtnis und
|
||||
// Spike-Erkennung haengen. Siehe ADR-0003.
|
||||
//
|
||||
// Ohne Zugangsdaten wird anonym verbunden (justinfan). Dann kann man mitlesen,
|
||||
// aber nicht schreiben - reicht, um die Datenaufnahme zu pruefen, bevor die
|
||||
// Twitch-Apps eingerichtet sind.
|
||||
|
||||
import { logger } from '#core/logger.ts';
|
||||
import { forever } from '#core/retry.ts';
|
||||
import type { ChatMessage } from '#shared/events.ts';
|
||||
import { accessToken } from './oauth.ts';
|
||||
import { readSecrets } from './secrets.ts';
|
||||
|
||||
const log = logger('irc');
|
||||
const URL_WS = 'wss://irc-ws.chat.twitch.tv:443';
|
||||
|
||||
export type IrcMessage = { tags: Record<string, string>; prefix: string; command: string; params: string[] };
|
||||
|
||||
/** IRCv3-Zeile zerlegen: `@tags :prefix COMMAND params :trailing` */
|
||||
export function parseLine(line: string): IrcMessage | null {
|
||||
if (!line) return null;
|
||||
let rest = line;
|
||||
const tags: Record<string, string> = {};
|
||||
|
||||
if (rest.startsWith('@')) {
|
||||
const sp = rest.indexOf(' ');
|
||||
for (const pair of rest.slice(1, sp).split(';')) {
|
||||
const eq = pair.indexOf('=');
|
||||
const k = eq === -1 ? pair : pair.slice(0, eq);
|
||||
const v = eq === -1 ? '' : pair.slice(eq + 1);
|
||||
tags[k] = v
|
||||
.replace(/\\s/g, ' ').replace(/\\n/g, '\n').replace(/\\r/g, '\r')
|
||||
.replace(/\\:/g, ';').replace(/\\\\/g, '\\');
|
||||
}
|
||||
rest = rest.slice(sp + 1);
|
||||
}
|
||||
|
||||
let prefix = '';
|
||||
if (rest.startsWith(':')) {
|
||||
const sp = rest.indexOf(' ');
|
||||
prefix = rest.slice(1, sp);
|
||||
rest = rest.slice(sp + 1);
|
||||
}
|
||||
|
||||
const trailingAt = rest.indexOf(' :');
|
||||
const head = trailingAt === -1 ? rest : rest.slice(0, trailingAt);
|
||||
const parts = head.split(' ').filter(Boolean);
|
||||
const command = parts.shift() ?? '';
|
||||
if (trailingAt !== -1) parts.push(rest.slice(trailingAt + 2));
|
||||
return { tags, prefix, command, params: parts };
|
||||
}
|
||||
|
||||
function parseEmotes(tag: string | undefined, text: string): ChatMessage['emotes'] {
|
||||
if (!tag) return [];
|
||||
const out: ChatMessage['emotes'] = [];
|
||||
const chars = [...text];
|
||||
for (const part of tag.split('/')) {
|
||||
const [id, ranges] = part.split(':');
|
||||
if (!id || !ranges) continue;
|
||||
const spans = ranges.split(',');
|
||||
const first = spans[0]?.split('-');
|
||||
const name = first && first[0] !== undefined && first[1] !== undefined
|
||||
? chars.slice(Number(first[0]), Number(first[1]) + 1).join('')
|
||||
: id;
|
||||
out.push({ id, name, count: spans.length });
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export function toChatMessage(m: IrcMessage): ChatMessage | null {
|
||||
if (m.command !== 'PRIVMSG') return null;
|
||||
const text = m.params[1] ?? '';
|
||||
const login = m.prefix.split('!')[0] ?? '';
|
||||
const userId = m.tags['user-id'];
|
||||
if (!userId) return null;
|
||||
const badges = m.tags['badges'] ?? '';
|
||||
return {
|
||||
id: m.tags['id'] ?? `${userId}-${Date.now()}`,
|
||||
ts: new Date(Number(m.tags['tmi-sent-ts'] ?? Date.now())).toISOString(),
|
||||
userId,
|
||||
login,
|
||||
displayName: m.tags['display-name'] || login,
|
||||
text,
|
||||
emotes: parseEmotes(m.tags['emotes'], text),
|
||||
isFirst: m.tags['first-msg'] === '1',
|
||||
isReturning: m.tags['returning-chatter'] === '1',
|
||||
isCommand: text.startsWith('!'),
|
||||
isMod: m.tags['mod'] === '1' || badges.includes('broadcaster'),
|
||||
isSub: m.tags['subscriber'] === '1',
|
||||
isBroadcaster: badges.includes('broadcaster'),
|
||||
bits: Number(m.tags['bits'] ?? 0),
|
||||
color: m.tags['color'] || null,
|
||||
};
|
||||
}
|
||||
|
||||
export type IrcHandlers = {
|
||||
onMessage: (msg: ChatMessage) => void;
|
||||
onNotice?: (text: string) => void;
|
||||
onConnected?: (anonymous: boolean) => void;
|
||||
};
|
||||
|
||||
export type IrcClient = {
|
||||
/** Haelt die Verbindung dauerhaft; kehrt erst bei `signal.abort` zurueck. */
|
||||
run: (signal: AbortSignal) => Promise<void>;
|
||||
/** Sendet in den Chat. Anonym verbundene Clients koennen nicht senden. */
|
||||
say: (text: string) => boolean;
|
||||
isAnonymous: () => boolean;
|
||||
};
|
||||
|
||||
export function createIrc(channel: string, handlers: IrcHandlers): IrcClient {
|
||||
let send: ((text: string) => boolean) | null = null;
|
||||
let anonymous = true;
|
||||
|
||||
return {
|
||||
run: (signal) => forever(
|
||||
async (sig) => {
|
||||
const conn = await connectOnce(channel, handlers, sig, (fn, anon) => {
|
||||
send = fn; anonymous = anon;
|
||||
});
|
||||
void conn;
|
||||
},
|
||||
{
|
||||
signal,
|
||||
onWait: (ms, n) =>
|
||||
log.warn(`Chat getrennt, neuer Versuch in ${Math.round(ms / 1000)} s (${n}.)`),
|
||||
}
|
||||
),
|
||||
say: (text) => (send ? send(text) : false),
|
||||
isAnonymous: () => anonymous,
|
||||
};
|
||||
}
|
||||
|
||||
function connectOnce(
|
||||
channel: string,
|
||||
handlers: IrcHandlers,
|
||||
signal: AbortSignal,
|
||||
ready: (say: (text: string) => boolean, anonymous: boolean) => void
|
||||
): Promise<void> {
|
||||
return new Promise<void>((_resolve, reject) => {
|
||||
const ws = new WebSocket(URL_WS);
|
||||
let anonymous = true;
|
||||
let joined = false;
|
||||
let alive: ReturnType<typeof setInterval> | null = null;
|
||||
|
||||
const shutdown = (why: string) => {
|
||||
if (alive) clearInterval(alive);
|
||||
try { ws.close(); } catch { /* schon zu */ }
|
||||
reject(new Error(why));
|
||||
};
|
||||
signal.addEventListener('abort', () => shutdown('abgebrochen'), { once: true });
|
||||
|
||||
ws.addEventListener('open', () => {
|
||||
void (async () => {
|
||||
ws.send('CAP REQ :twitch.tv/tags twitch.tv/commands');
|
||||
const bot = readSecrets().tokens.bot;
|
||||
if (bot) {
|
||||
try {
|
||||
ws.send(`PASS oauth:${await accessToken('bot')}`);
|
||||
ws.send(`NICK ${bot.login}`);
|
||||
anonymous = false;
|
||||
} catch (err) {
|
||||
log.warn(`Bot-Token nicht nutzbar, lese anonym mit: ${(err as Error).message}`);
|
||||
}
|
||||
}
|
||||
if (anonymous) ws.send(`NICK justinfan${10_000 + Math.floor(Math.random() * 80_000)}`);
|
||||
ws.send(`JOIN #${channel.toLowerCase()}`);
|
||||
})();
|
||||
});
|
||||
|
||||
ws.addEventListener('message', (ev) => {
|
||||
for (const line of String(ev.data).split('\r\n')) {
|
||||
const m = parseLine(line);
|
||||
if (!m) continue;
|
||||
|
||||
if (m.command === 'PING') { ws.send(`PONG :${m.params[0] ?? 'tmi.twitch.tv'}`); continue; }
|
||||
if (m.command === 'JOIN' && !joined) {
|
||||
joined = true;
|
||||
log.info(`Chat verbunden mit #${channel}${anonymous ? ' (anonym, nur lesend)' : ''}`);
|
||||
ready((text) => {
|
||||
if (anonymous || ws.readyState !== WebSocket.OPEN) return false;
|
||||
ws.send(`PRIVMSG #${channel.toLowerCase()} :${text}`);
|
||||
return true;
|
||||
}, anonymous);
|
||||
handlers.onConnected?.(anonymous);
|
||||
// Twitch schliesst stille Verbindungen; alle 4 Minuten ein Lebenszeichen
|
||||
alive = setInterval(() => { try { ws.send('PING :keepalive'); } catch { /* egal */ } }, 240_000);
|
||||
continue;
|
||||
}
|
||||
if (m.command === 'NOTICE') { handlers.onNotice?.(m.params[1] ?? ''); continue; }
|
||||
if (m.command === 'PRIVMSG') {
|
||||
const msg = toChatMessage(m);
|
||||
if (msg) handlers.onMessage(msg);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
ws.addEventListener('error', () => shutdown('WebSocket-Fehler'));
|
||||
ws.addEventListener('close', (ev) => shutdown(`Verbindung geschlossen (${ev.code})`));
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
// OAuth-Autorisierungscode-Flow gegen Twitch. Rueckruf laeuft auf denselben
|
||||
// Server wie die Einrichtungsseite (Port 4792) - siehe ADR-0005.
|
||||
|
||||
import crypto from 'node:crypto';
|
||||
import { logger } from '#core/logger.ts';
|
||||
import { readSecrets, updateSecrets, type Role, type TokenSet } from './secrets.ts';
|
||||
|
||||
const log = logger('oauth');
|
||||
const AUTH = 'https://id.twitch.tv/oauth2/authorize';
|
||||
const TOKEN = 'https://id.twitch.tv/oauth2/token';
|
||||
const VALIDATE = 'https://id.twitch.tv/oauth2/validate';
|
||||
|
||||
export const SCOPES: Record<Role, string[]> = {
|
||||
broadcaster: [
|
||||
'clips:edit',
|
||||
'channel:manage:broadcast',
|
||||
'channel:read:subscriptions',
|
||||
'moderator:read:followers',
|
||||
'moderator:read:chatters',
|
||||
'channel:manage:raids',
|
||||
'channel:read:redemptions',
|
||||
'bits:read',
|
||||
],
|
||||
bot: ['chat:read', 'chat:edit'],
|
||||
};
|
||||
|
||||
/** Kurzlebige, einmalig einloesbare `state`-Werte gegen CSRF. */
|
||||
const pending = new Map<string, { role: Role; created: number }>();
|
||||
|
||||
export function redirectUri(port: number): string {
|
||||
// Muss exakt so in der Twitch-App hinterlegt sein.
|
||||
return `http://localhost:${port}/callback`;
|
||||
}
|
||||
|
||||
export function authorizeUrl(role: Role, port: number): string {
|
||||
const app = readSecrets().apps[role];
|
||||
if (!app?.clientId) throw new Error(`Fuer "${role}" ist noch keine Client-ID hinterlegt.`);
|
||||
const state = crypto.randomBytes(16).toString('hex');
|
||||
pending.set(state, { role, created: Date.now() });
|
||||
for (const [k, v] of pending) if (Date.now() - v.created > 600_000) pending.delete(k);
|
||||
|
||||
const u = new URL(AUTH);
|
||||
u.searchParams.set('client_id', app.clientId);
|
||||
u.searchParams.set('redirect_uri', redirectUri(port));
|
||||
u.searchParams.set('response_type', 'code');
|
||||
u.searchParams.set('scope', SCOPES[role].join(' '));
|
||||
u.searchParams.set('state', state);
|
||||
u.searchParams.set('force_verify', 'true');
|
||||
return u.toString();
|
||||
}
|
||||
|
||||
export async function handleCallback(code: string, state: string, port: number): Promise<Role> {
|
||||
const entry = pending.get(state);
|
||||
if (!entry) throw new Error('Unbekannter oder abgelaufener state - bitte erneut verbinden.');
|
||||
pending.delete(state);
|
||||
const { role } = entry;
|
||||
|
||||
const app = readSecrets().apps[role];
|
||||
if (!app) throw new Error(`Fuer "${role}" fehlen die App-Daten.`);
|
||||
|
||||
const res = await fetch(TOKEN, {
|
||||
method: 'POST',
|
||||
headers: { 'content-type': 'application/x-www-form-urlencoded' },
|
||||
body: new URLSearchParams({
|
||||
client_id: app.clientId,
|
||||
client_secret: app.clientSecret,
|
||||
code,
|
||||
grant_type: 'authorization_code',
|
||||
redirect_uri: redirectUri(port),
|
||||
}),
|
||||
});
|
||||
if (!res.ok) throw new Error(`Token-Tausch fehlgeschlagen: HTTP ${res.status} ${await res.text()}`);
|
||||
const body = await res.json() as { access_token: string; refresh_token: string; expires_in: number };
|
||||
|
||||
const who = await validate(body.access_token);
|
||||
const tokens: TokenSet = {
|
||||
accessToken: body.access_token,
|
||||
refreshToken: body.refresh_token,
|
||||
expiresAt: new Date(Date.now() + body.expires_in * 1000).toISOString(),
|
||||
scopes: who.scopes,
|
||||
userId: who.user_id,
|
||||
login: who.login,
|
||||
};
|
||||
updateSecrets((s) => { s.tokens[role] = tokens; });
|
||||
log.info(`${role} verbunden als ${who.login} (${who.scopes.length} Scopes)`);
|
||||
return role;
|
||||
}
|
||||
|
||||
export async function validate(accessToken: string) {
|
||||
const res = await fetch(VALIDATE, { headers: { Authorization: `OAuth ${accessToken}` } });
|
||||
if (!res.ok) throw new Error(`Token ungueltig: HTTP ${res.status}`);
|
||||
return await res.json() as { user_id: string; login: string; scopes: string[]; expires_in: number };
|
||||
}
|
||||
|
||||
/** Liefert ein gueltiges Access-Token, erneuert bei Bedarf. */
|
||||
export async function accessToken(role: Role): Promise<string> {
|
||||
const s = readSecrets();
|
||||
const t = s.tokens[role];
|
||||
if (!t) throw new Error(`"${role}" ist nicht verbunden - Einrichtung unter /setup.`);
|
||||
|
||||
// Fuenf Minuten Puffer, damit kein Aufruf mitten im Ablauf landet
|
||||
if (Date.parse(t.expiresAt) - Date.now() > 300_000) return t.accessToken;
|
||||
|
||||
const app = s.apps[role];
|
||||
if (!app) throw new Error(`Fuer "${role}" fehlen die App-Daten.`);
|
||||
const res = await fetch(TOKEN, {
|
||||
method: 'POST',
|
||||
headers: { 'content-type': 'application/x-www-form-urlencoded' },
|
||||
body: new URLSearchParams({
|
||||
client_id: app.clientId,
|
||||
client_secret: app.clientSecret,
|
||||
grant_type: 'refresh_token',
|
||||
refresh_token: t.refreshToken,
|
||||
}),
|
||||
});
|
||||
if (!res.ok) {
|
||||
throw new Error(`Token-Erneuerung fuer "${role}" fehlgeschlagen (HTTP ${res.status}). ` +
|
||||
'Neu verbinden unter /setup.');
|
||||
}
|
||||
const body = await res.json() as { access_token: string; refresh_token: string; expires_in: number };
|
||||
const next: TokenSet = {
|
||||
...t,
|
||||
accessToken: body.access_token,
|
||||
refreshToken: body.refresh_token || t.refreshToken,
|
||||
expiresAt: new Date(Date.now() + body.expires_in * 1000).toISOString(),
|
||||
};
|
||||
updateSecrets((st) => { st.tokens[role] = next; });
|
||||
log.info(`Token fuer ${role} erneuert`);
|
||||
return next.accessToken;
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
// Verschluesselter Speicher fuer Zugangsdaten. Siehe ADR-0005.
|
||||
//
|
||||
// Bewusst NICHT in der SQLite-Datenbank: die wird per VACUUM INTO auf die
|
||||
// Windows-Seite gesichert, wo sie in einer Cloud-Synchronisation landen kann.
|
||||
//
|
||||
// Der Schluessel liegt im selben Volume wie die Daten. Das schuetzt nicht
|
||||
// gegen jemanden mit Zugriff auf das Volume, und tut auch nicht so. Es
|
||||
// schuetzt gegen versehentliche Anzeige im Stream, gegen verirrte Kopien und
|
||||
// gegen Grep-Unfaelle - und genau darum geht es hier.
|
||||
|
||||
import crypto from 'node:crypto';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { paths } from '#core/config.ts';
|
||||
import { logger } from '#core/logger.ts';
|
||||
|
||||
const log = logger('secrets');
|
||||
const FILE = path.join(paths.db, 'secrets.json');
|
||||
const KEYFILE = path.join(paths.db, '.secret-key');
|
||||
|
||||
export type Role = 'broadcaster' | 'bot';
|
||||
|
||||
export type TokenSet = {
|
||||
accessToken: string;
|
||||
refreshToken: string;
|
||||
expiresAt: string; // ISO
|
||||
scopes: string[];
|
||||
userId: string;
|
||||
login: string;
|
||||
};
|
||||
|
||||
export type SecretStore = {
|
||||
apps: Partial<Record<Role, { clientId: string; clientSecret: string }>>;
|
||||
tokens: Partial<Record<Role, TokenSet>>;
|
||||
obs?: { password: string };
|
||||
discord?: { goLiveWebhook?: string; recapWebhook?: string };
|
||||
bluesky?: { handle: string; appPassword: string };
|
||||
};
|
||||
|
||||
const EMPTY: SecretStore = { apps: {}, tokens: {} };
|
||||
|
||||
function key(): Buffer {
|
||||
fs.mkdirSync(paths.db, { recursive: true });
|
||||
if (fs.existsSync(KEYFILE)) return Buffer.from(fs.readFileSync(KEYFILE, 'utf8').trim(), 'base64');
|
||||
const k = crypto.randomBytes(32);
|
||||
fs.writeFileSync(KEYFILE, k.toString('base64'), { mode: 0o600 });
|
||||
log.info('Neuer Verschluesselungsschluessel erzeugt');
|
||||
return k;
|
||||
}
|
||||
|
||||
function encrypt(plain: string): string {
|
||||
const iv = crypto.randomBytes(12);
|
||||
const cipher = crypto.createCipheriv('aes-256-gcm', key(), iv);
|
||||
const body = Buffer.concat([cipher.update(plain, 'utf8'), cipher.final()]);
|
||||
return [iv.toString('base64'), cipher.getAuthTag().toString('base64'), body.toString('base64')]
|
||||
.join('.');
|
||||
}
|
||||
|
||||
function decrypt(blob: string): string {
|
||||
const [ivB64, tagB64, bodyB64] = blob.split('.');
|
||||
if (!ivB64 || !tagB64 || !bodyB64) throw new Error('secrets.json ist beschaedigt');
|
||||
const decipher = crypto.createDecipheriv('aes-256-gcm', key(), Buffer.from(ivB64, 'base64'));
|
||||
decipher.setAuthTag(Buffer.from(tagB64, 'base64'));
|
||||
return Buffer.concat([decipher.update(Buffer.from(bodyB64, 'base64')), decipher.final()])
|
||||
.toString('utf8');
|
||||
}
|
||||
|
||||
let cache: SecretStore | null = null;
|
||||
|
||||
export function readSecrets(): SecretStore {
|
||||
if (cache) return cache;
|
||||
if (!fs.existsSync(FILE)) { cache = structuredClone(EMPTY); return cache; }
|
||||
try {
|
||||
cache = JSON.parse(decrypt(fs.readFileSync(FILE, 'utf8'))) as SecretStore;
|
||||
} catch (err) {
|
||||
log.error(`secrets.json nicht lesbar (${(err as Error).message}) - starte mit leerem Speicher`);
|
||||
cache = structuredClone(EMPTY);
|
||||
}
|
||||
return cache;
|
||||
}
|
||||
|
||||
export function writeSecrets(next: SecretStore): void {
|
||||
fs.mkdirSync(paths.db, { recursive: true });
|
||||
fs.writeFileSync(FILE, encrypt(JSON.stringify(next)), { mode: 0o600 });
|
||||
cache = next;
|
||||
}
|
||||
|
||||
export function updateSecrets(fn: (s: SecretStore) => void): SecretStore {
|
||||
const s = structuredClone(readSecrets());
|
||||
fn(s);
|
||||
writeSecrets(s);
|
||||
return s;
|
||||
}
|
||||
|
||||
/** Zustand fuer die Einrichtungsseite - enthaelt nie einen Geheimwert. */
|
||||
export type SecretStatus = {
|
||||
apps: Record<Role, { clientId: string; hasSecret: boolean }>;
|
||||
tokens: Record<Role, { connected: boolean; login?: string; expiresAt?: string; scopes?: number }>;
|
||||
obs: boolean;
|
||||
ready: boolean;
|
||||
};
|
||||
|
||||
export function secretStatus(): SecretStatus {
|
||||
const s = readSecrets();
|
||||
const roles: Role[] = ['broadcaster', 'bot'];
|
||||
const apps = {} as SecretStatus['apps'];
|
||||
const tokens = {} as SecretStatus['tokens'];
|
||||
for (const r of roles) {
|
||||
// Die Client-ID ist kein Geheimnis und wird angezeigt, damit man sieht,
|
||||
// welche App hinterlegt ist. Das Secret nie.
|
||||
apps[r] = { clientId: s.apps[r]?.clientId ?? '', hasSecret: Boolean(s.apps[r]?.clientSecret) };
|
||||
const t = s.tokens[r];
|
||||
tokens[r] = t
|
||||
? { connected: true, login: t.login, expiresAt: t.expiresAt, scopes: t.scopes.length }
|
||||
: { connected: false };
|
||||
}
|
||||
return {
|
||||
apps, tokens,
|
||||
obs: Boolean(s.obs?.password),
|
||||
ready: Boolean(s.apps.broadcaster?.clientId && s.tokens.broadcaster),
|
||||
};
|
||||
}
|
||||
@@ -1,5 +0,0 @@
|
||||
{
|
||||
"extends": "../../tsconfig.base.json",
|
||||
"compilerOptions": { "outDir": "dist", "rootDir": "src" },
|
||||
"include": ["src"]
|
||||
}
|
||||
Reference in new issue
Block a user