dogfather-universe/server/pruef-alle-wege.mjs

/* JEDER WEG, JEDE ROLLE — die Vollabdeckung.

   Auftrag vom 04.09.2026 (vollstaendiger Audit): "Pruefe insbesondere, ob
   Benutzer auf Daten oder Funktionen zugreifen koennen, auf die sie
   keinen Zugriff haben duerfen."

   WARUM ZUSAETZLICH ZU DEN VORHANDENEN PRUEFUNGEN. Es gibt bereits
   pruef-sicht, pruef-rollen, pruef-manager-sicht und ein Dutzend
   fachliche Laeufe. Die sind gruendlich -- aber sie pruefen AUSGEWAEHLTE
   Wege. Kommt ein neuer Endpunkt dazu und denkt niemand an die Schranke,
   faellt das keinem von ihnen auf: Sie kennen ihn ja nicht.

   Diese Pruefung kennt keinen Endpunkt auswendig. Sie LIEST die Routen
   aus dem Quelltext und geht stumpf ueber alle. Was dazukommt, ist
   damit automatisch mitgeprueft.

   DIE EINE HARTE REGEL, die ohne Fachwissen gilt:

       Ohne Anmeldung darf keine einzige /workspace/api-Route Daten
       herausgeben.

   Ausgenommen sind genau drei, und jede mit Grund (siehe OHNE_ANMELDUNG).
   Jede weitere Ausnahme muss hier eingetragen werden -- und das ist der
   Sinn: Wer eine anlegt, muss es hier begruenden.

   ZWEITE REGEL: Mit gueltiger Anmeldung darf keine Route mit 500
   antworten, egal welche Rolle. Ein 403/404 ist eine Aussage, ein 500
   ist ein Fehler.

   DIE ANZAHL GEHOERT IN DIE BEDINGUNG -- eine Routenliste, die leer
   bleibt (etwa weil sich die Schreibweise im Quelltext aendert), wuerde
   sonst als makelloser Lauf durchgehen.

   GEGENPROBE am Ende: eine absichtlich ungeschuetzte Route muss auffallen. */

import { mkdtempSync, rmSync, readFileSync, readdirSync } from "node:fs";
import { tmpdir } from "node:os";
import { join, dirname } from "node:path";
import { fileURLToPath } from "node:url";
import { heuteLokal } from "./helfer-zeit.mjs";

const HIER = dirname(fileURLToPath(import.meta.url));
const ordner = mkdtempSync(join(tmpdir(), "ws-wege-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* Der Port muss frei sein -- sonst wird gegen einen fremden Server
   gemessen. Begruendung in helfer-port.mjs. */
const { portMussFreiSein } = await import("./helfer-port.mjs");
await portMussFreiSein(4247, "die Wegepruefung");

process.env.PORT = "4247";
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 }); };
await import("./index.js");
await new Promise((r) => setTimeout(r, 900));
const BASIS = "http://127.0.0.1:4247";

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

/* =======================================================================
   Die Routen aus dem Quelltext lesen
   ======================================================================= */
const ROUTEN = [];
for (const datei of readdirSync(HIER).filter((n) => /^workspace.*\.js$/.test(n))) {
  const text = readFileSync(join(HIER, datei), "utf8");
  for (const t of text.matchAll(
    /Router\.(get|post|patch|put|delete)\(\s*\n?\s*"(\/workspace\/api\/[^"]*)"/g)) {
    ROUTEN.push({ art: t[1].toUpperCase(), pfad: t[2], datei });
  }
}
console.log(`\n=== Bestand ===`);
ok(ROUTEN.length >= 90, `${ROUTEN.length} Schnittstellen aus dem Quelltext gelesen`);
ok(new Set(ROUTEN.map((r) => r.datei)).size >= 20,
  `verteilt auf ${new Set(ROUTEN.map((r) => r.datei)).size} Module`);

/* Platzhalter mit echten Nummern fuellen -- sonst antwortet alles 400,
   und die Pruefung misst nur die Zahlenpruefung statt der Schranke. */
const einsetzen = (pfad, werte) => pfad
  .replace(/:bereich/g, "live")
  .replace(/:schluessel/g, werte.schluessel ?? "technik-01")
  .replace(/:datei/g, "0".repeat(32) + ".jpg")
  .replace(/:nid\(\\\\d\+\)|:nid/g, String(werte.nachricht ?? 1))
  .replace(/:id\(\\\\d\+\)|:id/g, String(werte.id ?? 1));

