dogfather-universe/server/pruef-personen-formular.mjs

/* =====================================================================
   Prüfung: das Formular "Neue Person" und die Rechte auf den beiden
   Verwaltungsbereichen (02.09.2026).

   Zwei Meldungen:

     "das sieht ja mal richtig scheisse aus. mach das besser bitte."
     -- Die Rollenauswahl lief unten aus dem Formular heraus und legte
        sich über die Personenliste. Ursache war keine schlampige
        Gestaltung, sondern eine Raster-Regel für EINZEILIGE Felder
        (feste Zeilenhöhe 44 px), die auch auf den Block aus vier hohen
        Karten angewandt wurde.

     "die manager sollen diese kategorien garnicht sehen"
     -- "Personen & Zugänge" und "Automationen" gehören allein DogFather.

   Der zweite Punkt wird auf DREI Ebenen geprüft, nicht nur an der
   Kachel: Wegnehmen, was man sieht, ist kein Rechteentzug. Es zählt,
   was der Server antwortet.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-pform-"));
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-personen-formular");
process.env.PORT = `${PORT}`;
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-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");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
   zwei Auffangnetze ein, die einen Absturz nur protokollieren --
   richtig fuer den Betrieb, fatal fuer eine Pruefung. Ohne diese
   Zeile bleibt der Prozess nach einem Fehler ewig stehen, weil der
   Server ihn am Leben haelt (siehe helfer-notbremse.mjs). */
notbremse(480_000, "pruef-personen-formular");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();

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

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
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;
}
anlegen("Dogfather", "admin", "CODE-DOGI-0001");
anlegen("Cigdem", "manager", "CODE-CIGDEM-01");
anlegen("Tili", "creator", "CODE-TILI-0001");
/* ZWEI MENSCHEN MIT ROLLEN, DIE DER BROWSER NICHT KENNT (10.09.2026).

   assets/js/personen.js gruppiert nach einer Liste mit fuenf Rollen,
   und die Namen der beiden hier duerfen dort nicht stehen -- sie
   gehoeren in keine Datei, die jeder herunterlaedt. Bis heute fiel
   damit jeder heraus, der eine davon hat: kein Fehler, keine Luecke,
   kein Hinweis.

   Aufgefallen ist es, als VanVan die rechte Hand wurde und in derselben
   Minute aus der Personenliste verschwand. Filipe hat das
   Bildschirmfoto geschickt: ein einziger Abschnitt, "DogFather". */
anlegen("VanVan", "hand", "CODE-HAND-0001");
anlegen("Ayla", "modi", "CODE-TEAM-0001");
d.close();

const { chromium } = await import(
  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await chromium.launch();

async function anmelden(rolle, code, breite = 1440) {
  const kontext = await browser.newContext({ viewport: { width: breite, height: 1000 } });
  const seite = await kontext.newPage();
  await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
  await seite.click(`.rolle[data-rolle="${rolle}"]`);
  await seite.fill("#code", code);
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 15000 });
  return seite;
}

/* ===================================================================
   TEIL 1 — Das Formular läuft nicht mehr über
   =================================================================== */

console.log("\n— Das Formular „Neue Person“ —");

const dogi = await anmelden("admin", "CODE-DOGI-0001");
await dogi.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
await dogi.waitForTimeout(700);
await dogi.click("#neu-oeffnen").catch(() => {});
await dogi.waitForTimeout(500);

const mass = await dogi.evaluate(() => {
  const form = document.getElementById("neu");
  const wahl = document.getElementById("f-rolle");
  const karten = [...document.querySelectorAll(".rollenwahl__knopf")];
  const f = form.getBoundingClientRect();
  const w = wahl.getBoundingClientRect();
  /* Das erste Element NACH dem Formular -- über das die Karten vorher
     hinweggelaufen sind. */
  const danach = document.querySelector("#liste");
  const dn = danach ? danach.getBoundingClientRect() : null;
  return {
    formUnten: Math.round(f.bottom),
    wahlUnten: Math.round(w.bottom),
    wahlOben: Math.round(w.top),
    listeOben: dn ? Math.round(dn.top) : null,
    karten: karten.length,
    kartenRollen: karten.map((k) => k.dataset.rolle),
    /* Welches Zeichen an welcher Karte haengt -- fuer die Frage, ob
       zwei Rollen dasselbe tragen. */
    kartenZeichen: Object.fromEntries(karten.map((k) => [k.dataset.rolle,
      (k.querySelector("use") || {}).getAttribute?.("href") || ""])),
    kartenTexte: Object.fromEntries(karten.map((k) => [k.dataset.rolle,
      (k.querySelector(".rollenwahl__erklaerung") || {}).textContent || ""])),
    kartenBreiten: karten.map((k) => Math.round(k.getBoundingClientRect().width)),
    /* Liegt eine Karte weiter rechts als das Formular breit ist? */
    ueberRand: karten.some((k) => k.getBoundingClientRect().right > f.right + 1),
  };
});

