dogfather-universe/server/workspace-anruf.js

/* =====================================================================
   TELEFONIEREN IM CHAT (18.09.2026)

   Filipe: „kann man machen dass die modis, rechte hand und ich auch
   telefonieren können im chat?" -- und nach dem Plan: „ich will dass du
   das nimmst was man selbst in die app reinsetzten kann, nicht meinen
   pc belastet und trotzdem vielleicht in gruppe, mit video oder
   einzelnd, alles was möglich ist."

   ---------------------------------------------------------------------
   WAS HIER PASSIERT -- UND WAS AUSDRÜCKLICH NICHT

   Der Ton geht NICHT über diesen Server. Er geht direkt von einem
   Browser zum anderen (WebRTC). Dieser Server tut nur das, was die
   beiden allein nicht können: Er reicht die Verbindungsdaten weiter,
   damit sie sich finden. Das sind ein paar Kilobyte je Anruf --
   danach ist er aus dem Spiel.

   DAS IST DIE ANTWORT AUF „NICHT MEINEN PC BELASTEN":
   Bei zwei Teilnehmern kodiert jedes Gerät genau einen Strom und
   dekodiert einen. Das ist die Last eines gewöhnlichen Videoanrufs.
   Erst bei GRUPPEN wächst sie -- dazu unten mehr.

   ---------------------------------------------------------------------
   WARUM ES KEINEN NEUEN DIENST BRAUCHT

   Der Chat hat bereits alles, was die Signalisierung verlangt:

     `chatEreignis()`  schickt an alle offenen Verbindungen eines Raums
                       (SSE) -- der Hinweg für Angebot, Antwort und
                       Verbindungswege.
     Push              weckt die, die gerade nicht zusehen -- das
                       Klingeln.
     `chat_raeume`     kennt Räume mit beliebig vielen Teilnehmern --
                       Einzelgespräch ist der Sonderfall „genau zwei".

   Ein Anruf ist damit kein neues Konzept, sondern ein Ereignis mehr in
   einem Kanal, den es gibt. Ein eigener WebSocket-Dienst daneben wäre
   eine zweite Verbindung, die dieselbe Frage beantwortet -- und die
   zweite ist die, die beim nächsten Umbau vergessen wird.

   ---------------------------------------------------------------------
   DIE GRENZEN, EHRLICH AUFGESCHRIEBEN

   1. ZU ZWEIT ist die Last minimal und es funktioniert überall.

   2. IN DER GRUPPE verbindet sich jeder mit jedem. Bei drei Leuten
      sind das zwei Ströme hin und zwei zurück, bei vier je drei. Ab
      etwa vier Teilnehmern wird das auf schwächeren Geräten spürbar.
      Die Grenze steht deshalb als Zahl im Code (GRUPPE_MAX) und nicht
      im Gedächtnis -- wer sie erhöht, soll sehen, was daran hängt.

      Der saubere Weg darüber hinaus wäre ein Medienserver (SFU), der
      die Ströme verteilt: Dann sendet jedes Gerät nur EINMAL. Der
      läuft auf unserem Server, nicht auf Filipes Rechner -- aber er
      ist ein eigener Dienst mit eigener Wartung. Das ist der nächste
      Schritt, nicht dieser.

   3. AUF DEM IPHONE hört der Ton auf, sobald der Bildschirm ausgeht
      oder Safari in den Hintergrund rutscht. Das ist eine Regel von
      Apple für alle Web-Anwendungen und lässt sich nicht umgehen. Es
      klingelt zuverlässig -- wer rangeht, muss die Seite offen lassen.

   4. OHNE EIGENEN TURN-SERVER kommen etwa 15 bis 25 Prozent der
      Verbindungen nicht zustande (strenge Firmennetze, manche
      Mobilfunknetze). Die Adressen stehen in den Einstellungen und
      lassen sich nachtragen, ohne eine Zeile Code zu ändern.
   ===================================================================== */
import express from "express";
import {
  db, sitzungLesen, protokolliere, echteIp, einstellung, einstellungSetzen,
  istDogFather,
} from "./workspace.js";
import { chatEreignis, istDrinFuerAnruf, teilnehmerFuerAnruf } from "./workspace-chat.js";
import { darfTelefonieren } from "./workspace-treffchat.js";
import { mitZugangsdaten, wegeAusfaechern } from "./workspace-turn.js";

export const anrufRouter = express.Router();

