dogfather-universe/server/pruef-anruf.mjs

/* =====================================================================
   TELEFONIEREN IM CHAT -- die Riegel (18.09.2026)

   Filipe: „kann man machen dass die modis, rechte hand und ich auch
   telefonieren können im chat?"

   DER WICHTIGSTE ABSCHNITT IST DER LETZTE. Ein Anruf ist der
   vertraulichste Vorgang im ganzen Haus: Was gesagt wird, steht
   nirgends, und wer mithört, hinterlässt keine Spur. Die Frage „kommt
   jemand hinein, der nicht in den Raum gehört?" muss deshalb an JEDER
   Route beantwortet sein und nicht an der Liste davor.

   Besonders die Signalisierung: Sie reicht beliebiges JSON an eine
   Personennummer weiter. Ohne Prüfung wäre das ein Weg, jedem
   Angemeldeten etwas zu schicken -- an jeder Chatberechtigung vorbei.

   Aufrufen mit:  node server/pruef-anruf.mjs
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { request as httpAnfrage } from "node:http";
import { portMussFreiSein } from "./helfer-port.mjs";

const PORT = await portMussFreiSein(4196, "pruef-anruf");
const ordner = mkdtempSync(join(tmpdir(), "ws-anruf-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = String(PORT);
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
await import("./index.js");
notbremse(180_000, "pruef-anruf");
await new Promise((r) => setTimeout(r, 800));

process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });

let fehler = 0, geprueft = 0, offen = 0;
const melde = (t) => console.log(t);
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
const unklar = (t) => { offen++; console.log("  --   " + t); };

const CREW = "crew.dogfather-universe.com";
const HAUS = "workspace.dogfather-universe.com";

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
const anrufModul = await import("./workspace-anruf.js");

/* ---- Leute anlegen ---- */
const d = new DatabaseSync(process.env.WORKSPACE_DB);
function person(name, rolle, code) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(code, salt, 64,
    { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, new Date().toISOString());
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = person("Filipe", "admin", "CODE-DOGI-0001");
const idHand = person("Rieke", "hand", "CODE-HAND-0001");
const idModi = person("Kessi", "modi", "CODE-MODI-0001");
const idFremd = person("Tili", "creator", "CODE-TILI-0001");
d.close();

function roh(pfad, host, kopf = {}, koerper = null, methode = null) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({
      host: "127.0.0.1", port: PORT, path: pfad,
      method: methode || (koerper ? "POST" : "GET"),
      headers: { Host: host, ...(koerper ? { "Content-Type": "application/json" } : {}), ...kopf },
    }, (antwort) => {
      let text = "";
      antwort.on("data", (s) => { text += s; });
      antwort.on("end", () => fertig({ code: antwort.statusCode, text, kopf: antwort.headers }));
    });
    a.on("error", schief);
    if (koerper) a.write(JSON.stringify(koerper));
    a.end();
  });
}
const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };
async function anmelden(rolle, code, host) {
  const r = await roh("/workspace/api/anmelden", host, {}, { rolle, code });
  return [].concat(r.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
}
const kDogi = await anmelden("admin", "CODE-DOGI-0001", HAUS);
const kHand = await anmelden("hand", "CODE-HAND-0001", CREW);
const kModi = await anmelden("modi", "CODE-MODI-0001", CREW);
const kFremd = await anmelden("creator", "CODE-TILI-0001", HAUS);
ok(!!kDogi && !!kHand && !!kModi && !!kFremd, "vier Leute sind angemeldet");

/* =======================================================================
   1. DER KATALOG
   ======================================================================= */
melde("");
melde("=== 1. Was fest steht ===");
ok(anrufModul.GRUPPE_MAX >= 2 && anrufModul.GRUPPE_MAX <= 8,
  `die Gruppengrenze steht als Zahl im Code (${anrufModul.GRUPPE_MAX})`);

/* =======================================================================
   2. EIN GESPRAECH UND EIN ANRUF
   ======================================================================= */
melde("");
melde("=== 2. Anrufen ===");

/* Ein Zweier-Gespraech zwischen DogFather und der rechten Hand. */
let raumId = null;
{
  /* Die Route heisst `direkt`, nicht `mit` -- nachgesehen statt
     geraten. */
  const r = await roh("/workspace/api/chat/direkt", HAUS, { cookie: kDogi },
    { mit: idHand });
  raumId = json(r).raum?.id || json(r).raum_id || json(r).id;
  ok(!!raumId, `ein Gespraech entsteht (${r.code}, Raum ${raumId})`);
}

{
  const r = await roh(`/workspace/api/anruf/${raumId}`, HAUS, { cookie: kDogi });
  ok(r.code === 200 && json(r).laeuft === false,
    `am Anfang laeuft kein Anruf (${json(r).laeuft})`);
}

{
  const r = await roh(`/workspace/api/anruf/${raumId}/start`, HAUS,
    { cookie: kDogi }, { video: false });
  ok(r.code === 200, `anrufen geht (${r.code})`);
  const l = json(await roh(`/workspace/api/anruf/${raumId}`, HAUS, { cookie: kDogi }));
  ok(l.laeuft === true, "und danach laeuft einer");
  ok(l.wer?.length === 1 && l.wer[0].id === idDogi,
    `mit genau einem Teilnehmer (${l.wer?.map((w) => w.name).join(", ")})`);
}

{
  const r = await roh(`/workspace/api/anruf/${raumId}/dabei`, CREW, { cookie: kHand }, {}, "POST");
  ok(r.code === 200, `die rechte Hand geht ran (${r.code})`);
  const l = json(await roh(`/workspace/api/anruf/${raumId}`, CREW, { cookie: kHand }));
  ok(l.wer?.length === 2, `jetzt sind es zwei (${l.wer?.map((w) => w.name).join(", ")})`);
  ok(l.ich_dabei === true, "und sie weiss, dass sie dabei ist");
}

/* =======================================================================
   3. DIE SIGNALISIERUNG

   Sie reicht beliebiges JSON an eine Personennummer weiter. Ohne
   Pruefung waere das ein Weg, jedem Angemeldeten etwas zu schicken --
   an jeder Chatberechtigung vorbei.
   ======================================================================= */
melde("");
melde("=== 3. Die Signalisierung ===");
{
  const r = await roh(`/workspace/api/anruf/${raumId}/signal`, HAUS, { cookie: kDogi },
    { an: idHand, inhalt: { angebot: { type: "offer", sdp: "v=0" } } });
  ok(r.code === 200, `ein Angebot geht durch (${r.code})`);
}
{
  const r = await roh(`/workspace/api/anruf/${raumId}/signal`, HAUS, { cookie: kDogi },
    { an: idFremd, inhalt: { angebot: {} } });
  ok(r.code === 404,
    `an jemanden AUSSERHALB des Raums geht nichts (${r.code}) -- sonst waere das `
    + "ein Weg, jedem Angemeldeten JSON zu schicken");
}
{
  const r = await roh(`/workspace/api/anruf/${raumId}/signal`, HAUS, { cookie: kDogi },
    { an: idHand });
  ok(r.code === 400, `ohne Inhalt wird abgewiesen (${r.code})`);
}

/* =======================================================================
   4. WER NICHT HINEINGEHOERT

   Der wichtigste Abschnitt. Ein Anruf hinterlaesst keine Spur -- wer
   mithoert, faellt nicht auf. Die Frage muss an JEDER Route
   beantwortet sein.
   ======================================================================= */
melde("");
melde("=== 4. Wer nicht hineingehoert ===");
for (const [pfad, methode, koerper] of [
  ["", "GET", null],
  ["/start", "POST", { video: false }],
  ["/dabei", "POST", {}],
  ["/ende", "POST", {}],
  ["/signal", "POST", { an: idDogi, inhalt: { weg: {} } }],
]) {
  const r = await roh(`/workspace/api/anruf/${raumId}${pfad}`, HAUS,
    { cookie: kFremd }, koerper, methode);
  ok(r.code === 404,
    `${(pfad || "/lage").padEnd(8)} ist fuer Fremde zu -- und zwar 404, `
    + `nicht „kein Zugriff" (${r.code})`);
}
{
  const r = await roh(`/workspace/api/anruf/${raumId}`, HAUS, {});
  ok(r.code === 401, `ohne Anmeldung gar nichts (${r.code})`);
}
{
  const r = await roh("/workspace/api/anruf/999999/start", HAUS,
    { cookie: kDogi }, { video: false });
  ok(r.code === 404, `ein erfundener Raum wird abgewiesen (${r.code})`);
}

/* =======================================================================
   5. AUFLEGEN
   ======================================================================= */
melde("");
melde("=== 5. Auflegen ===");
{
  const r = await roh(`/workspace/api/anruf/${raumId}/ende`, CREW, { cookie: kHand }, {}, "POST");
  ok(r.code === 200, `die rechte Hand legt auf (${r.code})`);
  const l = json(await roh(`/workspace/api/anruf/${raumId}`, HAUS, { cookie: kDogi }));
  ok(l.laeuft === true && l.wer?.length === 1,
    `der Anruf laeuft weiter, solange noch jemand drin ist (${l.wer?.length})`);
  await roh(`/workspace/api/anruf/${raumId}/ende`, HAUS, { cookie: kDogi }, {}, "POST");
  const l2 = json(await roh(`/workspace/api/anruf/${raumId}`, HAUS, { cookie: kDogi }));
  ok(l2.laeuft === false, "wenn der Letzte geht, ist er vorbei");
}

/* =======================================================================
   6. DIE ADRESSEN

   Sie enthalten Zugangsdaten (TURN braucht Benutzer und Passwort).
   Deshalb darf nur DogFather sie setzen.
   ======================================================================= */
melde("");
melde("=== 6. Die Verbindungsadressen ===");
{
  const r = json(await roh("/workspace/api/anruf/adressen", HAUS, { cookie: kDogi }));
  ok(Array.isArray(r.adressen), `die Liste kommt (${r.adressen?.length} Eintraege)`);
  ok(r.nur_gleiches_netz === true,
    "und sie sagt ehrlich, dass es ohne Eintrag nur im selben Netz geht");
}
{
  const r = await roh("/workspace/api/anruf/adressen", CREW, { cookie: kHand },
    { adressen: [{ urls: "stun:beispiel.de:3478" }] }, "PUT");
  ok(r.code === 404, `die rechte Hand darf sie nicht setzen (${r.code})`);
}
{
  const r = await roh("/workspace/api/anruf/adressen", HAUS, { cookie: kDogi }, {
    adressen: [
      { urls: "stun:turn.dogfather-universe.com:3478" },
      { urls: "turn:turn.dogfather-universe.com:3478", username: "a", credential: "b" },
      /* DAS HIER MUSS RAUSFALLEN: kein STUN/TURN, sondern irgendetwas. */
      { urls: "https://beispiel.de/boese" },
    ],
  }, "PUT");
  ok(r.code === 200 && json(r).anzahl === 2,
    `DogFather setzt sie, und nur echte Adressen bleiben (${json(r).anzahl} von 3)`);
  const l = json(await roh("/workspace/api/anruf/adressen", CREW, { cookie: kModi }));
  ok(l.adressen?.length === 2, `alle bekommen sie zu sehen (${l.adressen?.length})`);
  ok(l.nur_gleiches_netz === false, "und der Hinweis verschwindet");
}

/* =======================================================================
   7. IM BROWSER
   ======================================================================= */
melde("");
melde("=== 7. Im Browser ===");
{
  let chromium;
  try {
    ({ chromium } = await import(
      "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs"));
  } catch { chromium = null; }

  if (!chromium) {
    unklar("kein Playwright gefunden -- die Oberflaeche wurde nicht angesehen");
  } else {
    const browser = await chromium.launch({
      /* Mikrofon ohne Rueckfrage und mit einem Testton statt echter
         Hardware -- sonst haengt getUserMedia im Prueflauf. */
      args: ["--use-fake-ui-for-media-stream", "--use-fake-device-for-media-stream"],
    });
    try {
      const sicht = await browser.newContext({
        viewport: { width: 1280, height: 900 },
        permissions: ["microphone", "camera"],
      });
      await sicht.addCookies(kDogi.split("; ").map((c) => {
        const [name, ...rest] = c.split("=");
        return { name, value: rest.join("="), domain: "127.0.0.1", path: "/" };
      }));
      const seite = await sicht.newPage();
      const konsole = [];
      seite.on("console", (m) => { if (m.type() === "error") konsole.push(m.text()); });
      await seite.goto(`http://127.0.0.1:${PORT}/workspace/chat.html`,
        { waitUntil: "domcontentloaded" });
      await seite.waitForTimeout(1800);

      ok(await seite.evaluate(() => typeof window.anrufStarten === "function"),
        "der Anruf ist geladen");

      /* Ein Gespraech oeffnen -- erst dann gibt es Knoepfe. */
      const raeume = await seite.locator("#raeume li").count();
      ok(raeume > 0, `${raeume} Gespraech(e) in der Liste`);
      await seite.locator("#raeume li").first().click();
      await seite.waitForTimeout(1200);

      const knoepfe = await seite.evaluate(() => ({
        ton: !!document.getElementById("anruf-ton-start"),
        video: !!document.getElementById("anruf-video-start"),
        sichtbar: document.getElementById("anruf-ton-start")?.offsetHeight > 0,
      }));
      ok(knoepfe.ton && knoepfe.video, "beide Anrufknoepfe stehen im Kopf");
      ok(knoepfe.sichtbar, "und man sieht sie");

      /* ANRUFEN -- und zwar wirklich. Ein Test, der nur prueft, dass
         ein Knopf da ist, prueft, dass jemand einen Knopf gebaut hat. */
      await seite.click("#anruf-ton-start");
      await seite.waitForTimeout(2500);
      const kasten = await seite.evaluate(() => {
        const k = document.getElementById("anruf");
        return {
          da: !!k && !k.hidden,
          lage: document.getElementById("anruf-lage")?.textContent || "",
          zeit: document.getElementById("anruf-zeit")?.textContent || "",
        };
      });
      ok(kasten.da, `der Anrufkasten erscheint ("${kasten.lage}")`);
      ok(/klingelt|Verbind/i.test(kasten.lage),
        `und sagt, was gerade passiert ("${kasten.lage}")`);
      ok(/^\d\d:\d\d$/.test(kasten.zeit), `die Uhr laeuft (${kasten.zeit})`);

      /* Und der Server weiss davon. */
      const l = json(await roh(`/workspace/api/anruf/${raumId}`, HAUS, { cookie: kDogi }));
      ok(l.laeuft === true, "der Server kennt den Anruf");

      await seite.screenshot({ path: "server/pruef-anruf.png", fullPage: false });
      melde("  --   Bildschirmfoto: server/pruef-anruf.png");

      await seite.click("#anruf-auflegen");
      await seite.waitForTimeout(900);
      ok(await seite.evaluate(() => document.getElementById("anruf")?.hidden === true),
        "nach dem Auflegen ist der Kasten weg");
      const l2 = json(await roh(`/workspace/api/anruf/${raumId}`, HAUS, { cookie: kDogi }));
      ok(l2.laeuft === false, "und der Server auch");

      ok(konsole.length === 0,
        konsole.length ? `Konsolenfehler: ${konsole[0]}` : "kein Konsolenfehler");
    } finally {
      await browser.close();
    }
  }
}

/* ------------------------------------------------------------------- */
melde("");
melde(`${geprueft} Pruefungen, ${fehler} Fehler`
  + (offen ? `, ${offen} nicht nachsehbar` : ""));
melde(fehler ? "NICHT IN ORDNUNG" : "ALLES IN ORDNUNG");
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* Aufraeumrest */ }
process.exit(fehler ? 1 : 0);