dogfather-universe/server/pruef-rechte-umstellen.mjs

/* =====================================================================
   Die Rechtetafel von Hand umstellen (11.09.2026)

   Seit heute kann DogFather die Tafel auf der Seite „Wer sieht was"
   ändern. Das ist die gefährlichste Einstellung im ganzen Haus: Ein
   Klick öffnet oder schließt eine Seite für eine ganze Rolle.

   Deshalb wird hier nicht geprüft, ob die Antwort 200 lautet, sondern
   ob sich das VERHALTEN ändert — also ob ein Modi die Seite danach
   wirklich nicht mehr aufbekommt. Mit Gegenprobe davor, sonst beweist
   es nichts.

   Und die drei Riegel:
     · Nur DogFather stellt um. Die rechte Hand sieht dieselbe Tafel
       und bekommt 403.
     · Drei Felder sind fest — er kann sich nicht selbst aussperren.
     · Alles zurück auf Grundstand ist ein Knopf, und danach gilt genau
       das, was im Code steht.

   Aufrufen mit:  node server/pruef-rechte-umstellen.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 { eigenerPort } from "./helfer-port.mjs";

const PORT = await eigenerPort(import.meta, "pruef-rechte-umstellen");

const ordner = mkdtempSync(join(tmpdir(), "ws-rechte-"));
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(240_000, "pruef-rechte-umstellen");
await new Promise((r) => setTimeout(r, 700));

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

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

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

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

const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
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);
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, createHmac("sha256", schluessel).update(code).digest("hex"), jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}
anlegen("Filipe", "admin", "CODE-DOGI-0001");
anlegen("Rieke", "hand", "CODE-HAND-0001");
anlegen("Frida", "modi", "CODE-MODI-0001");
anlegen("Mara", "manager", "CODE-MANA-0001");
d.close();

function roh(pfad, host, kopf = {}, koerper = null, methode = null) {
  if (methode === "DELETE") koerper = 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 kMana = await anmelden("manager", "CODE-MANA-0001", HAUS);
ok(!!kDogi && !!kHand && !!kModi && !!kMana, "vier Rollen sind angemeldet");

/* =======================================================================
   1. WER DIE SEITE BEKOMMT — und wer sie umstellen darf
   ======================================================================= */
melde("");
melde("=== 1. Wer die Tafel sieht ===");
{
  for (const [wer, host, keks, soll] of [
    ["DogFather", HAUS, kDogi, true],
    ["die rechte Hand", CREW, kHand, true],
    ["ein Modi", CREW, kModi, false],
    ["eine Managerin", HAUS, kMana, false],
  ]) {
    const seite = await roh("/workspace/rechte.html", host, { cookie: keks });
    const api = await roh("/workspace/api/rechte/tafel", host, { cookie: keks });
    ok((seite.code === 200) === soll && (api.code === 200) === soll,
      `${wer}: Seite ${seite.code}, Tafel ${api.code} — ${soll ? "beides offen" : "beides zu"}`);
  }

  /* UMSTELLEN IST ETWAS ANDERES ALS SEHEN. */
  const alsDogi = json(await roh("/workspace/api/rechte/tafel", HAUS, { cookie: kDogi }));
  const alsHand = json(await roh("/workspace/api/rechte/tafel", CREW, { cookie: kHand }));
  ok(alsDogi.darf_aendern === true, "DogFather darf umstellen");
  /* SEIT DEM 24.09.2026 DARF SIE AUCH UMSTELLEN.
     Filipe: „die selben rechte da haben wie dogfather. das einzige
     was sie nicht kann ist die dogfather rolle oder leute anfassen."
     Was sie NICHT darf, wird in Abschnitt 5 einzeln geprueft. */
  ok(alsHand.darf_aendern === true, "die rechte Hand darf jetzt auch umstellen");
  ok(alsDogi.darf_zuruecksetzen === true && alsHand.darf_zuruecksetzen === false,
    "zuruecksetzen bleibt bei DogFather -- es naehme auch ihre Sperren mit");
  ok(alsHand.seiten?.length === alsDogi.seiten?.length,
    `und sie bekommt wirklich dieselbe (${alsHand.seiten?.length} Seiten)`);

  /* DIE KACHEL AUF BEIDEN ADRESSEN (Filipe, 11.09.2026). */
  for (const [wer, host, keks, soll] of [
    ["DogFather auf crew.", CREW, kDogi, true],
    ["die rechte Hand auf crew.", CREW, kHand, true],
    ["ein Modi auf crew.", CREW, kModi, false],
  ]) {
    const ich = json(await roh("/workspace/api/ich", host, { cookie: keks }));
    const alle = [...(ich.bereiche || []), ...(ich.bereiche_zusatz || [])];
    const da = alle.some((k) => k.ziel === "rechte.html");
    ok(da === soll, `${wer}: Kachel ${da ? "da" : "nicht da"}`);
  }
}

