dogfather-universe/server/pruef-modi-verborgen.mjs

/* =====================================================================
   DER VERBORGENE MODI-ZUGANG

   Zwei Fragen, und sie sind nicht dieselbe:

     1. KOMMT EIN MODI HEREIN, ohne dass es dafuer eine Kachel gibt?
     2. MERKT SONST JEMAND ETWAS DAVON?

   Die zweite ist die schwierigere. Eine Liste zu filtern ist leicht;
   uebersehen wird die ZAHL daneben, die weiter alles mitzaehlt -- und
   eine Personenzahl, die nicht zur Liste passt, verraet genauso viel
   wie ein Name.

   MIT GEGENPROBE. Ganz unten wird die Regel absichtlich ausgehebelt
   (ein Modi bekommt in der Datenbank eine andere Rolle), und dann MUSS
   der Manager ihn sehen. Ohne diesen Teil waere nicht bewiesen, dass
   die Pruefung ueberhaupt anschlagen kann -- eine Pruefung, die immer
   bestaetigt, bestaetigt nichts.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-modi-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
   Ohne diese Zeile startet der eigene Server bei belegtem Port
   STILL nicht -- und alles Folgende misst gegen einen fremden
   Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
   als kaputt. */
const PORT = await eigenerPort(import.meta, "pruef-modi-verborgen");
process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
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";
import { eigenerPort } from "./helfer-port.mjs";
await import("./index.js");
/* NACH index.js: Der Server haengt dort zwei Auffangnetze ein, die
   einen Absturz nur protokollieren. Fuer den Betrieb richtig, fuer eine
   Pruefung fatal -- ohne diese Zeile bliebe der Prozess ewig stehen. */
notbremse(180_000, "pruef-modi-verborgen");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;

let fehler = 0;
let geprueft = 0;
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
/* Der dritte Ausgang: Konnte nicht nachgesehen werden. Kein Befund,
   aber auch keine Bestaetigung -- und es wird gesagt, damit niemand
   glaubt, hier sei etwas geprueft worden. */
let offen = 0;
const unklar = (t) => { offen++; console.log("  --   " + t); };

/* ---------- Personen anlegen ---------------------------------------- */
const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes, createHmac } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();

/* Der Suchschluessel muss VOR dem Anlegen dastehen -- die Personen
   werden hier von Hand eingetragen, nicht ueber personAnlegen(). */
const schluessel = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", schluessel, jetzt);
const kennung = (code) => createHmac("sha256", schluessel).update(code).digest("hex");

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, code_kennung, aktiv, erstellt)"
    + " VALUES (?,?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, kennung(code), jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}

const idDogi   = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idVan    = anlegen("VanVan", "admin", "CODE-VAN-0001");
const idSpicy  = anlegen("Cigdem", "spicy", "CODE-SPIC-0001");
const idMan    = anlegen("Schulle", "manager", "CODE-MAN-0001");
const idScout  = anlegen("Patrick", "scout", "CODE-SCOU-0001");
const idCreat  = anlegen("Tili", "creator", "CODE-ANNA-0001");
const idModi1  = anlegen("Marina", "modi", "CODE-MODI-0001");
const idModi2  = anlegen("Kim", "modi", "CODE-MODI-0002");
/* DIE STELLVERTRETUNG GEHOERT IN DIESELBE PRUEFUNG (10.09.2026).

   Sie ist seit heute die zweite verborgene Rolle. Ohne diese Zeile
   waere der ganze Lauf weiter gruen gewesen -- und haette die neue
   Rolle kein einziges Mal angesehen. Genau die Sorte gruener Haken,
   vor der die Hausregeln warnen: Er bestaetigt etwas, das er nicht
   geprueft hat.

   Sie wird bewusst in dieselben Listen aufgenommen wie die Modis, statt
   danebenzustehen: Was fuer einen Modi gilt, gilt fuer sie -- und wenn
   morgen jemand einen Weg hinzufuegt, deckt er beide ab, ohne dass es
   ihm jemand sagen muss. */
const idHand   = anlegen("Rieke", "hand", "CODE-HAND-0001");
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
  .run(idCreat, idScout, jetzt);
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)")
  .run(idScout, idMan, jetzt);
d.close();

const MODIS = [idModi1, idModi2, idHand];
void idSpicy;

/* ---------- Anmelden ueber die Schnittstelle -------------------------

   MIT WAND, SEIT DEM 01.10.2026. Vorher ging jede Anmeldung hier ueber
   `fetch` auf 127.0.0.1 -- eine Adresse OHNE Wand. Gemessen wurde
   damit der stille Zugang und nicht die Kachelregel; seit er weg ist,
   waere das die Messung der falschen Sache.

   WARUM node:http UND NICHT fetch: `fetch` (undici) setzt den
   Host-Kopf selbst aus der Adresse und ignoriert einen mitgegebenen.
   Nachgemessen, nicht vermutet -- dieselbe Stelle steht seit dem
   22.09. in pruef-chat-kanaele. */
const { request: httpAnfrage } = await import("node:http");
const CREW_WAND = "crew.dogfather-universe.com";
const AGENTUR_WAND = "workspace.dogfather-universe.com";