/** Wie viele gleichzeitig -- und warum diese Zahl.
 *
 *  Jeder verbindet sich mit jedem: Bei N Teilnehmern sendet jedes
 *  Gerät N-1 Ströme und empfängt N-1. Bei vier sind das je drei, und
 *  drei Videoströme zu kodieren merkt ein älteres Handy deutlich.
 *
 *  VIER IST DIE GRENZE, AN DER ES NOCH ANGENEHM IST. Wer sie erhöht,
 *  erhöht die Last quadratisch -- deshalb steht sie hier und nicht
 *  verstreut in drei Abfragen. */
export const GRUPPE_MAX = 4;

/** Wie lange ein Anruf im Raum „klingelt", bevor er von selbst verfällt.
 *
 *  Ohne diese Grenze bliebe ein Anruf, bei dem der Anrufer die Seite
 *  schließt, für immer offen stehen -- und der Angerufene sähe eine
 *  Einladung zu einem Gespräch, an dem niemand mehr teilnimmt.
 *
 *  ---------------------------------------------------------------------
 *  WARUM ZWEI MINUTEN UND NICHT 45 SEKUNDEN (18.09.2026)
 *
 *  Filipe: „das mit dem anruf klappt nicht … es geeeeeht einfach
 *  nicht." Nachgemessen war serverseitig alles in Ordnung: Der Anruf
 *  kam an, der Raum stimmte, die Angerufene war angemeldet und hatte
 *  ein Gerät für Benachrichtigungen.
 *
 *  Nur passte die Zeit nicht zum Weg. Bei einem Telefon hebt man ab --
 *  hier muss in dieselben Sekunden: Benachrichtigung zustellen, sie
 *  bemerken, Handy entsperren, antippen, App laden, Anmeldung prüfen.
 *  45 Sekunden reichen dafür, wenn man das Gerät in der Hand hält, und
 *  sonst nie.
 *
 *  Das ist der Unterschied zwischen „funktioniert" und „funktioniert
 *  im Alltag". Zwei Minuten sind lang genug, um aus der Tasche zu
 *  kommen, und kurz genug, dass niemand vor einem Anruf sitzt, den es
 *  längst nicht mehr gibt. */
const KLINGELT_SEKUNDEN = Number(process.env.ANRUF_KLINGELT_SEKUNDEN) || 120;

/* WARUM UEBER DIE UMGEBUNG UMSTELLBAR: Damit eine Pruefung den Ablauf
   messen kann, ohne zwei Minuten zu warten. Eine Pruefung, die so
   lange braucht, wird abgeschaltet -- und dann ist der verpasste
   Anruf wieder ungeprueft. Im Betrieb steht die Variable nirgends;
   dort gelten die 120 Sekunden. */

/* Wer gerade in welchem Raum telefoniert.
   IM SPEICHER, NICHT IN DER DATENBANK: Ein laufender Anruf ist ein
   Zustand dieses Prozesses, kein Datum. Startet der Server neu, ist
   jeder Anruf ohnehin zu Ende -- ein Eintrag in der Datenbank würde
   danach eine Verbindung behaupten, die es nicht mehr gibt. */
const laufend = new Map();      // raumId -> { seit, wer: Map(personId -> {name, seit}) }

/** Räumt ab, was abgelaufen ist. Läuft bei jeder Anfrage mit, statt
 *  als Zeitgeber: Ein Zeitgeber, der alle zehn Sekunden über eine
 *  leere Liste läuft, ist Arbeit ohne Anlass. */
function aufraeumen() {
  const jetzt = Date.now();
  for (const [raumId, a] of laufend) {
    if (!a.wer.size) { laufend.delete(raumId); continue; }
    /* Ein Anruf, bei dem seit KLINGELT_SEKUNDEN nur EINER drin ist,
       ist keiner mehr -- der Angerufene ist nicht rangegangen. */
    if (a.wer.size === 1 && jetzt - a.seit > KLINGELT_SEKUNDEN * 1000) {
      laufend.delete(raumId);

      /* ---- UND ER HINTERLAESST EINE SPUR (18.09.2026) -------------

         Bisher verschwand ein verpasster Anruf lautlos. Wer zu spaet
         kam, oeffnete den Chat und sah -- nichts. Keine Zeile, kein
         Hinweis, nicht einmal, DASS jemand angerufen hat. Genau das
         fuehlt sich an wie „es geht einfach nicht", auch wenn technisch
         alles funktioniert hat.

         Jedes Telefon der Welt zeigt einen verpassten Anruf. Hier
         steht er als Zeile im Gespraech, mit Namen und Uhrzeit -- und
         damit hat der andere etwas, worauf er antworten kann.

         IN EINEM EIGENEN try: Ein Fehler beim Schreiben der Zeile darf
         das Aufraeumen nicht anhalten -- sonst bliebe ein abgelaufener
         Anruf stehen, und das waere schlimmer als eine fehlende
         Notiz. */
      try { verpasstVermerken(raumId, a); } catch (f) {
        console.error("[anruf] verpasst:", f?.message);
      }
    }
  }
}