/* SECHS, seit es die verborgene Modi-Rolle gibt (09.09.2026) -- vorher
   fünf, seit es Spicy Media gibt. Die Erwartung steht hier absichtlich
   fest und wird nicht aus der Oberfläche abgeleitet: Fiele eine Rolle
   aus der Wahl, müsste das auffallen -- eine Zahl, die sich selbst
   nachzählt, kann das nicht.

   SIEBEN SEIT DEM 10.09.2026. Filipe: "3 rollen. dogfather. rechte
   hand und modis." Die Stellvertretung ist damit die siebte Karte --
   und sie kommt auf demselben Weg wie die sechste.

   DIE SECHSTE UND SIEBTE SIND NICHT WIE DIE ANDEREN. Die fünf stehen in
   assets/js/personen.js, also in einer Datei, die jeder bekommt, der
   die Seite öffnet. "Modi" darf dort nicht stehen -- ein Blick in den
   Quelltext würde sonst genügen, um den verborgenen Zugang zu
   entdecken. Sie kommt deshalb aus der Antwort des Servers und nur an
   die DogFather-Rolle. Dass sie hier auftaucht, ist gleichzeitig der
   Nachweis, dass dieser Weg funktioniert.

   Geprüft wird ab jetzt die LISTE und nicht nur die Anzahl: Sechs
   Karten könnten auch fünf richtige und eine doppelte sein. */
/* SECHS SEIT DEM 11.09.2026, NICHT SIEBEN. Filipe: "dogfather soll man
   nicht auswaehlen koennen. das ist die einzige die man nicht
   auswaehlen kann bitte." Die Karte faellt damit fuer JEDEN weg, auch
   fuer DogFather selbst.

   DIE ZEILE WURDE GEDREHT, NICHT GELOESCHT: Dass `admin` FEHLT, ist
   jetzt eine eigene Aussage -- sonst haette die Liste unten still eine
   Rolle mehr bekommen koennen, ohne dass es jemand merkt. */
/* ABGELEITET, NICHT GEZAEHLT (berichtigt 22.09.2026).
   ---------------------------------------------------------------------
   Hier stand `=== 7` und eine abgeschriebene Liste von sieben Namen.
   Am 21.09. kam die Rolle "linke" dazu, und beide Zeilen wurden rot,
   obwohl das Formular richtig war -- gemessen acht Karten, erwartet
   sieben. Die Pruefung war einen Tag lang rot und hat dabei nichts
   gefunden ausser sich selbst.

   Die eigentliche Aussage ist auch eine andere: Das Formular soll
   GENAU DAS anbieten, was der Server auch annimmt. Zwei Listen an zwei
   Stellen sind zwei Gelegenheiten, eine davon zu vergessen -- genau
   daran ist es am 17.09. schon einmal gescheitert ("wieso kann ich
   immer noch keine community rolle erstellen?"). */