/** Auf welcher Wand steht die Kachel dieser Rolle?
 *
 *  ABGELEITET STATT AUFGEZAEHLT (01.10.2026). Nach dem Umbau meldeten
 *  sich acht Stellen ueber eine fremde Kachel an -- ein Manager auf
 *  der Crew-Wand etwa, wo es seine Kachel gar nicht gibt. Eine Liste
 *  von Hand waere die, bei der man zwei Stellen vergisst.
 *
 *  Wer eine Wand AUSDRUECKLICH nennt, bekommt sie: Das brauchen die
 *  Zeilen, die absichtlich die falsche Wand pruefen. */
const CREW_ROLLEN = new Set(["admin", "hand", "linke", "modi", "gast"]);
const wandFuer = (rolle) => (CREW_ROLLEN.has(rolle) ? CREW_WAND : AGENTUR_WAND);

function anmelden(rolle, code, wand = wandFuer(rolle)) {
  return new Promise((fertig) => {
    const rumpf = JSON.stringify({ rolle, code });
    const a = httpAnfrage({
      host: "127.0.0.1", port: PORT, path: "/workspace/api/anmelden", method: "POST",
      headers: {
        "Content-Type": "application/json",
        "Content-Length": Buffer.byteLength(rumpf),
        Host: wand,
      },
    }, (antwort) => {
      const teile = [];
      antwort.on("data", (t) => teile.push(t));
      antwort.on("end", () => {
        let daten = {};
        try { daten = JSON.parse(Buffer.concat(teile).toString("utf8")); } catch { /* kein JSON */ }
        fertig({
          status: antwort.statusCode,
          daten,
          keks: [].concat(antwort.headers["set-cookie"] || [])
            .map((z) => z.split(";")[0]).join("; "),
        });
      });
    });
    a.on("error", () => fertig({ status: 0, daten: {}, keks: "" }));
    a.end(rumpf);
  });
}

/* =====================================================================
   1. DIE KACHEL IST BINDEND (01.10.2026)

   Filipe: „mach das. es soll fest sein."

   VanVan hatte gemeldet: „Man kann sich mit seinem Zugangscode immer
   noch über jeden Button der Startseite anmelden, egal welche Rolle
   man hat."

   BIS HEUTE STAND HIER DAS GEGENTEIL, und das war richtig: Vom
   09.09.2026 an hatten die Modis KEINE eigene Kachel -- wer keine
   hat, muss irgendeine nehmen koennen.

   Seit der Haustrennung am 24.09. hat `crew.` einen eigenen
   Kachelsatz mit allen fuenf Rollen. Das Verbergen leistet die
   ADRESSE; der Trick mit der beliebigen Kachel war ein Rest.
   ===================================================================== */
console.log("\n=== 1. Der Eingang: die Kachel gilt ===\n");

{
  const a = await anmelden("modi", "CODE-MODI-0001");
  ok(a.status === 200 && a.daten?.rolle === "modi",
    `auf der Modi-Kachel kommt ein Modi herein (${a.daten?.rolle || a.status})`);
}

/* UND AUF KEINER ANDEREN. Das ist die Aenderung. */
for (const kachel of ["admin", "hand", "linke", "gast"]) {
  const a = await anmelden(kachel, "CODE-MODI-0001");
  ok(a.status === 401,
    `Kachel "${kachel}" + Modi-Code -> abgewiesen (${a.status})`);
}

/* GEGENPROBE: Die anderen Rollen der Crew-Wand kommen auf IHRER
   Kachel herein. Ohne sie hiesse „401 ueberall" womoeglich nur, dass
   dort gar niemand mehr hereinkommt. */
{
  const h = await anmelden("hand", "CODE-HAND-0001");
  ok(h.status === 200 && h.daten?.rolle === "hand",
    `die rechte Hand auf ihrer Kachel (${h.daten?.rolle || h.status})`);
}

/* UND DIE AGENTURWAND BLEIBT, WIE SIE WAR. Dort war der stille Weg
   nie aktiv; ein Modi-Code verhaelt sich weiter wie ein erfundener. */
{
  const a = await anmelden("creator", "CODE-MODI-0001", AGENTUR_WAND);
  const b = await anmelden("creator", "GIBT-ES-NICHT-1", AGENTUR_WAND);
  ok(a.status === 401 && b.status === 401
    && JSON.stringify(a.daten) === JSON.stringify(b.daten),
    `auf der Agenturwand klingt ein Modi-Code wie ein erfundener `
    + `(${a.status} vs. ${b.status})`);
}

/* Und die Rollenpruefung der Agentur ist unveraendert: Ein Manager
   mit der Kachel "creator" scheitert weiterhin. */
{
  const a = await anmelden("creator", "CODE-MAN-0001", AGENTUR_WAND);
  ok(a.status === 401, `Manager-Code auf der Creator-Kachel bleibt abgewiesen (${a.status})`);
}