/* =======================================================================
   2. UMSTELLEN ÄNDERT DAS VERHALTEN — nicht nur die Anzeige
   ======================================================================= */
melde("");
melde("=== 2. Ein Klick, und die Seite ist zu ===");
const PROBE = "/workspace/chat.html";
{
  /* GEGENPROBE ZUERST. Ohne sie wäre „danach zu" auch dann grün, wenn
     die Seite vorher schon zu gewesen wäre. */
  const vorher = await roh(PROBE, CREW, { cookie: kModi });
  ok(vorher.code === 200, `ein Modi kann chat.html öffnen (${vorher.code})`);

  const stellen = await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
    { pfad: PROBE, rolle: "modi", erlaubt: false }, "PUT");
  ok(stellen.code === 200, `DogFather nimmt sie ihm weg (${stellen.code})`);
  ok(json(stellen).abweichungen === 1, `eine Abweichung vom Grundstand (${json(stellen).abweichungen})`);

  /* DAS IST DER EIGENTLICHE BEWEIS: nicht die Antwort, sondern die
     Schranke. */
  const nachher = await roh(PROBE, CREW, { cookie: kModi });
  ok(nachher.code !== 200, `und die Schranke lässt ihn nicht mehr durch (${nachher.code})`);

  /* Und die Kachel ist auch weg -- sonst führte ein Knopf ins Leere. */
  const ich = json(await roh("/workspace/api/ich", CREW, { cookie: kModi }));
  const alle = [...(ich.bereiche || []), ...(ich.bereiche_zusatz || [])];
  ok(!alle.some((k) => (k.ziel || "").startsWith("chat.html")),
    "und die Kachel dazu verschwindet mit");

  /* DIE ANZEIGE SAGT, DASS ES VON HAND GESETZT IST. */
  const tafel = json(await roh("/workspace/api/rechte/tafel", HAUS, { cookie: kDogi }));
  const zeile = tafel.seiten.find((s) => s.pfad === PROBE);
  ok(!zeile.rollen.includes("modi") && zeile.grund.includes("modi"),
    "die Tafel zeigt: jetzt nein, im Grundstand ja");
  const modi = tafel.rollen.find((r) => r.schluessel === "modi");
  ok(modi.abweichend === 1, `und zählt es bei der Rolle (${modi.abweichend})`);
}

/* =======================================================================
   3. ZURÜCK — auf zwei Wegen
   ======================================================================= */