const w = await import("./workspace.js");
/* ==== DASSELBE HAUS AUF BEIDEN SEITEN DER RECHNUNG (25.09.2026) =====

   Hier stand `haus: "agentur"`. Gemessen wird aber ueber
   `http://127.0.0.1` -- und dort kennt der Server kein Haus, liefert
   also ALLE anlegbaren Rollen (acht statt vier). Die Pruefung verglich
   damit eine Erwartung fuer die Agenturadresse mit einer Messung ohne
   Adresse und meldete: „alle 4 vergebbaren Rollen stehen zur Wahl (8)".

   BEIDES WAR RICHTIG, nur nicht dasselbe. Der Server tut genau, was er
   soll: `darfAnlegen` schneidet auf das Haus zu, sobald es eines gibt
   (workspace.js, seit dem 24.09.) -- und laesst alles zu, wo keines
   ist. Auf dem echten Server gibt es immer eines; die 127.0.0.1 ist
   ein Zustand, den nur Pruefungen herstellen.

   Die Erwartung fragt deshalb jetzt OHNE Haus -- genauso, wie die
   Messung laeuft. Dass die Einschraenkung je Haus wirklich greift,
   misst `pruef-haus-trennung` an echten Hostnamen; das ist ihre
   Aufgabe und nicht diese. */
const sollKarten = [...w.darfAnlegen({ rolle: "admin" })].sort();
ok(mass.karten === sollKarten.length,
  `alle ${sollKarten.length} vergebbaren Rollen stehen zur Wahl (${mass.karten})`);
ok(JSON.stringify([...mass.kartenRollen].sort()) === JSON.stringify(sollKarten),
  `und es sind genau die, die der Server annimmt (${mass.kartenRollen.join(", ")})`);
ok(!mass.kartenRollen.includes("admin"),
  "DogFather steht NICHT zur Wahl -- auch nicht fuer DogFather");

/* DIE STELLVERTRETUNG TRAEGT EIN EIGENES ZEICHEN.

   Zweimal derselbe Husky waere auf zwei getrennten Kacheln in Ordnung
   (dort unterscheiden Name und Farbe), in einer AUSWAHL aber nicht:
   Dort liegen sie untereinander, und zwei gleiche Zeichen laden zum
   Vertippen ein. Gemessen wird deshalb, dass es sich vom Husky
   UNTERSCHEIDET -- nicht, wie es aussieht. */
/* Hier stand "die Stellvertretung hat ein eigenes Zeichen" -- das
   Gegenteil dessen, was seit dem 10.09.2026 gilt. Umgedreht waere es
   dieselbe Pruefung wie oben, also ist die Zeile entfallen statt
   verdoppelt. */

/* WER DASSELBE ZEICHEN TRAEGT WIE DOGFATHER -- UND WER NICHT.

   Filipe, 10.09.2026 mit Bildschirmfoto: "bei rechte hand soll der
   husky sein und bei modis soll die pfote sein." Vorher trug der Modi
   den Husky ("das gleiche wie bei dogfather"); mit der dritten Rolle
   ist daraus eine Gruppe geworden -- Husky bei den beiden mit dem
   Ueberblick, Pfote bei der taeglichen Arbeit.

   BIS ZUM 11.09.2026 WURDE GEGEN DIE ADMIN-KARTE VERGLICHEN, und das
   war die bessere Messung: gewollt ist "dasselbe wie er", nicht "der
   Husky". Seit DogFather nicht mehr vergeben werden kann, gibt es
   diese Karte nicht mehr -- der Vergleich lief gegen `undefined` und
   waere kommentarlos rot geblieben.

   Ersatz ist das Zeichen selbst. Das ist schwaecher, und es steht hier,
   damit es niemand fuer gleichwertig haelt: Aendert jemand DogFathers
   Husky, faellt es hier NICHT mehr auf. Wer die alte Staerke
   zurueckwill, braucht eine Quelle fuer "DogFathers Zeichen", die
   nicht an der Auswahlkarte haengt. */
ok(mass.kartenZeichen.hand === "#r-husky",
  `die Rechte Hand trägt den Husky (${mass.kartenZeichen.hand} / `
  + `${mass.kartenZeichen.admin})`);
/* DIE GEGENPROBE GLEICH DANEBEN: Der Modi muss sich davon
   unterscheiden. Ohne sie waere die Zeile darueber auch dann gruen,
   wenn alle drei Karten dasselbe Zeichen truegen -- und genau so sah
   es bis heute Nachmittag aus. */
ok(mass.kartenZeichen.modi && mass.kartenZeichen.modi !== mass.kartenZeichen.admin,
  `und der Modi ein eigenes (${mass.kartenZeichen.modi})`);