/* Wortgleichheit: "modi" von aussen anzugeben darf nicht anders klingen
   als eine erfundene Rolle. */
{
  /* AUF DER AGENTURWAND klingt „modi" wie eine erfundene Rolle --
     dort gibt es die Kachel nicht. Auf crew. gibt es sie, und dort
     entscheidet der Code; deshalb wird das hier ausdruecklich an der
     Agenturwand gefragt. */
  const m = await anmelden("modi", "FALSCH-FALSCH-1", AGENTUR_WAND);
  const x = await anmelden("gibtesnicht", "FALSCH-FALSCH-1", AGENTUR_WAND);
  ok(m.status === 401 && x.status === 401
    && JSON.stringify(m.daten) === JSON.stringify(x.daten),
    "Rolle \"modi\" von aussen klingt wie eine erfundene "
    + `(${m.status} ${JSON.stringify(m.daten)} vs. ${x.status} ${JSON.stringify(x.daten)})`);
}

{
  const a = await anmelden("modi", "CODE-MODI-FALSCH");
  ok(a.status === 401, `ein falscher Modi-Code wird abgewiesen (${a.status})`);
}

/* ---------- 2. Die Unsichtbarkeit ------------------------------------ */
console.log("\n=== 2. Wer sieht die Modis? ===\n");

/* Jede Schnittstelle, die Personen ausgibt. Dieselbe Landkarte wie in
   pruef-verborgen.mjs -- wer eine neue baut, traegt sie in BEIDE ein. */
const WEGE = [
  ["Chat-Partner",       "/workspace/api/chat/partner",        (x) => x.personen],
  ["Personenwahl",       "/workspace/api/personen",            (x) => x.personen],
  ["Personenverwaltung", "/workspace/api/verwaltung/personen", (x) => x.personen],
  ["Betreuer-Auswahl",   "/workspace/api/verwaltung/personen", (x) => x.betreuer],
  /* NACHGESEHEN, NICHT ANGENOMMEN: Die Segmente der Zentrale tragen
     KEINE Nummer -- nur `{ name, rolle, stufe, heute, alt }`, und der
     Name ist auf den Vornamen gekuerzt. Wer hier nur nach `id` sucht,
     bekommt einen gruenen Haken, ohne etwas angesehen zu haben. Genau
     deshalb vergleicht der Treffer unten BEIDES. */
  ["Zentrale (Team)",    "/workspace/api/zentrale",            (x) => x.segmente],
];

/* Die Namen der Modis -- fuer die Wege, die keine Nummern liefern. */
const MODI_NAMEN = ["Marina", "Kim", "Rieke"];

const LEUTE = [
  ["DogFather",   "admin",   "CODE-DOGI-0001", true],
  ["VanVan",      "admin",   "CODE-VAN-0001",  true],
  ["Spicy Media", "spicy",   "CODE-SPIC-0001", false],
  ["Manager",     "manager", "CODE-MAN-0001",  false],
  ["Scout",       "scout",   "CODE-SCOU-0001", false],
  ["Creator",     "creator", "CODE-ANNA-0001", false],
  /* AUF IHRER EIGENEN KACHEL (01.10.2026). Hier stand „creator" --
     der stille Zugang liess damals jede Kachel durch. Seit die Kachel
     bindend ist, scheiterte ihre Anmeldung STILL: `unklar(...)` und
     weiter, und acht Sichtbarkeitspruefungen fielen lautlos weg.

     Genau der Rueckgang, vor dem die Hausregel warnt -- gruen bei
     weniger Pruefungen. Gefunden hat ihn nicht der Lauf, sondern der
     Vergleich der Anzahl mit dem Lauf davor. */
  ["Modi Marina", "modi", "CODE-MODI-0001", true],
  ["Rechte Hand", "hand", "CODE-HAND-0001", true],
];

async function hole(keks, pfad) {
  const a = await fetch(BASIS + pfad, { headers: { cookie: keks } });
  if (!a.ok) return { status: a.status, daten: null };
  return { status: 200, daten: await a.json().catch(() => null) };
}

for (const [name, kachel, code, darf] of LEUTE) {
  const an = await anmelden(kachel, code);
  if (an.status !== 200) { unklar(`${name}: Anmeldung misslang (${an.status})`); continue; }
  for (const [was, pfad, ziehen] of WEGE) {
    const { status, daten } = await hole(an.keks, pfad);
    if (status !== 200) {
      unklar(`${name.padEnd(12)} ${was.padEnd(20)} kein Zugriff (${status})`);
      continue;
    }
    let liste = [];
    try { liste = ziehen(daten) || []; } catch { liste = []; }
    const drin = liste.filter((z) => z
      && (MODIS.includes(z.id ?? z.person_id)
        || MODI_NAMEN.includes(String(z.name || "").trim().split(/\s+/)[0])));
    if (darf) {
      ok(true, `${name.padEnd(12)} ${was.padEnd(20)} sieht ${drin.length} Modi(s)`);
    } else {
      ok(drin.length === 0,
        `${name.padEnd(12)} ${was.padEnd(20)} `
        + (drin.length ? `SIEHT ${drin.length} MODI -- FEHLER` : "sieht keinen Modi"));
    }
  }
}

