dogfather-universe/server/workspace-buehne.js

/* =====================================================================
   DIE BUEHNENQUELLEN — fuer OBS und TikTok Studio (28.09.2026)

   Filipe: „ich will das alles auch so perfekt dass ich es ganz
   einfach und easy mit obs oder mit tiktok studio verbinden kann.
   also so dass man dan nur die kamera und das video sieht."

   ---------------------------------------------------------------------
   WARUM OHNE ANMELDUNG — nachgesehen, nicht angenommen

   OBS speichert die Anmeldung einer Browser-Quelle NICHT zuverlaessig;
   im OBS-Forum stehen dazu Meldungen bis in die aktuelle Fassung. Eine
   Quelle, bei der man sich nach jedem Programmstart neu anmelden muss,
   ist mitten in einer Sendung genau das, was man nicht gebrauchen kann.

   Deshalb ein SCHLUESSEL in der Adresse — derselbe Weg, den jedes
   Alert-Werkzeug im Netz geht. Wer ihn hat, sieht genau das, was
   ohnehin im Stream steht: das laufende Video und die Spendenkarten.
   Keine Namen von Zusehenden, kein Chat, keine Bedienung.

   ---------------------------------------------------------------------
   DREI QUELLEN, WEIL DREI DINGE VERSCHIEDEN SIND

     buehne.html   Das laufende YouTube-Video, auf die Sekunde genau
                   wie bei allen anderen. Als Browser-Quelle in OBS.
                   Die EIGENE Kamera gehoert NICHT hier hinein: Sie
                   ist in OBS direkt als Geraet verfuegbar, in
                   besserer Qualitaet und frei in Groesse und Lage.
                   Den Umweg ueber den Browser zu nehmen hiesse,
                   Qualitaet gegen nichts einzutauschen.

     tafel.html    Nur die Spendenkarten, auf durchsichtigem Grund.
                   Als zweite Browser-Quelle darueber gelegt.

     Buehnenmodus  Die Reaction-Seite selbst, nur ohne alles
                   Bedienbare (`?nur=buehne`). Fuer den Fall, dass
                   GAESTE im Bild sind: Deren Kameras kommen ueber
                   eine Direktverbindung an, und die braucht eine
                   angemeldete Seite. Diese eine wird als Fenster
                   aufgenommen.

   ---------------------------------------------------------------------
   DER SCHLUESSEL

   32 Byte aus dem Zufall des Betriebssystems. Er steht in den
   Einstellungen unter einem Namen mit „schluessel" darin — damit
   greift die vorhandene Regel, die Geheimnisse nicht im Klartext ins
   Protokoll schreibt.

   Er laesst sich jederzeit neu erzeugen. Dann sind die alten Adressen
   tot, und die Quellen in OBS muessen einmal neu eingetragen werden;
   das ist der Preis dafuer, dass man einen verratenen Schluessel
   wirklich loswird.
   ===================================================================== */
import express from "express";
import { randomBytes, timingSafeEqual } from "node:crypto";
import { join } from "node:path";
import { existsSync, createReadStream } from "node:fs";
import {
  db, sitzungLesen, einstellung, einstellungSetzen, protokolliere, echteIp, DATEN_ORDNER,
} from "./workspace.js";

export const buehneRouter = express.Router();

const SCHLUESSEL_NAME = "buehne_schluessel";

/** Wer die Adressen sehen und den Schluessel wechseln darf. */
const LEITUNG = new Set(["admin", "hand"]);

/** Den Schluessel holen — und beim ersten Mal erzeugen.
 *
 *  ERZEUGT WIRD ER ERST BEI BEDARF. Ein Schluessel, den niemand
 *  angefordert hat, ist ein Geheimnis ohne Zweck: Er liegt herum,
 *  wird irgendwann kopiert, und niemand weiss mehr, wofuer er war. */
export function buehneSchluessel() {
  let s = einstellung(SCHLUESSEL_NAME, "");
  if (!s) {
    s = randomBytes(32).toString("hex");
    einstellungSetzen(SCHLUESSEL_NAME, s, null);
  }
  return s;
}

/** Stimmt der mitgeschickte Schluessel?
 *
 *  ZEITGLEICHER VERGLEICH. Ein gewoehnlicher Vergleich bricht beim
 *  ersten falschen Zeichen ab; aus den Bruchteilen einer Millisekunde
 *  laesst sich ein Schluessel Zeichen fuer Zeichen erraten. Das ist
 *  nicht theoretisch -- es ist der Grund, warum es diese Funktion in
 *  Node ueberhaupt gibt. */