/* Und die Beschreibung ist auf Deutsch geschrieben, nicht auf ASCII.
   Auf dem Bildschirmfoto stand "Sichtbar nur fuer die DogFather-Rolle"
   -- in einem Text, den jemand liest, sieht das aus wie ein Fehler,
   weil es einer ist. */
ok(mass.kartenTexte.modi && !/\b(fuer|ueber|waehrend|koennen|moeglich)\b/
  .test(mass.kartenTexte.modi),
  `und ihre Beschreibung hat echte Umlaute ("${mass.kartenTexte.modi.slice(0, 60)}…")`);
ok(mass.wahlUnten <= mass.formUnten,
  `die Rollenauswahl endet INNERHALB des Formulars (${mass.wahlUnten} ≤ ${mass.formUnten})`);
ok(!mass.ueberRand, "keine Karte ragt seitlich aus dem Formular");
ok(mass.listeOben === null || mass.wahlUnten <= mass.listeOben,
  `die Karten liegen nicht über der Personenliste (${mass.wahlUnten} ≤ ${mass.listeOben})`);

/* Alle Karten gleich breit -- ungleiche Kacheln sind das, was "sieht
   scheisse aus" in Zahlen bedeutet. */
const breiteste = Math.max(...mass.kartenBreiten);
const schmalste = Math.min(...mass.kartenBreiten);
ok(breiteste - schmalste <= 2,
  `alle Karten sind gleich breit (${schmalste}–${breiteste} px)`);

/* Die gewählte Rolle muss man SEHEN, nicht erraten. */
const vorher = await dogi.evaluate(() =>
  getComputedStyle(document.querySelector('.rollenwahl__knopf[data-an="ja"]'), "::after").content);
ok(vorher.includes("✓"), `die gewählte Rolle trägt ein Häkchen (${vorher})`);

await dogi.screenshot({ path: "pruef-personen-formular.png", fullPage: false });

/* Auf dem Handy darf nichts herausragen. */
const handy = await anmelden("admin", "CODE-DOGI-0001", 390);
await handy.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
await handy.waitForTimeout(700);
await handy.click("#neu-oeffnen").catch(() => {});
await handy.waitForTimeout(500);
const engUeber = await handy.evaluate(() =>
  document.documentElement.scrollWidth - document.documentElement.clientWidth);
ok(engUeber <= 0, `auf dem Handy ragt nichts heraus (${engUeber}px)`);
await handy.screenshot({ path: "pruef-personen-formular-handy.png", fullPage: false });

/* ===================================================================
   TEIL 2 — Die beiden Bereiche gehören DogFather allein
   =================================================================== */

console.log("\n— Automationen: nur DogFather. Personen: auch die Leitung —");

/* AM 07.09.2026 GETEILT. Hier standen beide Bereiche unter derselben
   Regel: „gehören DogFather allein". Für die Automationen gilt das
   weiter. Für die Personenseite hat Filipe es umgedreht -- Manager
   sollen „creator und auch wirklich nur creator hinzufügen können",
   und dafür müssen sie hinein.

   Aus einer Regel sind damit ZWEI geworden, und beide werden gemessen:
   Die Seite geht auf, die Verwaltungsdaten dahinter bleiben zu. Genau
   diese Trennung IST die Sicherung. Hätte ich hier nur die Zeilen
   gelöscht, wäre der neue Weg ab sofort ungeprüft -- und die Zahl der
   Prüfungen wäre gesunken, ohne dass jemand hinsieht. */
const cigdem = await anmelden("manager", "CODE-CIGDEM-01");
await cigdem.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
await cigdem.waitForTimeout(800);

const kacheln = await cigdem.evaluate(() =>
  [...document.querySelectorAll(".kachel")].map((k) => k.innerText.split("\n")[0].trim()));
ok(kacheln.some((t) => /Personen/.test(t)),
  "1. die Kachel „Personen & Zugänge“ steht jetzt bei der Managerin");
ok(!kacheln.some((t) => /Automationen/.test(t)),
  "1. die Kachel „Automationen“ fehlt weiterhin");
ok(kacheln.length > 8,
  `   – und der Rest steht auch da (${kacheln.length} Kacheln)`);