/** Schreibt „Anruf · 3:42" in das Gespraech, wenn er vorbei ist.
 *
 *  Filipe: „im chat soll auch stehen verpasster anruf oder anruf
 *  gehabt und wie lange."
 *
 *  WARUM DIE DAUER UND NICHT NUR „Anruf": Eine Zeile ohne Zahl
 *  beantwortet die Frage nicht, die man Tage spaeter hat -- „haben wir
 *  das besprochen oder nur kurz telefoniert?". Drei Minuten sind ein
 *  Gespraech, zwoelf Sekunden sind ein Verwaehlen.
 *
 *  GEZAEHLT AB DEM RANGEHEN, nicht ab dem Klingeln. Sonst staende bei
 *  jedem Anruf eine halbe Minute zu viel darin -- die Zeit, in der das
 *  Telefon nur laeutete.
 */
function anrufVermerken(raumId, a) {
  const beginn = a.gespraechSeit || a.seit;
  const s = Math.max(1, Math.round((Date.now() - beginn) / 1000));
  /* Unter einer Minute reicht die Sekundenzahl -- „0:07" liest sich
     umstaendlicher als „7 Sekunden". */
  const dauer = s < 60
    ? `${s} Sekunde${s === 1 ? "" : "n"}`
    : `${Math.floor(s / 60)}:${String(s % 60).padStart(2, "0")} Minuten`;

  /* Die Zeile steht beim ANRUFER -- er hat den Anruf begonnen, und im
     Verlauf liest es sich wie bei jedem Telefon. Wer das war, weiss
     nur der Eintrag selbst; `wer` ist nach Reihenfolge des Beitritts
     sortiert. */
  const wer = a.anrufer || null;
  if (!wer) return;
  const d = db();
  const n = new Date().toISOString();
  const text = `📞 ${a.video ? "Videoanruf" : "Anruf"} · ${dauer}`;
  d.prepare("INSERT INTO chat_nachrichten (raum_id, person_id, text, erstellt) VALUES (?,?,?,?)")
    .run(raumId, wer.id, text, n);
  const neueId = d.prepare("SELECT last_insert_rowid() AS id").get().id;
  d.prepare("UPDATE chat_raeume SET letzte_am = ? WHERE id = ?").run(n, raumId);

  chatEreignis(raumId, {
    id: neueId, raum_id: raumId, von_id: wer.id, von: wer.name,
    text, erstellt: n, zurueckgenommen: false, antwort: null, anhang: null,
  }, [], "neu");
}

/** Schreibt „Verpasster Anruf" in das Gespraech.
 *
 *  Als ganz normale Nachricht des Anrufers: So steht sie an der
 *  richtigen Stelle im Verlauf, wird mitgezaehlt wie jede andere und
 *  braucht keine Sonderbehandlung in der Oberflaeche. */
function verpasstVermerken(raumId, a) {
  /* AUS `a.anrufer`, NICHT AUS `a.wer`.

     `wer` ist die Runde der gerade Anwesenden. Beim Verfallen steht
     der Anrufer noch darin -- beim AUFLEGEN ist sie leer, und die
     Zeile waere still ausgefallen. Genau dieser Unterschied hat den
     Fehler vom 19.09. so schwer sichtbar gemacht: In der Pruefung
     (Anruf verfaellt) ging es, im Alltag (Anrufer legt auf) nicht. */
  const wer = a.anrufer;
  if (!wer) return;
  const id = wer.id;
  const d = db();
  const n = new Date().toISOString();
  const text = a.video ? "📞 Verpasster Videoanruf" : "📞 Verpasster Anruf";
  d.prepare("INSERT INTO chat_nachrichten (raum_id, person_id, text, erstellt) VALUES (?,?,?,?)")
    .run(raumId, id, text, n);
  const neueId = d.prepare("SELECT last_insert_rowid() AS id").get().id;
  d.prepare("UPDATE chat_raeume SET letzte_am = ? WHERE id = ?").run(n, raumId);

  /* Die anderen im Raum bekommen sie wie jede Nachricht -- inklusive
     Benachrichtigung, falls sie gerade nicht zusehen. Wer den Anruf
     verpasst hat, sieht wenigstens, DASS er ihn verpasst hat. */
  const andere = teilnehmerFuerAnruf(raumId)
    .map((t) => t.id).filter((x) => x !== id);
  chatEreignis(raumId, {
    id: neueId, raum_id: raumId, von_id: id, von: wer.name,
    text, erstellt: n, zurueckgenommen: false, antwort: null, anhang: null,
  }, andere, "neu");
}

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  next();
}