function schluesselStimmt(gegeben) {
  const soll = buehneSchluessel();
  const a = Buffer.from(String(gegeben || ""), "utf8");
  const b = Buffer.from(soll, "utf8");
  if (a.length !== b.length) return false;
  try { return timingSafeEqual(a, b); } catch { return false; }
}

function mitSchluessel(req, res, next) {
  const s = req.query?.s || req.get("X-Buehne") || "";
  if (!schluesselStimmt(s)) return res.status(404).end();
  next();
}

/* ---------- Die Zuhoerer ------------------------------------------------
   Eine eigene Liste, nicht die des Hauschats: Dort haengt jeder
   Zuhoerer an einer Person, und genau die gibt es hier nicht. */
const zuhoerer = new Set();

/** Hoechstens so viele Quellen gleichzeitig.
 *
 *  Nicht gegen Angriffe -- der Schluessel steht davor -- sondern
 *  gegen den Fall, dass OBS bei einer Stoerung immer neu verbindet
 *  und die alten Verbindungen nicht abbaut. Ohne Grenze sammeln sich
 *  hunderte, und der Server haelt sie alle offen. */
const MAX_QUELLEN = 20;

export function buehneMelden(art, daten) {
  const text = `event: ${art}\ndata: ${JSON.stringify(daten)}\n\n`;
  for (const antwort of [...zuhoerer]) {
    try { antwort.write(text); } catch { zuhoerer.delete(antwort); }
  }
}

/** Wie viele Quellen gerade hoeren — fuer die Anzeige im Pult. */
export function buehneQuellen() {
  return zuhoerer.size;
}

/* ======================================================================
   DIE WEGE
   ====================================================================== */

/* ==== DAS BILD EINER SPENDENSTUFE ==================================

   Es haengt HIER und nicht am Spenden-Router, und dafuer gibt es
   genau einen Grund: Die Spendentafel in OBS hat KEINE Anmeldung.
   Am Spenden-Router steht eine Schranke ueber allem, und ein 401 als
   JSON in einem `<img>` ergibt ein kaputtes Bild ohne jeden Hinweis.
   Dieselbe Ueberlegung wie beim Profilbild, das deshalb auch vor dem
   Aufgaben-Router haengt.

   OHNE SCHLUESSEL -- UND WARUM DAS VERTRETBAR IST. Der Dateiname
   sind 32 zufaellige Zeichen aus `randomBytes(16)`, also 128 Bit. Das
   ist dieselbe Groessenordnung wie der Buehnenschluessel selbst. Und
   der Gegenstand ist ein Zierbild, das Filipe fuer seinen Stream
   hochlaedt -- es steht ohnehin oeffentlich im Bild. Eine Schranke
   davor waere eine, die nur den eigenen Saal aussperrt: Der kennt
   den Buehnenschluessel naemlich nicht, den bekommt nur die Leitung.

   DER NAME MUSS GENAU DEM MUSTER ENTSPRECHEN. Damit laesst sich kein
   Pfad verlassen, auch nicht ueber kodierte Zeichen. */
buehneRouter.get("/workspace/api/buehne/spendenbild/:datei", (req, res) => {
  try {
    const name = String(req.params.datei);
    if (!/^[a-f0-9]{32}\.(jpg|png|webp)$/.test(name)) return res.status(404).end();
    const pfad = join(DATEN_ORDNER, "spendenbilder", name);
    if (!existsSync(pfad)) return res.status(404).end();
    res.setHeader("Content-Type", name.endsWith(".jpg") ? "image/jpeg"
      : name.endsWith(".png") ? "image/png" : "image/webp");
    res.setHeader("X-Content-Type-Options", "nosniff");
    /* Alles verbietende Inhaltsregel: Selbst wenn eine Datei jemals
       durchkaeme, die der Browser als etwas anderes liest, darf sie
       nichts nachladen und nichts ausfuehren. */
    res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
    /* Der Name ist zufaellig und aendert sich bei jedem neuen Bild --
       er darf lange zwischengespeichert werden. Das ist hier mehr als
       Sparsamkeit: Eine OBS-Quelle laeuft stundenlang, und ein Bild,
       das bei jeder Karte neu geladen wird, erscheint beim ersten Mal
       mit einer Verzoegerung mitten in der Einblendung. */
    res.setHeader("Cache-Control", "public, max-age=604800, immutable");
    createReadStream(pfad).pipe(res);
  } catch (fehler) {
    console.error("[buehne] Spendenbild:", fehler?.message);
    res.status(404).end();
  }
});