/* 2. Die SEITEN, falls jemand die Adresse kennt. */
{
  await cigdem.goto(BASIS + "/workspace/automation.html", { waitUntil: "networkidle" });
  ok(cigdem.url().endsWith("/start.html"),
    `2. automation.html führt zurück zur Startseite (${cigdem.url().split("/").pop()})`);

  await cigdem.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
  await cigdem.waitForTimeout(900);
  ok(cigdem.url().endsWith("/personen.html"),
    `2. personen.html geht bei ihr auf (${cigdem.url().split("/").pop()})`);

  /* Und sie sieht dort NUR das Anlegen -- keine Liste, kein Protokoll,
     und keinen Ladehinweis ohne Ende. Der stand dort wirklich:
     `laden()` wird für sie mit Absicht nicht aufgerufen, und niemand
     hat aria-busy zurückgesetzt. Für einen Screenreader lud die Seite
     dann für immer. */
  const seitenbild = await cigdem.evaluate(() => ({
    nurAnlegen: document.body.dataset.nurAnlegen || null,
    laedtNoch: document.querySelectorAll('[aria-busy="true"]').length,
    erklaerung: document.getElementById("unterzeile")?.textContent.trim() || "",
    formularDa: !!document.getElementById("neu") && !document.getElementById("neu").hidden,
  }));
  ok(seitenbild.nurAnlegen === "ja" && seitenbild.formularDa === true,
    "2. sie sieht dort das Anlegen-Formular");
  ok(seitenbild.laedtNoch === 0,
    `2. und nichts hängt auf „wird geladen“ (${seitenbild.laedtNoch})`);
  ok(seitenbild.erklaerung.includes("DogFather"),
    `2. ein Satz erklärt, warum hier so wenig steht ("${seitenbild.erklaerung.slice(0, 40)}…")`);
}

/* 3. Die SCHNITTSTELLE, falls jemand ganz an der Seite vorbeigeht.
   Das ist die einzige Ebene, die wirklich zählt -- die beiden darüber
   sind Bequemlichkeit. */
const api = (seite, pfad, optionen) => seite.evaluate(async ([p, o]) => {
  const a = await fetch(p, { credentials: "same-origin", ...(o || {}) });
  return a.status;
}, [pfad, optionen]);

await cigdem.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
ok(await api(cigdem, "/workspace/api/verwaltung/personen") === 404,
  "3. die Personenverwaltung antwortet ihr mit 404");
ok(await api(cigdem, "/workspace/api/zustand") === 404,
  "3. der Systemzustand ebenfalls");
ok(await api(cigdem, "/workspace/api/ki/schalter", { method: "PUT" }) !== 200,
  "3. und den KI-Schalter darf sie nicht umlegen");

/* GEGENPROBE: Bei DogFather geht das alles weiterhin. Ohne sie wäre
   jede Zeile oben auch dann grün, wenn die Bereiche für ALLE kaputt
   wären -- und das würde erst auffallen, wenn er sie braucht. */
ok(await api(dogi, "/workspace/api/verwaltung/personen") === 200,
  "GEGENPROBE: DogFather kommt weiterhin an die Personenverwaltung");
ok(await api(dogi, "/workspace/api/zustand") === 200,
  "GEGENPROBE: und an den Systemzustand");

/* Und die Managerin behält, was sie behalten soll. */
ok(await api(cigdem, "/workspace/api/aufgaben") === 200,
  "die Managerin arbeitet ansonsten unverändert weiter (Aufgaben)");
ok(await api(cigdem, "/workspace/api/calls") === 200, "   und die Gespräche auch");

/* =====================================================================
   NIEMAND FAELLT LAUTLOS WEG (10.09.2026)

   Die eigentliche Pruefung dieser Datei zum Thema Rollen: Was der
   Server liefert, MUSS auf dem Bildschirm stehen. Eine Pruefung, die
   nur die Antwort des Servers ansieht, waere hier gruen gewesen -- er
   hat VanVan die ganze Zeit mitgeschickt.

   VERGLICHEN WIRD DESHALB ZAHL GEGEN ZAHL: wie viele Menschen kamen
   an, wie viele stehen da. Nicht "steht VanVan da" -- das waere ein
   Name, den man beim naechsten Umbau anpasst, bis die Pruefung wieder
   passt. Die Zahl kann man nicht zurechtbiegen.
   ===================================================================== */