/* GLEICHE HERKUNFT. Ein Anruf ist ein schreibender Vorgang -- er
   klingelt bei jemandem. Dieselbe Pruefung wie ueberall sonst. */
function gleicheHerkunft(req, res, next) {
  const herkunft = req.get("origin");
  if (!herkunft) return next();
  try {
    if (new URL(herkunft).host === req.get("host")) return next();
  } catch { /* unlesbar -> abweisen */ }
  return res.status(403).json({ fehler: "fremde_herkunft" });
}

anrufRouter.use("/workspace/api/anruf", angemeldet);

/* =====================================================================
   DIE COMMUNITY TELEFONIERT NICHT (19.09.2026)

   Filipe, als er den Treff-Chat bestellt hat: „und die sollen nicht
   anrufen koennen. nur schreiben."

   WARUM DAS EINEN EIGENEN RIEGEL BRAUCHT, obwohl niemand es je erlaubt
   hat: Ein Anruf haengt in diesem Haus an der RAUMMITGLIEDSCHAFT
   (`istDrin`), nicht an der Rolle. Solange die Community gar keinen
   Raum hatte, war die Frage muessig. Seit sie einen hat, waere
   Telefonieren erlaubt -- nicht, weil es jemand entschieden haette,
   sondern weil es niemand verboten hat. Das ist die gefaehrlichste
   Art von Erlaubnis: Sie entsteht durch eine Aenderung an einer ganz
   anderen Stelle, und sie faellt niemandem auf.

   HIER UND NICHT IN DEN NEUN ROUTEN DAHINTER. Neun Stellen hiessen
   acht richtige und eine vergessene, und die vergessene waere die,
   die keiner ausprobiert. Dieselbe Begruendung wie bei `istDrin`
   nebenan.

   404 UND NICHT 403: Wer "kein Zugriff" liest, weiss, dass es etwas
   gibt. Fuer jemanden aus der Community existiert die Anruffunktion
   schlicht nicht -- die Oberflaeche zeigt sie ihm auch nicht.
   ===================================================================== */
anrufRouter.use("/workspace/api/anruf", (req, res, next) => {
  if (darfTelefonieren(req.person)) return next();
  return res.status(404).json({ fehler: "nicht_gefunden" });
});

const nummer = (x) => { const n = Number(x); return Number.isInteger(n) && n > 0 ? n : 0; };

/* =====================================================================
   DIE VERBINDUNGSADRESSEN

   STUN sagt einem Browser, wie er von aussen aussieht. TURN leitet den
   Ton weiter, wenn eine direkte Verbindung nicht zustande kommt.

   SIE STEHEN IN DEN EINSTELLUNGEN, NICHT IM CODE. Wer einen eigenen
   TURN-Server einrichtet, traegt ihn dort ein -- ohne dass jemand eine
   Zeile aendert und ohne Neustart. Genau daran ist im Haus schon
   einmal etwas gescheitert: Eine Adresse im Quelltext ist eine, die
   beim naechsten Umzug niemand findet.

   DER STANDARD IST BEWUSST LEER, was STUN angeht: Ein oeffentlicher
   STUN-Dienst (etwa der von Google) bekommt bei jedem Anruf die
   IP-Adresse beider Teilnehmer zu sehen. Das ist fuer ein Team, das
   ueber Moderation und Vorfaelle spricht, keine Kleinigkeit -- und es
   waere eine Entscheidung, die ich nicht still treffen darf. Ohne
   Eintrag funktioniert der Anruf im selben Netz; sobald coturn auf dem
   eigenen Server steht, funktioniert er ueberall.
   ===================================================================== */