/** Was gerade laeuft. Ein einziger Aufruf beim Start der Quelle. */
buehneRouter.get("/workspace/api/buehne/lage", mitSchluessel, (req, res) => {
  try {
    const s = db().prepare("SELECT * FROM reaktion WHERE id = 1").get();
    res.set("Cache-Control", "no-store");
    res.json({
      /* NUR, WAS OHNEHIN IM STREAM STEHT. Kein Chat, keine Namen von
         Zusehenden, keine Zahlen ueber das Haus. Wer den Schluessel
         hat, sieht nichts, was nicht gerade gesendet wird. */
      stand: s?.stand || "zu",
      video: s?.video || "",
      video_titel: s?.video_titel || "",
      laeuft: !!s?.laeuft,
      sekunde: s?.sekunde || 0,
      /* DIE GESCHWINDIGKEIT MUSS MIT. Ohne sie liefe das Video in
         OBS immer auf 1,0 -- und sobald die Regie auf 1,5 stellt,
         liefe der Stream langsamer als der Saal. Nach fuenf Minuten
         waeren das zweieinhalb Minuten Unterschied, und was Filipe
         kommentiert, haetten die Zuschauer noch gar nicht gesehen. */
      tempo: Number(s?.tempo) || 1,
      gesendet: Date.now(),
      titel: s?.titel || "",
    });
  } catch (fehler) {
    console.error("[buehne] Lage:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Der Strom: Videowechsel und Spendenkarten. */
buehneRouter.get("/workspace/api/buehne/strom", mitSchluessel, (req, res) => {
  if (zuhoerer.size >= MAX_QUELLEN) return res.status(503).end();
  res.set({
    "Content-Type": "text/event-stream",
    "Cache-Control": "no-store",
    Connection: "keep-alive",
    /* Kein Puffer dazwischen -- sonst kommt die Karte, wenn die
       naechste kommt. */
    "X-Accel-Buffering": "no",
  });
  res.flushHeaders?.();
  res.write("retry: 3000\n\n");
  zuhoerer.add(res);

  /* ALLE 25 SEKUNDEN EIN LEBENSZEICHEN. Ein Strom, durch den nichts
     fliesst, wird von jedem Vermittler irgendwann geschlossen -- und
     OBS merkt es erst, wenn die naechste Karte ausbleibt. */
  const puls = setInterval(() => {
    try { res.write(": puls\n\n"); } catch { /* gleich weg */ }
  }, 25_000);

  req.on("close", () => {
    clearInterval(puls);
    zuhoerer.delete(res);
  });
});

/* ---------- Fuer das Regiepult ----------------------------------------- */
function nurLeitung(req, res, next) {
  const p = sitzungLesen(req);
  if (!p) return res.status(401).json({ fehler: "nicht_angemeldet" });
  if (p.haus === "agentur") return res.status(404).end();
  if (!LEITUNG.has(p.rolle)) return res.status(403).json({ fehler: "nur_leitung" });
  req.person = p;
  next();
}

buehneRouter.get("/workspace/api/buehne/adressen", nurLeitung, (req, res) => {
  try {
    const s = buehneSchluessel();
    const wurzel = `https://${req.get("Host")}`;
    res.set("Cache-Control", "no-store");
    res.json({
      video: `${wurzel}/workspace/buehne.html?s=${s}`,
      tafel: `${wurzel}/workspace/tafel.html?s=${s}`,
      buehnenmodus: `${wurzel}/workspace/reaktion.html?nur=buehne`,
      quellen: buehneQuellen(),
    });
  } catch (fehler) {
    console.error("[buehne] Adressen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

buehneRouter.post("/workspace/api/buehne/schluessel", nurLeitung, (req, res) => {
  try {
    const neu = randomBytes(32).toString("hex");
    einstellungSetzen(SCHLUESSEL_NAME, neu, req.person);
    protokolliere("buehne_schluessel", {
      personId: req.person.id,
      detail: "neu erzeugt",
      ip: echteIp(req),
    });
    /* DIE ALTEN QUELLEN WERDEN GESCHLOSSEN. Sonst liefe eine Quelle
       mit dem alten Schluessel weiter, obwohl er zurueckgezogen ist
       -- und man haelt sich fuer sicher, ohne es zu sein. */
    for (const antwort of [...zuhoerer]) {
      try { antwort.end(); } catch { /* egal */ }
      zuhoerer.delete(antwort);
    }
    const wurzel = `https://${req.get("Host")}`;
    res.json({
      video: `${wurzel}/workspace/buehne.html?s=${neu}`,
      tafel: `${wurzel}/workspace/tafel.html?s=${neu}`,
      quellen: 0,
    });
  } catch (fehler) {
    console.error("[buehne] Schluessel:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});