/* ---------- 3. Die Zahl daneben -------------------------------------- */
console.log("\n=== 3. Auch die ZAHL darf sie nicht mitzaehlen ===\n");
{
  const an = await anmelden("manager", "CODE-MAN-0001");
  const { status, daten } = await hole(an.keks, "/workspace/api/personen");
  if (status !== 200 || !Array.isArray(daten?.personen)) {
    unklar(`Personenwahl fuer den Manager nicht lesbar (${status})`);
  } else {
    const namen = daten.personen.map((z) => z.name);
    /* Die Zahl der geprueften Dinge gehoert in die BEDINGUNG, nicht nur
       in den Meldetext: Eine leere Liste wuerde sonst als "keine Modis
       drin" durchgehen, und die Pruefung waere wertlos. */
    ok(namen.length > 0 && !namen.includes("Marina") && !namen.includes("Kim"),
      `der Manager sieht ${namen.length} Personen, keine davon ein Modi `
      + `(${namen.join(", ")})`);
  }
}

/* ---------- 4. Sehen die Modis einander? ----------------------------- */
console.log("\n=== 4. Die Modis sind untereinander ein Team ===\n");
{
  const an = await anmelden("modi", "CODE-MODI-0001");
  const { status, daten } = await hole(an.keks, "/workspace/api/personen");
  if (status !== 200 || !Array.isArray(daten?.personen)) {
    unklar(`Personenwahl fuer den Modi nicht lesbar (${status})`);
  } else {
    const ids = daten.personen.map((z) => z.id);
    ok(ids.includes(idModi2), "Marina sieht Kim");
    ok(ids.includes(idDogi), "Marina sieht DogFather");
    /* VanVan bleibt fuer alle ausser DogFather verborgen -- das ist die
       Regel vom 09.09.2026, und sie gilt auch gegenueber Modis. */
    ok(!ids.includes(idVan), "Marina sieht VanVan NICHT (verborgener Zugang)");
    ok(!ids.includes(idMan) && !ids.includes(idScout) && !ids.includes(idCreat),
      "Marina sieht weder Manager noch Scout noch Creator");
  }
}