console.log("");
console.log("=== Steht jeder auf der Seite, den der Server schickt? ===");
{
  await dogi.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
  await dogi.waitForTimeout(900);
  const m = await dogi.evaluate(async () => {
    const a = await fetch("/workspace/api/verwaltung/personen", { credentials: "same-origin" });
    const daten = await a.json();
    return {
      vomServer: (daten.personen || []).length,
      rollenVomServer: [...new Set((daten.personen || []).map((p) => p.rolle))].sort(),
      aufDerSeite: document.querySelectorAll(".person, .person-karte, [class*='person__']").length
        ? document.querySelectorAll("#liste .gruppe").length : -1,
      /* AUFGEKLAPPT MESSEN. Die Abschnitte stehen zugeklappt da, und
         zugeklappt sind ihre Zeilen gar nicht im Dokument -- eine Suche
         im Text findet dann nichts, obwohl alles richtig ist. Beim
         ersten Lauf meldete diese Zeile vier Fehler, die es nicht gab.
         Also erst oeffnen, dann lesen. */
      namenAufDerSeite: (() => {
        for (const k of document.querySelectorAll("#liste .gruppe__kopf")) k.click();
        return document.querySelector("#liste")?.textContent || "";
      })(),
      zeilen: (() => {
        for (const k of document.querySelectorAll("#liste .gruppe__kopf")) {
          if (k.getAttribute("aria-expanded") !== "true") k.click();
        }
        return document.querySelectorAll("#liste .person").length;
      })(),
      abschnitte: [...document.querySelectorAll("#liste .gruppe")]
        .map((g) => g.dataset.rolle),
    };
  });
  console.log(`   Server: ${m.vomServer} Menschen in ${m.rollenVomServer.length} Rollen `
    + `(${m.rollenVomServer.join(", ")})`);
  console.log(`   Seite:  ${m.abschnitte.length} Abschnitte (${m.abschnitte.join(", ")})`);

  ok(m.vomServer >= 5, `der Server liefert ${m.vomServer} Menschen`);
  ok(m.zeilen === m.vomServer,
    `und ebenso viele Zeilen stehen auf der Seite (${m.zeilen} von ${m.vomServer})`);
  ok(m.abschnitte.length === m.rollenVomServer.length,
    `fuer jede gelieferte Rolle steht ein Abschnitt da `
    + `(${m.abschnitte.length} von ${m.rollenVomServer.length})`);
  for (const name of ["VanVan", "Ayla", "Tili", "Cigdem"]) {
    ok(m.namenAufDerSeite.includes(name), `${name} steht auf der Seite`);
  }

  /* GEGENPROBE: Findet die Messung ueberhaupt jemanden NICHT? Ein
     erfundener Name darf nicht dastehen -- sonst prueft "steht auf der
     Seite" gar nichts. */
  ok(!m.namenAufDerSeite.includes("Gibtsnichtsson"),
    "und ein erfundener Name steht nicht da");
}

const ERWARTET = 17;
console.log("");
ok(geprueft >= ERWARTET, `es sind ${geprueft} Prüfungen gelaufen (erwartet mindestens ${ERWARTET})`);

/* ===================================================================
   TEIL: DIE RECHTE HAND LEGT SELBST JEMANDEN AN (22.09.2026)
   ===================================================================

   Filipe: "dan will ich dass die rechte hand auch neue personen
   hinzufuegen kann ... und die codes genau so sieht wie dogfather,
   damit sie das auch machen kann wenn er live ist."

   GEPRUEFT WIRD DER GANZE WEG, nicht die Rechtetabelle. Die sagt seit
   heute "ja"; ob ein Mensch damit jemanden anlegen kann, ist eine
   andere Frage. Beim ersten Anlauf war sie mit "nein" zu beantworten:
   Die Seite entschied den Sendeweg an `ich.rolle === 'admin'`, und
   fuer die rechte Hand gab es damit GAR KEINEN -- sie bekam "Fuer die
   Rolle modi gibt es hier keinen Weg", einen Satz, der wie ein Fehler
   im Formular klingt.
   =================================================================== */