melde("");
melde("=== 3. Zurück ===");
{
  /* WEG EINS: dasselbe Feld wieder anklicken. Die Abweichung muss
     dabei VERSCHWINDEN und nicht als „erlaubt" stehenbleiben -- sonst
     stünde in der Datenbank eine Zeile, die dasselbe sagt wie der
     Code, und die Anzeige meldete „von Hand gesetzt", obwohl nichts
     verstellt ist. */
  const zurueck = await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
    { pfad: PROBE, rolle: "modi", erlaubt: true }, "PUT");
  ok(zurueck.code === 200 && json(zurueck).abweichungen === 0,
    `zurückgeklickt, keine Abweichung mehr (${json(zurueck).abweichungen})`);
  const wieder = await roh(PROBE, CREW, { cookie: kModi });
  ok(wieder.code === 200, `und der Modi kommt wieder hinein (${wieder.code})`);

  /* WEG ZWEI: der Knopf. Erst wieder etwas verstellen, sonst prüft er
     nichts. */
  await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
    { pfad: PROBE, rolle: "modi", erlaubt: false }, "PUT");
  await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
    { pfad: "/workspace/wissen.html", rolle: "modi", erlaubt: false }, "PUT");
  const vorAllem = json(await roh("/workspace/api/rechte/tafel", HAUS, { cookie: kDogi }));
  ok(vorAllem.abweichungen === 2, `zwei Felder verstellt (${vorAllem.abweichungen})`);

  const alles = await roh("/workspace/api/rechte/abweichungen", HAUS, { cookie: kDogi },
    null, "DELETE");
  ok(alles.code === 200 && json(alles).zurueckgenommen === 2,
    `der Knopf nimmt beide zurück (${json(alles).zurueckgenommen})`);
  const danach = json(await roh("/workspace/api/rechte/tafel", HAUS, { cookie: kDogi }));
  ok(danach.abweichungen === 0, "und die Tafel steht wieder auf Grundstand");

  /* Und das Verhalten stimmt auch wieder -- die Zahl allein wäre nur
     eine Behauptung. */
  const chat = await roh(PROBE, CREW, { cookie: kModi });
  const wissen = await roh("/workspace/wissen.html", CREW, { cookie: kModi });
  ok(chat.code === 200 && wissen.code === 200,
    `beide Seiten sind für den Modi wieder offen (${chat.code}/${wissen.code})`);
}

/* =======================================================================
   4. DIE DREI FESTEN FELDER
   ======================================================================= */
melde("");
melde("=== 4. Aussperren geht nicht ===");
{
  for (const u of rechte.UNANTASTBAR) {
    const a = await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
      { pfad: u.pfad, rolle: u.rolle, erlaubt: false }, "PUT");
    ok(a.code === 400, `${u.pfad.replace("/workspace/", "")} bleibt bei ${u.rolle} (${a.code})`);
    ok(/wegnehmen/.test(json(a).fehler || ""),
      "und die Absage sagt, warum – nicht nur nein");
  }
  /* GEGENPROBE: Dieselbe Seite bei einer ANDEREN Rolle geht sehr wohl.
     Ohne diese Zeile wäre „fest" auch dann grün, wenn gar nichts
     umstellbar wäre. */
  const andere = await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
    { pfad: "/workspace/rechte.html", rolle: "hand", erlaubt: false }, "PUT");
  ok(andere.code === 200, `dieselbe Seite bei der rechten Hand schon (${andere.code})`);
  const handSeite = await roh("/workspace/rechte.html", CREW, { cookie: kHand });
  ok(handSeite.code !== 200, `und sie kommt danach nicht mehr hinein (${handSeite.code})`);
  await roh("/workspace/api/rechte/abweichungen", HAUS, { cookie: kDogi }, null, "DELETE");

  /* Die Oberfläche bekommt die feste Liste mitgeliefert -- damit sie
     den Knopf gar nicht erst als Knopf zeigt. */
  const tafel = json(await roh("/workspace/api/rechte/tafel", HAUS, { cookie: kDogi }));
  const zeile = tafel.seiten.find((s) => s.pfad === "/workspace/rechte.html");
  ok(zeile?.fest?.includes("admin"), `und die Tafel sagt, welches Feld fest ist (${zeile?.fest})`);
}

/* =======================================================================
   5. WER NICHT DARF, DARF AUCH ÜBER DIE SCHNITTSTELLE NICHT
   ======================================================================= */