/* ---------- 5. Der echte Weg durch die Anwendung --------------------- */
console.log("\n=== 5. Anlegen wie im Betrieb: DogFather legt einen Modi an ===\n");
{
  const an = await anmelden("admin", "CODE-DOGI-0001");
  const kopf = { "Content-Type": "application/json", cookie: an.keks };

  /* a) Steht die Rolle ueberhaupt zur Auswahl -- und kommt sie vom
        Server, nicht aus einer Datei im Browser? */
  const { status, daten } = await hole(an.keks, "/workspace/api/verwaltung/personen");
  if (status !== 200) {
    unklar(`Verwaltung fuer DogFather nicht lesbar (${status})`);
  } else {
    const zusatz = daten?.zusatzrollen || [];
    ok(zusatz.some((z) => z.wert === "modi"),
      "DogFather bekommt die Rolle zur Auswahl angeboten "
      + `(${zusatz.map((z) => z.wert).join(", ") || "keine"})`);
  }

  /* b) Anlegen -- ueber genau den Weg, den die Oberflaeche benutzt. */
  const a = await fetch(BASIS + "/workspace/api/verwaltung/personen", {
    method: "POST", headers: kopf,
    body: JSON.stringify({ name: "Testmodi Neu", rolle: "modi" }),
  });
  const neuDaten = await a.json().catch(() => ({}));
  ok(a.status === 201 && neuDaten?.rolle === "modi" && typeof neuDaten?.code === "string",
    `angelegt (${a.status}, Rolle ${neuDaten?.rolle}, `
    + `Code ${neuDaten?.code ? "erhalten" : "FEHLT"})`);

  /* c) DER EIGENTLICHE PUNKT: Kommt der so angelegte Modi auch herein?

        Die Abschnitte oben haben die Personen VON HAND eingetragen und
        den Suchschluessel selbst ausgerechnet. Damit ist nicht bewiesen,
        dass personAnlegen() ihn im Betrieb auch wirklich schreibt -- und
        ohne ihn findet der stille Zugang niemanden. Waere die Zeile dort
        vergessen worden, waeren oben trotzdem alle Haken gruen und kein
        einziger echter Modi kaeme herein. */
  if (neuDaten?.code) {
    /* AUF DER MODI-KACHEL, seit dem 01.10.2026 -- vorher ging jede. */
    const b = await anmelden("modi", neuDaten.code);
    ok(b.status === 200 && b.daten?.rolle === "modi",
      "und meldet sich mit seinem Code an, ueber eine fremde Kachel "
      + `(${b.status}, ${b.daten?.rolle})`);
  } else {
    unklar("ohne Code laesst sich die Anmeldung nicht pruefen");
  }

  /* d) Und ist auch der Neue fuer den Manager unsichtbar? */
  const m = await anmelden("manager", "CODE-MAN-0001");
  const sicht = await hole(m.keks, "/workspace/api/personen");
  if (sicht.status !== 200 || !Array.isArray(sicht.daten?.personen)) {
    unklar(`Personenwahl fuer den Manager nicht lesbar (${sicht.status})`);
  } else {
    const namen = sicht.daten.personen.map((z) => z.name);
    ok(namen.length > 0 && !namen.includes("Testmodi Neu"),
      `der Manager sieht ihn nicht (${namen.length} Personen: ${namen.join(", ")})`);
  }
}
/* ---------- 6. Die Startseite eines Modis ---------------------------- */
console.log("\n=== 6. Was ein Modi auf seiner Startseite sieht ===\n");
{
  /* AUF SEINER EIGENEN KACHEL, seit dem 01.10.2026. Hier stand
     „creator" -- damals gab es fuer einen Modi keine eigene, und der
     stille Zugang liess jede durch. Jetzt gilt die Kachel. */
  const an = await anmelden("modi", "CODE-MODI-0001");
  const { status, daten } = await hole(an.keks, "/workspace/api/ich");
  if (status !== 200) {
    unklar(`/api/ich nicht lesbar (${status})`);
  } else {
    const b = daten?.bereiche;
    ok(Array.isArray(b) && b.length > 0,
      `der Server schickt ihm ${Array.isArray(b) ? b.length : "keine"} Kacheln`);
    /* Nichts aus der Agentur. Nicht "moeglichst wenig", sondern keine
       einzige -- diese Seiten drehen sich um betreute Creator, um
       Rechte oder um Automationen. */
    /* `calls.html` STAND HIER UND IST AM 25.09.2026 HERAUSGENOMMEN.

       Nicht, weil die Pruefung zu streng war, sondern weil sich die
       Sache geaendert hat: Filipe hat die Calls-Kachel ausdruecklich
       fuer alle verlangt, die einen Kalender haben („jeder der einen
       kalender hat soll auch sowas haben danke"), und ein Modi hat
       einen. Seither war diese Zeile rot, ohne dass etwas kaputt war
       -- und eine Warnung, die immer kommt, wird ueberlesen.

       DIE LISTE BLEIBT EINE LISTE VON HAND, und das ist ihre Schwaeche:
       Sie altert genau so wie diese Zeile gealtert ist. Deshalb steht
       darunter eine Gegenprobe -- ohne sie waere „nichts Verbotenes
       dabei" auch dann gruen, wenn die Pruefung gar nichts mehr
       prueft. */
    const verboten = ["personen.html", "scouting.html", "automation.html",
      "report.html", "uebersicht.html", "content.html"];
    const ziele = (b || []).map((x) => x.ziel);
    const drin = ziele.filter((z) => verboten.includes(z));
    ok(Array.isArray(b) && verboten.length >= 6 && drin.length === 0,
      drin.length ? `ABER AUCH: ${drin.join(", ")} -- FEHLER`
        : `und nichts aus der Agentur (${verboten.length} Seiten geprueft)`);
    /* GEGENPROBE: Haette er eine davon, MUSS die Zeile darueber
       anschlagen. Gepruft wird an einer erfundenen Liste, nicht an
       echten Daten -- es wird nichts angelegt und nichts veraendert. */
    const alsHaette = [...ziele, "scouting.html"].filter((z) => verboten.includes(z));
    ok(alsHaette.length === 1,
      `und sie wuerde es merken, wenn doch (Probe: ${alsHaette.join(", ") || "merkt nichts"})`);
    /* Die Beschriftung gehoert zum Empfaenger: "Alle Creator auf einen
       Blick" waere fuer jemanden ohne Creator schlicht falsch. */
    ok((b || []).every((x) => x.name && x.unter && x.zeichen && x.ziel),
      "jede Kachel hat Beschriftung, Zeichen und Ziel");
  }

  /* GEGENPROBE ZUR QUELLE: Fuer eine bekannte Rolle muss `null`
     herauskommen -- nicht eine leere Liste. Die Oberflaeche
     unterscheidet die beiden, und verwechselte man sie, haetten alle
     anderen ab sofort eine leere Startseite. */
  const m = await anmelden("manager", "CODE-MAN-0001");
  const mi = await hole(m.keks, "/workspace/api/ich");
  ok(mi.status === 200 && mi.daten?.bereiche === null,
    `beim Manager steht dort null, nicht [] (${JSON.stringify(mi.daten?.bereiche)})`);
}

