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 { mitZugangsdaten } 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. */
const KLINGELT_SEKUNDEN = 45;

/* 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);
    }
  }
}

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);

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. */
    const { adressen, turn_gesamt, turn_bereit, grund } =
      mitZugangsdaten(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: 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}.` });
    }
    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");
    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);
      a.wer.delete(req.person.id);
      const dauer = war ? Math.round((Date.now() - war.seit) / 1000) : 0;
      if (!a.wer.size) laufend.delete(raumId);
      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" });
  }
});