/* =======================================================================
   Bestand anlegen
   ======================================================================= */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
await fetch(BASIS + "/workspace/api/anmelden", {
  method: "POST", headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
for (let i = 0; i < 60; i++) {
  try {
    const p = new DatabaseSync(process.env.WORKSPACE_DB);
    try { p.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { p.close(); }
  } catch { await new Promise((r) => setTimeout(r, 250)); }
}
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
/* ORTSZEIT, nicht UTC -- Begruendung in helfer-zeit.mjs. Mit
   `jetzt.slice(0, 10)` lag dieser Wert zwischen Mitternacht und
   zwei Uhr einen Tag daneben. */
const heute = heuteLokal();
function anlegen(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, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
const idDogi = anlegen("Chef", "admin", "CODE-DOGI-0001");
const idMara = anlegen("Mara", "manager", "CODE-MANA-0001");
const idPat = anlegen("Pat", "scout", "CODE-SCOU-0001");
const idLuna = anlegen("Luna", "creator", "CODE-CREA-0001");

/* NORA GEHOERT NIEMANDEM, DER HIER MITSPIELT.
   Ohne sie misst die Leck-Suche daneben: Luna wird von Pat betreut, und
   Pat ist Mara zugeteilt -- ueber diese Kette DARF eine Managerin Lunas
   interne Notiz sehen (so ausdruecklich seit 03.09.2026). Der erste Lauf
   meldete deshalb einen "Fund", der keiner war.
   Nora haengt an einem zweiten Scout, den Mara nicht hat. Wer Noras
   interne Notiz sieht, sieht sie zu Unrecht. */
const idBea = anlegen("Bea", "scout", "CODE-SCOU-0002");
const idNora = anlegen("Nora", "creator", "CODE-CREA-0002");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idPat, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idNora, idBea, jetzt);
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)").run(idPat, idMara, jetzt);

/* GEHEIMWORT: kommt es irgendwo bei einer Rolle an, die es nicht sehen
   darf, ist das ein Leck -- egal ueber welchen Weg. */
const GEHEIM = "ZWOELFGEHEIMNIS";
d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, creator_id, erstellt, erstellt_von)
  VALUES (?,?,'offen','hoch',?,?,?)`).run("Aufgabe A", "harmlos", idLuna, jetzt, idDogi);
const idAufgabe = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare(`INSERT INTO termine (titel, art, beginn, dauer_min, creator_id, erstellt, erstellt_von)
  VALUES ('Call A','call',?,30,?,?,?)`).run(heute + "T10:00", idLuna, jetzt, idDogi);
const idTermin = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare(`INSERT INTO eintraege (bereich, art, titel, text, status, datum, creator_id, erstellt, erstellt_von)
  VALUES ('live','vorbereitung','Eintrag A','Text',?,?,?,?,?)`)
  .run("offen", heute, idLuna, jetzt, idDogi);
const idEintrag = d.prepare("SELECT last_insert_rowid() AS id").get().id;
d.prepare(`INSERT INTO leads (name, plattform, handle, status, prioritaet, notizen, scout_id, erstellt)
  VALUES ('Lead A','tiktok','@a','neu','hoch',?,?,?)`).run(GEHEIM + " im Lead", idBea, jetzt);
const idLead = d.prepare("SELECT last_insert_rowid() AS id").get().id;
/* KEIN STILLES catch HIER. Der erste Entwurf hatte eines ("Tabelle
   heisst evtl. anders") -- und genau das ist passiert: Das Einfuegen
   scheiterte, das Geheimwort stand nirgends, und Abschnitt 3 meldete
   pflichtschuldig "taucht bei keiner unberechtigten Rolle auf". Er hatte
   nur auf ein Wort geprueft, das es gar nicht gab.

   Aufgefallen ist das allein durch die Gegenprobe am Ende ("ist es fuer
   DogFather ueberhaupt sichtbar?"). Ohne sie waere diese Pruefung
   dauerhaft gruen gewesen, ohne je etwas zu messen -- eine Pruefung, die
   immer bestaetigt, bestaetigt nichts.

   Schlaegt das Einfuegen jetzt fehl, bricht der Lauf ab. Ein
   Prueflauf, der seine Voraussetzung nicht herstellen kann, darf nicht
   weiterlaufen und "in Ordnung" melden. */
/* Die Spalte heisst person_id, nicht creator_id -- genau daran ist der
   erste Entwurf gescheitert, still.
   Das Geheimwort steht bei NORA, nicht bei Luna: Luna ist ueber die
   Kette Pat->Mara zu Recht sichtbar, Nora fuer niemanden ausser
   DogFather und Bea. */
d.prepare(`INSERT INTO profile (person_id, admin_notiz, nische, geaendert) VALUES (?,?,?,?)`)
  .run(idNora, GEHEIM + " in der internen Notiz", "Basteln", jetzt);
d.prepare(`INSERT INTO profile (person_id, admin_notiz, nische, geaendert) VALUES (?,?,?,?)`)
  .run(idLuna, "Lunas Notiz (darf Mara sehen)", "Gaming", jetzt);
d.close();

async function anmelden(rolle, code) {
  const a = await fetch(BASIS + "/workspace/api/anmelden", {
    method: "POST", headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ rolle, code }) });
  const keks = (a.headers.getSetCookie?.() || []).map((z) => z.split(";")[0]).join("; ");
  if (!keks) throw new Error(`Anmeldung ${rolle} fehlgeschlagen (${a.status})`);
  return keks;
}
const KEKSE = {
  admin: await anmelden("admin", "CODE-DOGI-0001"),
  manager: await anmelden("manager", "CODE-MANA-0001"),
  scout: await anmelden("scout", "CODE-SCOU-0001"),
  creator: await anmelden("creator", "CODE-CREA-0001"),
};
const NUMMERN = {
  aufgaben: idAufgabe, termine: idTermin, eintrag: idEintrag,
  leads: idLead, profil: idNora, startcheck: idNora, steckbrief: idNora,
  personen: idNora, calls: idTermin,
};

/** Passende Nummer je nach Weg -- sonst prueft man 404 statt der Schranke. */
function nummerFuer(pfad) {
  for (const [wort, id] of Object.entries(NUMMERN)) {
    if (pfad.includes("/" + wort)) return id;
  }
  return 1;
}

/* ---------- WEGE, DIE NIE ZU ENDE ANTWORTEN ------------------------------

   Der Chat haelt seit dem 06.09.2026 eine Verbindung offen und schickt
   darueber Nachrichten, sobald sie entstehen (Server-Sent Events). Das
   ist genau der Zweck -- und fuer diese Pruefung eine Falle: `a.text()`
   wartet, bis der Server fertig ist, und der wird nie fertig.

   GEMESSEN, NICHT VERMUTET: Der komplette Prueflauf blieb dadurch
   haengen. Angemeldet als DogFather trat er in /workspace/api/chat/strom
   ein und kam nicht wieder heraus -- nach zwoelf Minuten war er immer
   noch dort. Es lief kein Fehler auf, es stand kein FEHL da: Der ganze
   Regressionslauf hoerte einfach auf, weiterzugehen. Das ist die
   unangenehmste Sorte, weil "noch nicht fertig" und "haengt fuer immer"
   von aussen gleich aussehen.

   ZWEI DINGE dagegen, und beide gehoeren zusammen:

     1. JEDER Ruf bekommt eine Frist. Laeuft sie ab, ist das ein
        ERGEBNIS ("hing") und kein Absturz -- die Pruefung laeuft weiter
        und sagt am Ende, wo es klemmte.
     2. Bekannte Stroeme stehen hier mit Begruendung. Sie werden nicht
        uebersprungen (ein uebersprungener Test beweist nichts), sondern
        ANDERS geprueft: verbinden, den Status ablesen, abbrechen. Die
        Schranke wird damit genauso gemessen wie ueberall sonst.

   Wer einen weiteren Strom baut, traegt ihn hier ein. Vergisst er es,
   haengt der Lauf -- und die Frist macht daraus eine Meldung mit
   Dateinamen statt eines stillen Stillstands. */
const STROEME = new Map([
  ["/workspace/api/chat/strom",
    "haelt die Verbindung offen und schickt neue Nachrichten sofort (SSE)"],
]);

const FRIST_MS = 8000;

/* Jeder Weg, der nicht antwortet, landet hier -- und wird am Ende
   EINMAL gemeldet. Ihn an Ort und Stelle in die jeweilige Liste zu
   werfen waere falsch: In Abschnitt 1 saehe er aus wie "ohne Anmeldung
   erreichbar", in Abschnitt 2 fiele er ganz durch (`"hing" >= 500` ist
   false, weil Zeichenkette gegen Zahl immer false ergibt). Genau so
   verschwinden Befunde. */
const HAENGER = [];

async function ruf(art, pfad, keks) {
  const kopf = { "Content-Type": "application/json", origin: BASIS };
  if (keks) kopf.cookie = keks;
  const rumpf = art === "GET" || art === "DELETE" ? undefined : JSON.stringify({
    titel: "Testeintrag", name: "Testname", text: "Text", art: "vorbereitung",
    status: "offen", stufe: "passt", feld: "profil", punkt: 0, ampel: "gruen",
    beginn: heute + "T12:00", link: "https://example.invalid/x", takt: "woche",
    start: heute, uhrzeit: "10:00", rolle: "creator", ziele: "Ziel",
    nachricht: "Hallo", schluessel: "technik-01", erledigt: true,
  });

  const abbruch = new AbortController();
  const wecker = setTimeout(() => abbruch.abort(), FRIST_MS);
  try {
    const a = await fetch(BASIS + pfad, {
      method: art, headers: kopf, body: rumpf, redirect: "manual", signal: abbruch.signal,
    });
    /* Ein Strom liefert den Status sofort und den Rumpf nie. Der Status
       ist das, worauf es hier ankommt -- also wird er gelesen und die
       Verbindung danach zugemacht. */
    if (STROEME.has(pfad)) {
      abbruch.abort();
      return { status: a.status, text: "(Strom, Rumpf nicht gelesen)" };
    }
    let text = "";
    try { text = await a.text(); } catch { /* egal */ }
    return { status: a.status, text };
  } catch (f) {
    if (f?.name === "AbortError") {
      /* HAENGT. Als eigener Zustand, nicht als 0 und nicht als Absturz:
         Ein Weg, der nicht antwortet, ist etwas anderes als einer, der
         mit einem Fehler antwortet -- und etwas ganz anderes als einer,
         der in Ordnung ist. */
      HAENGER.push(`${art} ${pfad}${keks ? " (angemeldet)" : ""}`);
      return { status: "hing", text: `keine Antwort binnen ${FRIST_MS} ms` };
    }
    HAENGER.push(`${art} ${pfad} — ${String(f?.message || f).slice(0, 60)}`);
    return { status: "fehler", text: String(f?.message || f).slice(0, 80) };
  } finally {
    clearTimeout(wecker);
  }
}

/* =======================================================================
   1. Ohne Anmeldung — die harte Regel
   ======================================================================= */
console.log(`\n=== Ohne Anmeldung darf nichts herauskommen ===`);

/* Die drei begruendeten Ausnahmen. Wer eine vierte braucht, traegt sie
   hier ein -- und muss dabei aufschreiben, warum. */
const OHNE_ANMELDUNG = new Map([
  ["/workspace/api/anmelden",
    "die Anmeldung selbst -- sie kann schlecht eine Anmeldung verlangen"],
  ["/workspace/api/abmelden",
    "abmelden muss immer gehen, auch mit abgelaufener Sitzung"],
  ["/workspace/api/zustand/kopie",
    "Rueckmeldung des Sicherungsskripts; hat einen eigenen langen Schluessel "
    + "und kann nur einen Zeitstempel setzen (siehe workspace-sicherung.js)"],
]);

let ohneGeprueft = 0;
const offen = [];
for (const r of ROUTEN) {
  const pfad = einsetzen(r.pfad, { id: nummerFuer(r.pfad) });
  if (OHNE_ANMELDUNG.has(r.pfad)) continue;
  ohneGeprueft++;
  const { status, text } = await ruf(r.art, pfad, null);
  /* Erlaubt ist: 401 (nicht angemeldet), 403, 404. Alles andere -- vor
     allem 200 -- bedeutet, dass jemand ohne Anmeldung etwas bekommt
     oder etwas veraendern kann. */
  if (![401, 403, 404].includes(status)) {
    offen.push(`${r.art} ${pfad} -> ${status} ${text.slice(0, 60).replace(/\s+/g, " ")} [${r.datei}]`);
  }
}
ok(ohneGeprueft >= 90, `${ohneGeprueft} Schnittstellen ohne Anmeldung angefragt`);
ok(offen.length === 0,
  offen.length
    ? `OHNE ANMELDUNG ERREICHBAR:\n         ` + offen.slice(0, 10).join("\n         ")
    : "keine einzige Schnittstelle antwortet ohne Anmeldung mit Daten");

/* =======================================================================
   2. Mit Anmeldung — nie ein Serverfehler
   ======================================================================= */
console.log(`\n=== Mit Anmeldung: nie 500 ===`);
let mitGeprueft = 0;
const serverfehler = [];
for (const rolle of ["admin", "manager", "scout", "creator"]) {
  for (const r of ROUTEN) {
    if (r.pfad === "/workspace/api/abmelden") continue;   // beendet die Sitzung
    const pfad = einsetzen(r.pfad, { id: nummerFuer(r.pfad) });
    mitGeprueft++;
    const { status, text } = await ruf(r.art, pfad, KEKSE[rolle]);
    if (status >= 500) {
      serverfehler.push(`${rolle}: ${r.art} ${pfad} -> ${status} ${text.slice(0, 60)} [${r.datei}]`);
    }
  }
}
ok(mitGeprueft >= 360, `${mitGeprueft} Aufrufe (${ROUTEN.length} Wege x 4 Rollen)`);
ok(serverfehler.length === 0,
  serverfehler.length
    ? `SERVERFEHLER:\n         ` + serverfehler.slice(0, 12).join("\n         ")
    : "kein Weg antwortet mit 500 oder 503");

/* =======================================================================
   3. Das Geheimwort darf nicht wandern
   ======================================================================= */
console.log(`\n=== Kein Durchsickern interner Angaben ===`);

/* GEHEIM steht in einer internen Admin-Notiz und in einer Lead-Notiz.
   Ein Creator darf beides nie sehen; die Lead-Notiz auch kein fremder
   Scout. Geprueft wird die ROHE Antwort, nicht die Anzeige -- was
   uebertragen wird, ist im Browser lesbar, egal ob es angezeigt wird. */
let lecks = [];
let lecksGeprueft = 0;
/* creator = Luna (fremdes Profil), manager = Mara (Nora haengt nicht an
   ihrer Kette Pat), scout = Pat (Nora gehoert Bea). Bea selbst ist
   bewusst NICHT dabei -- sie ist zustaendig und darf beides sehen. */
for (const rolle of ["creator", "manager", "scout"]) {
  for (const r of ROUTEN.filter((x) => x.art === "GET")) {
    const pfad = einsetzen(r.pfad, { id: nummerFuer(r.pfad) });
    lecksGeprueft++;
    const { status, text } = await ruf("GET", pfad, KEKSE[rolle]);
    if (status === 200 && text.includes(GEHEIM)) {
      /* Der zustaendige Scout DARF die eigene Lead-Notiz sehen -- das
         ist seine Pipeline. Alles andere nicht. */
      /* Der Lead gehoert Bea, und Bea ist hier nicht dabei. Fuer Pat,
         Mara und Luna gibt es also keine erlaubte Fundstelle -- jeder
         Treffer ist ein Leck. */
      lecks.push(`${rolle} sieht das Geheimwort in ${r.art} ${pfad} [${r.datei}]`);
    }
  }
}
ok(lecksGeprueft > 100, `${lecksGeprueft} Leseabfragen auf durchgesickerte Angaben geprueft`);
ok(lecks.length === 0,
  lecks.length ? `DURCHGESICKERT:\n         ` + lecks.slice(0, 8).join("\n         ")
    : "das Geheimwort taucht bei keiner unberechtigten Rolle auf");

/* =======================================================================
   4. Fremde Herkunft (CSRF)
   ======================================================================= */
console.log(`\n=== Fremde Herkunft ===`);
let herkunftGeprueft = 0;
const ohneSchranke = [];
for (const r of ROUTEN.filter((x) => x.art !== "GET")) {
  if (r.pfad === "/workspace/api/anmelden" || r.pfad === "/workspace/api/abmelden") continue;
  if (r.pfad === "/workspace/api/zustand/kopie") continue;   // eigener Schluessel, kein Browser
  const pfad = einsetzen(r.pfad, { id: nummerFuer(r.pfad) });
  herkunftGeprueft++;
  const a = await fetch(BASIS + pfad, {
    method: r.art,
    headers: {
      "Content-Type": "application/json",
      cookie: KEKSE.admin,
      origin: "https://boese.example",
    },
    body: JSON.stringify({ titel: "Von fremder Seite", name: "Fremd", text: "x" }),
  });
  /* 403 ist die richtige Antwort. 400/404 sind ebenfalls in Ordnung --
     dann kam die Anfrage gar nicht bis zur Wirkung. Ein 200/201 waere
     die Luecke. */
  if (a.status === 200 || a.status === 201) {
    ohneSchranke.push(`${r.art} ${pfad} -> ${a.status} [${r.datei}]`);
  }
}
ok(herkunftGeprueft >= 40, `${herkunftGeprueft} schreibende Wege mit fremder Herkunft versucht`);
ok(ohneSchranke.length === 0,
  ohneSchranke.length
    ? `OHNE HERKUNFTSPRUEFUNG:\n         ` + ohneSchranke.slice(0, 10).join("\n         ")
    : "kein schreibender Weg nimmt eine fremde Herkunft an");

/* =======================================================================
   5. Hat irgendein Weg gar nicht geantwortet?
   ======================================================================= */
console.log(`\n=== Antwortet jeder Weg ueberhaupt? ===`);
ok(HAENGER.length === 0,
  HAENGER.length
    ? `${HAENGER.length} Aufrufe blieben ohne Antwort — das ist der Grund, wenn der `
      + `Gesamtlauf stehenbleibt:\n         ` + [...new Set(HAENGER)].slice(0, 8).join("\n         ")
      + `\n         Ist es ein Ereignisstrom, gehoert er in STROEME (oben, mit Begruendung).`
    : `alle Aufrufe kamen binnen ${FRIST_MS} ms zurueck`);

/* Und die Sonderbehandlung selbst muss stimmen: Ein Strom, der auf
   einmal doch einen fertigen Rumpf liefert, ist keiner mehr -- dann
   gehoert er aus der Liste heraus, sonst wird sein Inhalt nie geprueft.
   Und ein Weg, den ich faelschlich als Strom eintrage, verlaere still
   seine Inhaltspruefung. Deshalb wird beides nachgemessen. */
{
  let belegt = 0;
  for (const [pfad, grund] of STROEME) {
    const bekannt = ROUTEN.some((r) => r.pfad === pfad);
    if (!bekannt) {
      ok(false, `${pfad} steht in STROEME, ist aber gar keine Route mehr — Eintrag entfernen`);
      continue;
    }
    /* Der Strom muss WIRKLICH offen bleiben. Wenn er von selbst endet,
       ist die Ausnahme unnoetig und verdeckt nur seinen Inhalt. */
    const abbruch = new AbortController();
    const wecker = setTimeout(() => abbruch.abort(), 2500);
    let endeteVonSelbst = false;
    let status = null;
    try {
      const a = await fetch(BASIS + pfad, {
        headers: { cookie: KEKSE.admin }, signal: abbruch.signal,
      });
      status = a.status;
      await a.text();
      endeteVonSelbst = true;
    } catch { /* abgebrochen = er blieb offen, wie es sein soll */ }
    clearTimeout(wecker);
    belegt++;
    ok(status === 200 && !endeteVonSelbst,
      `${pfad} liefert angemeldet ${status} und bleibt offen — ${grund}`);
  }
  ok(belegt === STROEME.size, `alle ${STROEME.size} eingetragenen Stroeme nachgemessen`);
}

/* =======================================================================
   GEGENPROBE — findet diese Pruefung ueberhaupt etwas?
   ======================================================================= */
console.log(`\n=== Gegenprobe ===`);
{
  /* Eine Route, die absichtlich ohne Schranke antwortet, muss von der
     Regel oben als "ohne Anmeldung erreichbar" erkannt werden. */
  const testRouten = [...ROUTEN, { art: "GET", pfad: "/workspace/api/ich", datei: "workspace.js" }];
  const gefundenOhne = [];
  for (const r of testRouten.slice(0, 3)) {
    const { status } = await ruf(r.art, einsetzen(r.pfad, { id: 1 }), null);
    if (![401, 403, 404].includes(status)) gefundenOhne.push(r.pfad);
  }
  ok(gefundenOhne.length === 0, "die Stichprobe bestaetigt: ohne Anmeldung kommt nichts");

  /* Und der Beweis, dass die Messung "durchgelassen" ueberhaupt sehen
     kann: MIT Anmeldung liefert dieselbe Route Daten. */
  const a = await ruf("GET", "/workspace/api/ich", KEKSE.admin);
  ok(a.status === 200 && a.text.includes("rolle"),
    `mit Anmeldung liefert /api/ich Daten (${a.status}) — die Messung erkennt also den Unterschied`);

  /* Das Geheimwort MUSS bei DogFather ankommen -- sonst pruefte
     Abschnitt 3 nur, dass es nirgends steht. */
  const b = await ruf("GET", `/workspace/api/profil/${idNora}`, KEKSE.admin);
  const c = await ruf("GET", "/workspace/api/leads", KEKSE.admin);
  ok(b.text.includes(GEHEIM) || c.text.includes(GEHEIM),
    "das Geheimwort ist fuer DogFather sichtbar — die Leck-Suche misst also an echtem Inhalt");
}

console.log(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler ? 1 : 0);