melde("");
melde("=== 5. Die rechte Hand stellt um -- aber nicht alles ===");
{
  /* WAS SIE DARF (seit 24.09.2026). */
  const darf = await roh("/workspace/api/rechte/feld", CREW, { cookie: kHand },
    { pfad: PROBE, rolle: "modi", erlaubt: false }, "PUT");
  ok(darf.code === 200, `sie stellt ein gewoehnliches Feld um (${darf.code})`);
  /* UND ES WIRKT WIRKLICH -- nicht nur die Anzeige. */
  const zu = await roh(PROBE, CREW, { cookie: kModi });
  ok(zu.code !== 200, `danach kommt der Modi nicht mehr auf die Seite (${zu.code})`);
  /* Gleich wieder zurueck, damit die folgenden Abschnitte den
     Grundstand vorfinden. */
  await roh("/workspace/api/rechte/feld", CREW, { cookie: kHand },
    { pfad: PROBE, rolle: "modi", erlaubt: true }, "PUT");

  /* WAS SIE NICHT DARF -- die drei Sperren, einzeln. */
  const dogiSpalte = await roh("/workspace/api/rechte/feld", CREW, { cookie: kHand },
    { pfad: PROBE, rolle: "admin", erlaubt: false }, "PUT");
  ok(dogiSpalte.code === 400,
    `die Spalte DogFather nicht (${dogiSpalte.code})`);
  ok(/DogFather/.test(json(dogiSpalte).fehler || ""),
    "und sie erfaehrt, warum");

  /* AUCH NICHT ZUSCHALTEN. Nur das Wegnehmen zu sperren waere
     dieselbe Tuer, nur andersherum -- sie koennte ihm jede Seite
     AUFdruecken. */
  const dogiZu = await roh("/workspace/api/rechte/feld", CREW, { cookie: kHand },
    { pfad: "/workspace/befinden.html", rolle: "admin", erlaubt: true }, "PUT");
  ok(dogiZu.code === 400,
    `auch zuschalten kann sie ihm nichts (${dogiZu.code})`);

  const leute = await roh("/workspace/api/rechte/feld", CREW, { cookie: kHand },
    { pfad: "/workspace/personen.html", rolle: "modi", erlaubt: true }, "PUT");
  ok(leute.code === 400,
    `und "Personen & Zugaenge" fuer niemanden (${leute.code})`);

  /* UND SIE KANN SICH NICHT SELBST AUSSPERREN. Das hat Filipe nicht
     gesagt; eine Sperre, aus der man sich aussperren kann, ist aber
     keine Einstellung, sondern eine Falle. */
  const selbst = await roh("/workspace/api/rechte/feld", CREW, { cookie: kHand },
    { pfad: "/workspace/rechte.html", rolle: "hand", erlaubt: false }, "PUT");
  ok(selbst.code === 400,
    `sie kann sich die Rechteseite nicht selbst wegnehmen (${selbst.code})`);

  /* DIE OBERFLAECHE WEISS DASSELBE -- sonst zeigt sie einen Knopf,
     den der Server danach ablehnt. */
  const tafelHand = json(await roh("/workspace/api/rechte/tafel", CREW, { cookie: kHand }));
  const zeileProbe = tafelHand.seiten.find((x) => x.pfad === PROBE);
  const zeilePers = tafelHand.seiten.find((x) => x.pfad === "/workspace/personen.html");
  ok(zeileProbe?.fest?.includes("admin"),
    "die Tafel zeichnet ihr die Spalte DogFather als fest");
  ok(zeilePers?.fest?.length >= 5,
    `und die ganze Zeile "Personen & Zugaenge" (${zeilePers?.fest?.length} Felder)`);
  ok(!!zeileProbe?.fest_grund?.admin,
    "mit einem Grund, der danebensteht");

  /* GEGENPROBE: Bei DogFather ist genau das NICHT fest -- sonst
     hiesse "fest" nur, dass die Tafel immer dasselbe sagt. */
  const tafelDogi2 = json(await roh("/workspace/api/rechte/tafel", HAUS, { cookie: kDogi }));
  const dogiProbe = tafelDogi2.seiten.find((x) => x.pfad === PROBE);
  ok(!dogiProbe?.fest?.includes("admin"),
    "fuer DogFather selbst ist dieselbe Spalte NICHT fest");

  /* Andere Rollen kommen weiterhin gar nicht heran. */
  const modi = await roh("/workspace/api/rechte/feld", CREW, { cookie: kModi },
    { pfad: PROBE, rolle: "modi", erlaubt: true }, "PUT");
  ok(modi.code === 404, `ein Modi bekommt 404 – für ihn gibt es die Tafel nicht (${modi.code})`);

  const alles = await roh("/workspace/api/rechte/abweichungen", CREW, { cookie: kHand },
    null, "DELETE");
  ok(alles.code === 403, `und zurücksetzen darf sie nicht (${alles.code})`);

  /* GEGENPROBE: Nach all dem ist die Tafel unverändert. Ein
     abgewiesener Versuch, der trotzdem etwas ändert, wäre der
     schlimmste Ausgang von allen. */
  const tafel = json(await roh("/workspace/api/rechte/tafel", HAUS, { cookie: kDogi }));
  ok(tafel.abweichungen === 0, `nichts davon hat etwas verändert (${tafel.abweichungen})`);
}