/* ---------- 7. Und im echten Browser? -------------------------------- */
console.log("\n=== 7. Dieselbe Seite mit einem echten Browser ===\n");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  try {
    /* MIT FINGER. Ohne `hasTouch` meldet der Browser einen feinen
     Zeiger, und keine Regel aus `@media (pointer: coarse)` greift --
     dort stehen die 44-Pixel-Beruehrziele. Siehe pruef-fingermass.mjs. */
    const kontext = await browser.newContext({ viewport: { width: 390, height: 844 },
      hasTouch: true, isMobile: true });
    const seite = await kontext.newPage();
    const konsole = [];
    seite.on("console", (e) => { if (e.type() === "error") konsole.push(e.text()); });
    seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));

    /* ==== ANGEMELDET WIRD UEBER DIE WAND, NICHT UEBER DIE SEITE
       (01.10.2026)

       Hier wurde bis heute im Browser auf die Creator-Kachel getippt
       und der Modi-Code eingegeben -- das ging, solange der stille
       Zugang jede Kachel durchliess.

       Seit die Kachel bindend ist, braeuchte der Browser die
       CREW-Wand: Dort steht die Modi-Kachel. Ein Browser auf
       127.0.0.1 bekommt aber die Agenturwand, und ein Host-Kopf
       laesst sich dort nur mit einer Namensumleitung setzen (so macht
       es mess-reaktion mit `--host-resolver-rules`).

       Der kuerzere und ehrlichere Weg: an der richtigen Wand
       anmelden und den Keks mitgeben. Gemessen werden soll, was ein
       Modi auf seiner STARTSEITE sieht -- nicht, wie er hereinkommt.
       Das steht in Abschnitt 1, und dort wird es an der echten Wand
       gemessen. */
    const modiKeks = (await anmelden("modi", "CODE-MODI-0001")).keks;
    await kontext.addCookies(modiKeks.split("; ").filter(Boolean).map((z) => {
      const [n, ...r] = z.split("=");
      return { name: n, value: r.join("="), domain: "127.0.0.1", path: "/" };
    }));
    await seite.goto(BASIS + "/workspace/start.html", { waitUntil: "domcontentloaded" });
    /* KEIN `waitForURL` MEHR. Es wartete auf eine Navigation, die es
       seit dem 01.10.2026 nicht mehr gibt -- angemeldet wird ueber
       die Wand, nicht ueber das Formular. Steht die Seite schon da,
       wartet es trotzdem und laeuft in die Frist.

       Und wenn der Keks NICHT angenommen wurde, sagt die Zeile
       darunter genau das, statt fuenfzehn Sekunden zu schweigen. */
    if (!/start\.html/.test(seite.url())) {
      unklar(`nach dem Anmelden steht die Seite auf ${seite.url()}`);
    }
    await seite.waitForTimeout(1200);

    const bild = await seite.evaluate(() => ({
      kacheln: [...document.querySelectorAll(".gruppe a[href]")].map((a) => a.getAttribute("href")),
      gruppen: [...document.querySelectorAll(".gruppe__kopf")].map((k) => k.textContent.trim().slice(0, 40)),
      rolle: (document.getElementById("zgruss-rolle") || {}).textContent || "",
      rollentext: (document.getElementById("rollentext") || {}).textContent || "",
      marke: (document.querySelector(".zmarke") || {}).textContent || "",
      rauten: document.querySelectorAll(".zmarke .zraute").length,
    }));

    /* Die ZAHL gehoert in die Bedingung, nicht nur in den Text: Eine
       leere Seite wuerde sonst als "nichts Verbotenes dabei" durchgehen. */
    ok(bild.kacheln.length >= 8,
      `${bild.kacheln.length} Kacheln stehen wirklich auf der Seite (${bild.gruppen.join(" | ")})`);
    ok(bild.kacheln.some((h) => h.startsWith("aufgaben.html")),
      "darunter das Aufgabenbrett -- das Herzstueck aus Kapitel 6");
    ok(!bild.kacheln.some((h) => /personen|scouting|automation|report/.test(h)),
      "und nichts aus der Agentur");
    /* Der Anzeigename kommt aus /api/ich, nicht aus einer Datei im
       Browser -- sonst stuende das Wort in einer Datei, die jeder
       bekommt. Dass er hier steht, ist der Nachweis, dass der Weg geht. */
    ok(bild.rolle.trim() === "MODI",
      `die Plakette sagt "${bild.rolle.trim()}" (kommt vom Server)`);
    /* EIN SATZ, KEIN WORT. Die fuenf bekannten Rollen bekommen unter
       der Begruessung eine Erklaerung ("Creator · dein eigener
       Bereich"). Stuende dort nur "Modi", saehe die Seite nicht
       verborgen aus, sondern unfertig -- und genau das stand da, bis
       diese Pruefung es gemeldet hat. */
    ok(bild.rollentext.includes("·") && bild.rollentext.trim().length > 12,
      `und die Zeile darunter ist ein ganzer Satz ("${bild.rollentext.trim()}")`);
    /* DIE MARKE UEBER DEM TITEL. Ein Modi gehoert nicht zur Agentur --
       stand dort "Spicy Media", war die Seite fuer ihn schlicht falsch
       beschriftet. Gefunden auf dem Bildschirmfoto, nicht im Code. */
    ok(bild.marke.includes("Team Dogi") && !bild.marke.includes("Spicy"),
      `die Zierzeile nennt seinen Betrieb ("${bild.marke.trim()}")`);
    /* Und die beiden Zierrauten sind noch da: Sie beim Austausch des
       Textes zu verlieren waere lautlos passiert. */
    ok(bild.rauten === 2, `die beiden Zierrauten stehen noch (${bild.rauten})`);
    ok(konsole.length === 0,
      konsole.length ? `Fehler in der Konsole: ${konsole[0]}` : "keine Fehler in der Konsole");

    await seite.screenshot({ path: "pruef-modi-start.png", fullPage: true });
    console.log("  --   Bildschirmfoto: server/pruef-modi-start.png");

    /* ==== DER CREATOR-KATALOG GEHOERT IHM NICHT (25.09.2026) ========

       Filipe, zu einem Bildschirmfoto der Aufgabenseite: „es gibt
       keine creator auf dieser seite. die app ist nur fuer modis und
       community also steht das falsch da."

       Dort stand ein Katalog mit vier Bereichen und vier Stufen -- der
       fuer CREATOR -- und darunter „Waehle oben einen Creator, dann
       lassen sich diese Aufgaben uebernehmen". Auf dieser Adresse gibt
       es keine; der Satz forderte zu etwas auf, das nie geht.

       GEPRUEFT WIRD DER KASTEN UND DER SATZ, nicht nur einer von
       beiden: Verschwindet der Satz und der leere Kasten bleibt, ist
       es dieselbe Sackgasse in leise. */
    await seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
    await seite.waitForTimeout(1200);
    const katalog = await seite.evaluate(() => {
      const kasten = document.getElementById("vorlagenbrett");
      return {
        daUeberhaupt: !!kasten,
        sichtbar: !!(kasten && !kasten.hidden && kasten.offsetHeight > 0),
        text: (document.body.textContent || "").includes("Wähle oben einen Creator"),
        /* GEGENPROBE IM SELBEN ZUG: Sein EIGENES Aufgabenbrett muss da
           sein. Waere die ganze Seite leer, meldeten die zwei Zeilen
           darueber brav "nichts Fremdes zu sehen". */
        eigenes: !!document.querySelector("#brett, .spalten, .aufgabe, #aufgaben"),
      };
    });
    ok(katalog.daUeberhaupt,
      "der Kasten fuer den Katalog steht im Bauplan der Seite (Gegenprobe)");
    ok(!katalog.sichtbar,
      `der Creator-Katalog wird ihm NICHT gezeigt (sichtbar: ${katalog.sichtbar})`);
    ok(!katalog.text,
      "und der Satz „Waehle oben einen Creator“ steht nirgends");
    ok(katalog.eigenes,
      "sein eigenes Aufgabenbrett ist trotzdem da (Gegenprobe)");

    await kontext.close();
  } finally {
    await browser.close();
  }
}
/* ---------- 8. Was einem Modi GEHOERT, sieht sonst niemand ----------- */
console.log("\n=== 8. Aufgaben, Einträge und Dateien eines Modis ===\n");
{
  /* DREI TABELLEN, DREI EIGENE SICHTBARKEITSREGELN. Fuer Personen ist
     die Regel zentral (verborgeneIds); fuer ZEILEN gibt es sie dreimal
     -- in workspace-aufgaben.js, workspace-bereiche.js und
     workspace-dateien.js. Alle drei geben Spicy Media "alles ausser dem,
     was DogFather gehoert" -- und ein Modi-Eintrag gehoert ihm nicht.

     Der Kalender ist bewusst nicht dabei: termineSichtbar() gibt jedem
     nur Eigenes, dort kann nichts durchsickern. Nachgesehen, nicht
     angenommen. */
  const an = await anmelden("modi", "CODE-MODI-0001");
  const MERKMAL = "GEHEIMER MODI-EINTRAG";

  /* (a) Eine Aufgabe -- ueber den normalen Weg. */
  const t1 = await fetch(BASIS + "/workspace/api/aufgaben", {
    method: "POST", headers: { "Content-Type": "application/json", cookie: an.keks },
    body: JSON.stringify({ titel: MERKMAL + " Aufgabe" }),
  });
  /* ==== UMGEDREHT -- UND STRENGER (25.09.2026) ====================

     Hier stand `status === 201`: „der Modi legt eine Aufgabe an". Das
     war bis zum 22.09.2026 richtig. An dem Tag hat Filipe es
     abgeschafft: „sie sich nicht selber aufgaben geben" und „die modis
     sollen nur diese aufgaben wo sie von den drauf markiert werden
     annehmen koennen". Seither antwortet der Server mit 403 -- und
     diese Zeile war seitdem rot, ohne dass etwas kaputt war.

     SIE PRUEFT JETZT MEHR ALS VORHER, nicht weniger: nicht nur die
     Nummer, sondern auch das WORT. Eine 403 aus einem anderen Grund
     (etwa weil die Anmeldung kaputt ist) saehe sonst genauso aus wie
     die gewollte Absage -- und die Pruefung waere gruen ueber einem
     ganz anderen Fehler.

     WARUM DAS WORT ZAEHLT: `nur_leitung_legt_an` hat in meldung.js
     einen ganzen Satz („Aufgaben werden dir zugeteilt -- anlegen
     kannst du hier keine"). Eine nackte 403 haette ihn nicht. */
  const t1Fehler = (await t1.json().catch(() => ({})))?.fehler;
  ok(t1.status === 403 && t1Fehler === "nur_leitung_legt_an",
    `der Modi legt KEINE Aufgabe an -- mit Begruendung (${t1.status} ${t1Fehler || "ohne Wort"})`);

  /* (b) Ein Bereichs-Eintrag -- ebenfalls ueber den normalen Weg. */
  const t2 = await fetch(BASIS + "/workspace/api/bereich/live", {
    method: "POST", headers: { "Content-Type": "application/json", cookie: an.keks },
    body: JSON.stringify({ art: "vorbereitung", titel: MERKMAL + " Eintrag", text: "nur für das Team" }),
  });
  const t2daten = await t2.json().catch(() => ({}));
  if (t2.status !== 201 && t2.status !== 200) {
    unklar(`kein Bereichs-Eintrag moeglich (${t2.status}: ${JSON.stringify(t2daten)})`);
  } else {
    ok(true, `und einen Bereichs-Eintrag (${t2.status})`);
  }

  /* (c) Eine Datei -- direkt in die Tabelle. Der normale Weg braeuchte
     einen echten Datei-Upload; hier geht es nicht um das Hochladen,
     sondern allein um die Frage, WER die Zeile danach sieht. */
  {
    const dd = new DatabaseSync(process.env.WORKSPACE_DB);
    dd.prepare(`INSERT INTO dateien
        (name_original, name_datei, groesse, typ, status, creator_id, hochgeladen_von, erstellt)
        VALUES (?,?,?,?,'entwurf',NULL,?,?)`)
      .run(MERKMAL + " Datei", "modi-probe.txt", 12, "text/plain", idModi1, jetzt);
    dd.close();
    ok(true, "und eine Datei liegt auf seinen Namen");
  }

  const WEGE2 = [
    ["Aufgaben", "/workspace/api/aufgaben", (x) => x.aufgaben],
    ["Einträge", "/workspace/api/bereich/live", (x) => x.eintraege || x.liste],
    ["Dateien", "/workspace/api/dateien", (x) => x.dateien],
  ];
  for (const [name, kachel, code, darf] of [
    ["DogFather", "admin", "CODE-DOGI-0001", true],
    ["Spicy Media", "spicy", "CODE-SPIC-0001", false],
    ["Manager", "manager", "CODE-MAN-0001", false],
    ["Scout", "scout", "CODE-SCOU-0001", false],
    ["Creator", "creator", "CODE-ANNA-0001", false],
  ]) {
    const w = await anmelden(kachel, code);
    for (const [was, pfad, ziehen] of WEGE2) {
      const r = await hole(w.keks, pfad);
      if (r.status !== 200) { unklar(`${name.padEnd(12)} ${was.padEnd(9)} kein Zugriff (${r.status})`); continue; }
      let liste = [];
      try { liste = ziehen(r.daten) || []; } catch { liste = []; }
      const drin = liste.some((z) =>
        String(z.titel || z.name_original || z.name || "").includes(MERKMAL));
      if (darf) ok(true, `${name.padEnd(12)} ${was.padEnd(9)} sieht es (${drin ? "ja" : "nein"})`);
      else ok(!drin, `${name.padEnd(12)} ${was.padEnd(9)} `
        + (drin ? "SIEHT ES -- LECK" : "sieht es nicht"));
    }
  }
}