anrufRouter.get("/workspace/api/anruf/adressen", (req, res) => {
  try {
    let liste = [];
    try { liste = JSON.parse(einstellung("anruf_adressen") || "[]"); } catch { liste = []; }

    /* ZUGANGSDATEN WERDEN GERECHNET, NICHT GESPEICHERT.
       Warum das so ist, steht ausfuehrlich in workspace-turn.js. Kurz:
       Ein festes TURN-Passwort laege dauerhaft im Browser jedes
       Teilnehmers und liesse sich nie wieder entziehen. Die hier
       erzeugten verfallen von selbst.

       Als Kennung die PERSONENNUMMER, nicht der Name -- sie landet im
       Protokoll von coturn, und das ist kein Ort fuer Klarnamen. */
    /* ERST AUFFAECHERN, DANN ANMELDEN (19.09.2026).

       Ein eingetragenes `turn:host:port` ohne `?transport=` heisst
       UDP -- und nur UDP. Wer in einem Netz sitzt, das UDP nach
       draussen sperrt, bekommt damit keinen Vermittlungsweg: Es
       klingelt (das laeuft ueber 443), und danach passiert nichts.

       Nachgemessen hoert coturn auf beidem. Aus einem Eintrag werden
       deshalb drei Wege -- stun, turn/udp, turn/tcp. Die Reihenfolge
       ist Absicht, siehe workspace-turn.js.

       VOR mitZugangsdaten, nicht danach: Die neuen turn:-Eintraege
       brauchen dieselben gerechneten Zugangsdaten wie der Eintrag, aus
       dem sie entstanden sind. Andersherum waeren zwei von drei ohne
       Passwort -- also genau der Zustand, den wir beheben wollen. */
    const { adressen, turn_gesamt, turn_bereit, grund } =
      mitZugangsdaten(wegeAusfaechern(liste), `w${req.person.id}`);

    if (grund) {
      /* DER DRITTE AUSGANG. „Kann nicht nachsehen" ist etwas anderes
         als „ist nicht eingerichtet" -- und wer das verschweigt, sucht
         den Fehler spaeter beim Anrufer. */
      console.warn(`[anruf] TURN-Geheimnis nicht verwendbar: ${grund}`);
    }

    res.json({
      adressen,
      gruppe_max: GRUPPE_MAX,
      /* WAS DIE OBERFLAECHE WISSEN MUSS, um ehrlich zu sein: Ohne
         Adressen klappt der Anruf nur im selben Netz. Das gehoert
         DAVOR gesagt, nicht als Fehlermeldung danach. */
      nur_gleiches_netz: !Array.isArray(liste) || liste.length === 0,
      /* Zahlen statt Ja/Nein: Wer zaehlen kann, kann pruefen. Ein
         eingetragener TURN-Server, der mangels Geheimnis niemanden
         durchlaesst, sieht sonst genauso aus wie ein funktionierender. */
      turn_gesamt,
      turn_bereit,
      ...(grund ? { turn_grund: grund } : {}),
    });
  } catch (f) {
    console.error("[anruf] Adressen:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Die Adressen eintragen -- nur DogFather.
 *
 *  Es sind Zugangsdaten zu einem Dienst (TURN braucht Benutzer und
 *  Passwort). Die gehoeren nicht in eine Oberflaeche, die jeder sieht. */
anrufRouter.put("/workspace/api/anruf/adressen", gleicheHerkunft,
  express.json({ limit: "8kb" }), (req, res) => {
    try {
      if (!istDogFather(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
      const liste = Array.isArray(req.body?.adressen) ? req.body.adressen : null;
      if (!liste) return res.status(400).json({ fehler: "Erwartet wird eine Liste." });
      /* Nur die Felder, die WebRTC kennt -- alles andere waere ein
         offenes Tor, um beliebiges JSON in die Einstellungen zu legen. */
      const sauber = liste.slice(0, 8).map((e) => ({
        urls: String(e?.urls || "").slice(0, 200),
        ...(e?.username ? { username: String(e.username).slice(0, 100) } : {}),
        ...(e?.credential ? { credential: String(e.credential).slice(0, 200) } : {}),
      })).filter((e) => /^(stun|turn|turns):/.test(e.urls));
      einstellungSetzen("anruf_adressen", JSON.stringify(sauber));
      protokolliere("anruf_adressen", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `${sauber.length} Adresse(n)`,
      });
      res.json({ ok: true, anzahl: sauber.length });
    } catch (f) {
      console.error("[anruf] Adressen setzen:", f?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* =====================================================================
   ANRUFEN
   ===================================================================== */
anrufRouter.post("/workspace/api/anruf/:raum/start", gleicheHerkunft,
  express.json({ limit: "4kb" }), (req, res) => {
    try {
      aufraeumen();
      const raumId = nummer(req.params.raum);
      if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
        return res.status(404).json({ fehler: "nicht_gefunden" });
      }
      const mitVideo = req.body?.video === true;

      const leute = teilnehmerFuerAnruf(raumId);
      if (leute.length > GRUPPE_MAX) {
        return res.status(409).json({
          fehler: `In diesem Gespräch sind ${leute.length} Leute. `
            + `Telefonieren geht bis ${GRUPPE_MAX} – darüber wird es für die `
            + `Geräte zu viel.`,
        });
      }

      const schon = laufend.get(raumId);
      if (schon && !schon.wer.has(req.person.id)) {
        /* Es laeuft schon einer -- dann tritt man bei, statt einen
           zweiten zu starten. Zwei Anrufe im selben Raum waeren zwei
           Gespraeche, von denen jeder das andere nicht hoert. */
        schon.wer.set(req.person.id, { name: req.person.name, seit: Date.now() });
        chatEreignis(raumId, {
          raum_id: raumId, art: "dabei",
          person: { id: req.person.id, name: req.person.name },
          wer: [...schon.wer.entries()].map(([id, w]) => ({ id, name: w.name })),
        }, [], "anruf");
        return res.json({ ok: true, beigetreten: true, video: schon.video });
      }

      laufend.set(raumId, {
        seit: Date.now(), video: mitVideo,
        /* WER ANGERUFEN HAT -- eigens gemerkt (18.09.2026).

           `wer` ist die Runde der GERADE Anwesenden; sie aendert sich,
           und am Ende ist sie leer. Fuer die Zeile im Chat („Anruf ·
           3:42") braucht es aber den, der begonnen hat -- so wie bei
           jedem Telefon. Aus einer Liste, die sich leert, laesst sich
           das hinterher nicht mehr ablesen. */
        anrufer: { id: req.person.id, name: req.person.name },
        wer: new Map([[req.person.id, { name: req.person.name, seit: Date.now() }]]),
      });

      /* DAS KLINGELN. `chatEreignis` schickt an alle offenen
         Verbindungen des Raums UND weckt per Push, wer nicht zusieht --
         genau die zwei Wege, die ein Anruf braucht. Der dritte
         Parameter sind die, die geweckt werden sollen: alle ausser dem
         Anrufer. */
      const wecken = leute.map((t) => t.id).filter((id) => id !== req.person.id);
      chatEreignis(raumId, {
        raum_id: raumId, art: "klingelt", video: mitVideo,
        von: { id: req.person.id, name: req.person.name },
        laeuft_bis: Date.now() + KLINGELT_SEKUNDEN * 1000,
      }, wecken, "anruf");

      protokolliere("anruf_start", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `Raum ${raumId}${mitVideo ? " mit Video" : ""}`,
      });
      res.json({ ok: true, video: mitVideo, wer: [{ id: req.person.id, name: req.person.name }] });
    } catch (f) {
      console.error("[anruf] Start:", f?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Annehmen. */
anrufRouter.post("/workspace/api/anruf/:raum/dabei", gleicheHerkunft, (req, res) => {
  try {
    aufraeumen();
    const raumId = nummer(req.params.raum);
    if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
      return res.status(404).json({ fehler: "nicht_gefunden" });
    }
    const a = laufend.get(raumId);
    if (!a) return res.status(409).json({ fehler: "Der Anruf ist schon vorbei." });
    if (a.wer.size >= GRUPPE_MAX) {
      return res.status(409).json({ fehler: `Es telefonieren schon ${GRUPPE_MAX}.` });
    }
    /* WANN DAS GESPRAECH BEGINNT -- nicht, wann angerufen wurde.

     Die Dauer, die spaeter im Chat steht, soll die Zeit sein, in der
     wirklich geredet wurde. Zaehlte man ab dem Klingeln, staende dort
     bei jedem Anruf eine halbe Minute zu viel: die Zeit, in der das
     Telefon nur laeutete. */
  if (!a.gespraechSeit && a.wer.size >= 1) a.gespraechSeit = Date.now();
  a.wer.set(req.person.id, { name: req.person.name, seit: Date.now() });
    chatEreignis(raumId, {
      raum_id: raumId, art: "dabei",
      person: { id: req.person.id, name: req.person.name },
      wer: [...a.wer.entries()].map(([id, w]) => ({ id, name: w.name })),
    }, [], "anruf");

    /* DAS RANGEHEN GEHOERT INS PROTOKOLL (19.09.2026).

       Bis heute standen dort nur `anruf_start` und `anruf_ende`. Bei
       der Suche nach „es klingelt weiter, obwohl sie dran ist" war
       damit die wichtigste Frage nicht zu beantworten: IST sie
       ueberhaupt rangegangen?

       Herauszufinden war es nur ueber einen Umweg -- `anruf_ende` mit
       ihrer Personennummer. Das ist eine Schlussfolgerung, keine
       Auskunft. Ein Protokoll, das den Anfang und das Ende kennt, aber
       nicht den Moment dazwischen, laesst genau die Frage offen, die
       man spaeter stellt. */
    protokolliere("anruf_dabei", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `Raum ${raumId}, jetzt ${a.wer.size} dabei`,
    });

    res.json({ ok: true, video: a.video,
      wer: [...a.wer.entries()].map(([id, w]) => ({ id, name: w.name })) });
  } catch (f) {
    console.error("[anruf] Dabei:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Auflegen -- oder ablehnen. Derselbe Weg.
 *
 *  Wer ablehnt, war nie dabei; wer auflegt, geht raus. Beides endet in
 *  „diese Person nimmt nicht (mehr) teil", und zwei getrennte Wege
 *  waeren zwei Gelegenheiten, den Zustand verschieden zu fuehren. */
anrufRouter.post("/workspace/api/anruf/:raum/ende", gleicheHerkunft, (req, res) => {
  try {
    const raumId = nummer(req.params.raum);
    if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
      return res.status(404).json({ fehler: "nicht_gefunden" });
    }
    const a = laufend.get(raumId);
    if (a) {
      const war = a.wer.get(req.person.id);
      const warGespraech = a.wer.size >= 2 || !!a.gespraechSeit;
      a.wer.delete(req.person.id);
      const dauer = war ? Math.round((Date.now() - war.seit) / 1000) : 0;
      if (!a.wer.size) {
        laufend.delete(raumId);
        /* DER LETZTE GEHT -- also ist es vorbei. Jetzt gehoert eine
           Zeile in den Chat, wie bei jedem Telefon.

           ZWEI FAELLE, UND DER ZWEITE HAT GEFEHLT (19.09.2026):

             warGespraech  jemand ist rangegangen  -> „Anruf · 0:42"
             sonst         niemand ist rangegangen -> „Verpasster Anruf"

           Der zweite Fall stand vorher NUR in `aufraeumen()` -- also
           erst, wenn ein Anruf nach zwei Minuten von selbst verfaellt.
           Wer vorher auflegt, loeschte ihn damit spurlos.

           Genau das hat Filipe gemeldet: viermal angerufen, nach drei
           bis zehn Sekunden aufgelegt, „da steht immer noch nichts im
           chat vom anruf". Vier verpasste Anrufe, von denen keiner
           irgendwo stand -- und fuer die andere Seite ist ein Anrufer,
           der aufgibt, ERST RECHT ein verpasster Anruf.

           Eigenes try: Ein Fehler beim Schreiben darf das Auflegen
           nicht scheitern lassen. */
        try {
          if (warGespraech) anrufVermerken(raumId, a);
          else verpasstVermerken(raumId, a);
        } catch (fe) {
          console.error("[anruf] vermerken:", fe?.message);
        }
      }
      chatEreignis(raumId, {
        raum_id: raumId, art: a.wer.size ? "weg" : "ende",
        person: { id: req.person.id, name: req.person.name },
        wer: [...a.wer.entries()].map(([id, w]) => ({ id, name: w.name })),
        dauer,
      }, [], "anruf");
      if (war && dauer > 2) {
        protokolliere("anruf_ende", {
          personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
          detail: `Raum ${raumId}, ${dauer} s`,
        });
      }
    }
    res.json({ ok: true });
  } catch (f) {
    console.error("[anruf] Ende:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* =====================================================================
   DIE SIGNALISIERUNG

   Angebot, Antwort und Verbindungswege wandern hier durch -- und NUR
   sie. Der Server liest sie nicht, er reicht sie weiter.

   AN EINE BESTIMMTE PERSON, nicht an den ganzen Raum: Bei drei
   Teilnehmern baut jeder mit jedem eine eigene Verbindung auf, und ein
   Angebot, das an alle geht, würde von zweien beantwortet.
   ===================================================================== */
anrufRouter.post("/workspace/api/anruf/:raum/signal", gleicheHerkunft,
  express.json({ limit: "64kb" }), (req, res) => {
    try {
      const raumId = nummer(req.params.raum);
      if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
        return res.status(404).json({ fehler: "nicht_gefunden" });
      }
      const an = nummer(req.body?.an);
      const inhalt = req.body?.inhalt;
      if (!an || !inhalt || typeof inhalt !== "object") {
        return res.status(400).json({ fehler: "unvollstaendig" });
      }
      /* DER EMPFAENGER MUSS IM RAUM SEIN. Ohne diese Zeile waere das
         hier ein Weg, jedem Angemeldeten beliebiges JSON zu schicken --
         an jeder Chatberechtigung vorbei. */
      if (!teilnehmerFuerAnruf(raumId).some((t) => t.id === an)) {
        return res.status(404).json({ fehler: "nicht_gefunden" });
      }
      chatEreignis(raumId, {
        raum_id: raumId, art: "signal",
        von: req.person.id, an, inhalt,
      }, [], "anruf");
      res.json({ ok: true });
    } catch (f) {
      console.error("[anruf] Signal:", f?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/** Läuft hier gerade ein Anruf? Für den, der die Seite frisch öffnet. */
/* =====================================================================
   KLINGELT GERADE ETWAS FUER MICH? (18.09.2026)

   Filipe: „wenn ich vanvan anrufe kriegt sie nur eine benarichtigung
   aber keinen anruf was soll das."

   DAS WAR DER FEHLER, UND ER WAR GRUNDSAETZLICH. Das Klingeln lief
   ausschliesslich ueber `chatEreignis` -- also ueber den offenen
   Ereignisstrom. Wer die Seite gerade ansieht, hoert es. Wer sie
   NICHT offen hat, bekommt die Push-Benachrichtigung, tippt darauf,
   die Seite laedt -- und dann passiert nichts mehr. Das Ereignis war
   in dem Moment vorbei, in dem es geschickt wurde.

   Damit funktionierte der Anruf ausgerechnet fuer die nicht, fuer die
   die Benachrichtigung gebaut wurde. Und es sah aus wie ein Fehler
   beim Angerufenen („sie kriegt nur eine Benachrichtigung"), obwohl
   nichts kaputt war -- es fehlte schlicht der Weg zurueck.

   Diese Route ist dieser Weg: Beim Laden fragt die Seite einmal nach,
   ob in einem ihrer Raeume gerade jemand wartet. Ein laufender Anruf
   steht im Speicher (`laufend`), die Frage kostet also nichts.

   NUR WAS NOCH KLINGELT: Anrufe, die laenger als KLINGELT_SEKUNDEN
   her sind, gelten als verpasst -- sonst klingelte es beim Oeffnen
   noch, obwohl der andere laengst aufgelegt hat. Und nur Raeume, in
   denen die Person auch wirklich drin ist; `istDrinFuerAnruf` ist
   dieselbe Pruefung wie ueberall sonst.
   ===================================================================== */
anrufRouter.get("/workspace/api/anruf/offen", (req, res) => {
  try {
    aufraeumen();
    const jetzt = Date.now();
    const offen = [];
    for (const [raumId, a] of laufend) {
      /* Schon dabei? Dann klingelt es nicht mehr, dann telefoniert
         man. */
      if (a.wer.has(req.person.id)) continue;
      if (jetzt - a.seit > KLINGELT_SEKUNDEN * 1000) continue;
      /* DIE PERSON, NICHT IHRE NUMMER -- istDrin() wirft sonst einen
         TypeError, und zwar ausdruecklich: Die Sicherung steht dort
         genau fuer diesen Fall. Hier stand zuerst `.id`. */
      if (!istDrinFuerAnruf(raumId, req.person)) continue;
      const ersterAndere = [...a.wer.entries()][0];
      offen.push({
        raum_id: raumId,
        video: !!a.video,
        von: ersterAndere
          ? { id: ersterAndere[0], name: ersterAndere[1].name }
          : null,
        laeuft_bis: a.seit + KLINGELT_SEKUNDEN * 1000,
      });
    }
    res.json({ anrufe: offen });
  } catch (f) {
    console.error("[anruf] Offene:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

anrufRouter.get("/workspace/api/anruf/:raum", (req, res) => {
  try {
    aufraeumen();
    const raumId = nummer(req.params.raum);
    if (!raumId || !istDrinFuerAnruf(raumId, req.person)) {
      return res.status(404).json({ fehler: "nicht_gefunden" });
    }
    const a = laufend.get(raumId);
    res.json({
      laeuft: !!a,
      video: a?.video || false,
      wer: a ? [...a.wer.entries()].map(([id, w]) => ({ id, name: w.name })) : [],
      ich_dabei: !!a?.wer.has(req.person.id),
    });
  } catch (f) {
    console.error("[anruf] Lage:", f?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});