/* =======================================================================
   6. ERFUNDENES WIRD ABGEWIESEN
   ======================================================================= */
melde("");
melde("=== 6. Erfundenes ===");
{
  const seite = await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
    { pfad: "/workspace/gibt-es-nicht.html", rolle: "modi", erlaubt: true }, "PUT");
  ok(seite.code === 400, `eine erfundene Seite (${seite.code})`);
  const rolle = await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
    { pfad: PROBE, rolle: "chef", erlaubt: true }, "PUT");
  ok(rolle.code === 400, `eine erfundene Rolle (${rolle.code})`);
  /* Und die Zugangswände stehen gar nicht erst in der Tafel -- sie
     lassen sich deshalb auch nicht schließen. */
  const wand = await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
    { pfad: "/workspace/crew-index.html", rolle: "admin", erlaubt: false }, "PUT");
  ok(wand.code === 400, `und eine Zugangswand auch nicht (${wand.code})`);
}

/* =======================================================================
   7. EINE UMSTELLUNG ÜBERLEBT EINEN NEUSTART
   ======================================================================= */
melde("");
melde("=== 7. Nach einem Neustart ===");
{
  await roh("/workspace/api/rechte/feld", HAUS, { cookie: kDogi },
    { pfad: PROBE, rolle: "modi", erlaubt: false }, "PUT");

  /* DEN NEUSTART NACHSTELLEN: die Tafel auf den Grundstand
     zuruecksetzen (so, wie sie nach einem frischen Start waere) und
     dann den Ladevorgang aufrufen, den index.js beim Start macht.

     OHNE DIESEN AUFRUF GAELTE NACH EINEM NEUSTART WIEDER DER
     GRUNDSTAND -- und niemand haette es gemerkt, denn es saehe aus wie
     vorher. Genau das ist die Sorte Fehler, die man nur findet, wenn
     man danach sucht. */
  rechte.tafelSetzen(null);
  ok(rechte.darfSeite({ rolle: "modi" }, PROBE) === true,
    "ohne geladene Abweichungen gilt der Grundstand");
  const stand = modul.tafelLaden();
  ok(stand.abweichungen === 1, `tafelLaden() findet die Abweichung (${stand.abweichungen})`);
  ok(rechte.darfSeite({ rolle: "modi" }, PROBE) === false,
    "und danach gilt sie wieder");

  const nachher = await roh(PROBE, CREW, { cookie: kModi });
  ok(nachher.code !== 200, `auch für den Modi im Browser (${nachher.code})`);

  await roh("/workspace/api/rechte/abweichungen", HAUS, { cookie: kDogi }, null, "DELETE");
  ok(rechte.darfSeite({ rolle: "modi" }, PROBE) === true, "und am Ende ist alles wieder offen");
}

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