/* ---------- 9. Die Gegenprobe ----------------------------------------
   Sie steht ABSICHTLICH GANZ UNTEN: Sie haengt eine Person
   absichtlich aus der Regel aus. Lief sie weiter oben, tauchte
   diese Person in jeder Liste DANACH auf -- und jeder spaetere
   Abschnitt maesse einen Zustand, den es im Betrieb nicht gibt.
   -------------------------------------------------------------------- */
console.log("\n=== 9. Gegenprobe: kann diese Pruefung ueberhaupt anschlagen? ===\n");
{
  const d2 = new DatabaseSync(process.env.WORKSPACE_DB);
  d2.prepare("UPDATE personen SET rolle = 'creator' WHERE id = ?").run(idModi1);
  /* Betreuung dazu, sonst waere der Creator fuer den Manager auch ohne
     die Verbergen-Regel unsichtbar -- und die Gegenprobe pruefte nichts. */
  d2.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
    .run(idModi1, idScout, jetzt);
  d2.close();

  const an = await anmelden("manager", "CODE-MAN-0001");
  const { status, daten } = await hole(an.keks, "/workspace/api/personen");
  if (status !== 200 || !Array.isArray(daten?.personen)) {
    unklar(`Gegenprobe nicht durchfuehrbar (${status})`);
  } else {
    const sichtbar = daten.personen.some((z) => z.id === idModi1);
    ok(sichtbar, sichtbar
      ? "ohne die Rolle 'modi' sieht der Manager dieselbe Person sehr wohl "
        + "-- die Pruefung oben kann also anschlagen"
      : "GEGENPROBE FEHLGESCHLAGEN: auch ohne die Regel bleibt die Person "
        + "unsichtbar. Die Pruefung oben beweist damit nichts.");
  }
}


console.log(`\n${fehler ? "FEHLGESCHLAGEN" : "BESTANDEN"} -- `
  + `${geprueft} geprueft, ${fehler} Fehler, ${offen} nicht nachsehbar`);
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
process.exit(fehler ? 1 : 0);