console.log("\n— Die rechte Hand legt jemanden an —");
{
  /* EIGENER BROWSER AUF DER CREW-ADRESSE.
     ------------------------------------------------------------------
     127.0.0.1 ist die AGENTURWAND -- dort gibt es die Kachel "rechte
     Hand" gar nicht, und der erste Anlauf lief in eine
     Zeitueberschreitung. Das war kein Befund, sondern die falsche Tuer.

     Chromium zwingt `crew.dogfather-universe.com` auf https (die
     Adresse steht in seiner eingebauten HSTS-Liste), deshalb ein
     Vorbau mit eigenem Zertifikat -- derselbe Weg wie in
     pruef-handy-teamdogi und pruef-zuteilung. */
  const { execFileSync } = await import("node:child_process");
  const { createServer: httpsServer } = await import("node:https");
  const { request: httpAnfrage } = await import("node:http");
  const { readFileSync: lesen } = await import("node:fs");
  const HOST = "crew.dogfather-universe.com";
  const sk = join(ordner, "pf.key"), zt = join(ordner, "pf.crt");
  execFileSync("openssl", ["req", "-x509", "-newkey", "rsa:2048", "-nodes",
    "-keyout", sk, "-out", zt, "-days", "2", "-subj", `/CN=${HOST}`,
    "-addext", `subjectAltName=DNS:${HOST}`], { stdio: "ignore" });
  const HP = PORT + 1;
  const vorbau = httpsServer({ key: lesen(sk), cert: lesen(zt) }, (von, nach) => {
    const w = httpAnfrage({ host: "127.0.0.1", port: PORT, path: von.url,
      method: von.method, headers: { ...von.headers, host: `${HOST}:${HP}` } },
      (a) => { nach.writeHead(a.statusCode || 502, a.headers); a.pipe(nach); });
    von.pipe(w);
  });
  await new Promise((r) => vorbau.listen(HP, "127.0.0.1", r));
  const CREW = `https://${HOST}:${HP}`;
  const crewBrowser = await chromium.launch({
    args: [`--host-resolver-rules=MAP ${HOST} 127.0.0.1`, "--ignore-certificate-errors"],
  });
  const kontext = await crewBrowser.newContext({ viewport: { width: 1440, height: 1000 } });
  const hand = await kontext.newPage();
  try {
    await hand.goto(CREW + "/workspace/", { waitUntil: "domcontentloaded" });
    await hand.click('.rolle[data-rolle="hand"]');
    await hand.fill("#code", "CODE-HAND-0001");
    await hand.click("button[type=submit]");
    await hand.waitForURL("**/start.html", { timeout: 20000 });
    await hand.goto(CREW + "/workspace/personen.html", { waitUntil: "networkidle" });
    await hand.waitForTimeout(900);
    await hand.click("#neu-oeffnen").catch(() => {});
    await hand.waitForTimeout(500);

    const bild = await hand.evaluate(async () => {
      const a = await fetch("/workspace/api/ich").then((r) => r.json()).catch(() => ({}));
      const f = document.getElementById("neu");
      const auf = document.getElementById("neu-oeffnen");
      return {
        formDa: !!f && !f.hidden,
        knopfDa: !!auf && !auf.hidden,
        rollen: [...document.querySelectorAll("#neu .rollenwahl__knopf")]
          .map((k) => k.dataset.rolle || k.getAttribute("data-rolle")).filter(Boolean),
        woSonst: [...document.querySelectorAll(".rollenwahl__knopf")]
          .map((k) => (k.closest("[id]") || {}).id + ":" + (k.dataset.rolle || "?")),
        vomServer: a.darf_anlegen,
        meineRolle: a.rolle,
      };
    });
    console.log("       /api/ich sagt: rolle=" + bild.meineRolle
      + " darf_anlegen=" + JSON.stringify(bild.vomServer)
      + " Knopf=" + bild.knopfDa + " Form offen=" + bild.formDa);
    console.log("       Rollenknoepfe: " + JSON.stringify(bild.woSonst));
    ok(bild.formDa, "sie bekommt das Formular ueberhaupt zu sehen");
    ok(bild.rollen.length > 0 && bild.rollen.every((r) => ["modi", "gast"].includes(r)),
      `und genau die Rollen, die sie darf (${bild.rollen.join(", ") || "keine"})`);

    /* JETZT WIRKLICH ANLEGEN. Ein Formular, das dasteht und beim
       Absenden scheitert, ist schlimmer als keines. */
    const name = "Neue Modi " + Date.now().toString().slice(-5);
    await hand.evaluate((n) => {
      const k = [...document.querySelectorAll(".rollenwahl__knopf")]
        .find((x) => (x.dataset.rolle || "") === "modi");
      if (k) k.click();
      document.getElementById("f-name").value = n;
    }, name);
    await hand.waitForTimeout(250);
    await hand.click("#neu button[type=submit]").catch(async () => {
      await hand.evaluate(() => document.getElementById("neu").requestSubmit());
    });
    await hand.waitForTimeout(2200);

    /* DIE ABSCHNITTE DER LISTE SIND ZUGEKLAPPT -- `innerText` sieht
       zugeklappten Inhalt nicht. Dieselbe Falle wie am 21.09. bei
       pruef-nachfrage. Erst aufklappen, dann messen. */
    await hand.evaluate(() => {
      for (const d of document.querySelectorAll("details")) d.open = true;
    });
    await hand.waitForTimeout(400);
    const danach = await hand.evaluate((n) => {
      const kasten = document.querySelector(".code-kasten, #code-kasten");
      const text = document.body.innerText;
      return {
        fehler: (document.getElementById("neu-fehler") || {}).textContent || "",
        codeDa: !!kasten && !kasten.hidden,
        codeText: kasten ? (kasten.innerText || "").slice(0, 200) : "",
        stehtInListe: text.includes(n),
        listeDa: !!document.getElementById("liste"),
        listeText: (document.getElementById("liste") || {}).innerText
          ? document.getElementById("liste").innerText.replace(/\s+/g, " ").slice(-260) : "(leer)",
        gesucht: n,
      };
    }, name);
    ok(!danach.fehler, `kein Fehler beim Absenden (${danach.fehler || "keiner"})`);
    ok(danach.codeDa, "der Zugangscode wird ihr angezeigt");
    ok(/[A-Z0-9]{4}/.test(danach.codeText),
      `und er sieht auch wie einer aus (${danach.codeText.replace(/\s+/g, " ").slice(0, 60)})`);
    /* GEMESSEN WIRD DIE LISTE DES SERVERS, NICHT DER SICHTBARE TEXT
       (berichtigt 22.09.2026).

       Hier stand `document.body.innerText.includes(name)`. Die
       Abschnitte der Personenliste sind zugeklappt und zeigen nur die
       Anfangsbuchstaben -- der volle Name steht dort also gar nicht,
       obwohl die Person laengst angelegt ist. Die Zeile war rot, und
       kaputt war nur sie selbst.

       Jetzt wird gefragt, was sie WIRKLICH bekommt: dieselbe Auskunft,
       aus der die Liste gebaut wird. Das beweist beides auf einmal --
       dass sie anlegen kann UND dass sie das Ergebnis sieht. */
    const ausListe = await hand.evaluate(async (n) => {
      const a = await fetch("/workspace/api/verwaltung/personen")
        .then((r) => r.json()).catch(() => null);
      return {
        code: Array.isArray(a?.personen) ? 200 : 0,
        dabei: (a?.personen || []).some((x) => x.name === n),
        zahl: (a?.personen || []).length,
      };
    }, name);
    ok(ausListe.code === 200,
      `sie bekommt die Personenliste (${ausListe.zahl} Menschen)`);
    ok(ausListe.dabei, ausListe.dabei
      ? "und die eben angelegte Person steht darin"
      : `die eben angelegte Person fehlt in ihrer Liste (${name})`);
  } finally {
    await kontext.close();
    await crewBrowser.close();
    await new Promise((r) => vorbau.close(r));
  }
}

await browser.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
console.log(`\n${fehler ? "FEHLER: " + fehler : "Alles in Ordnung"} — ${geprueft} Prüfungen`);
process.exit(fehler ? 1 : 0);