dogfather-universe/server/pruef-befinden.mjs

/* =====================================================================
   Wie geht's dir? (15.09.2026)

   Filipe, mit dem Bildschirmfoto der Kachel: „ich will dass du diese
   seite perfektionnierst, denn gerade wenn ich drauf drücke geht die
   entwicklungsseite auf."

   ---------------------------------------------------------------------
   DER FEHLER WAR SCHLIMMER ALS EIN FALSCHER VERWEIS

   Auf der Kachel steht „die Antworten sieht nur du" — und sie öffnete
   eine Seite voller Namen und Beobachtungen über ANDERE Menschen. Die
   erste Prüfung hier ist deshalb: Führt die Kachel dorthin, wo sie
   hinführt zu führen verspricht?

   ---------------------------------------------------------------------
   UND DIE EIGENTLICHE FRAGE: BLEIBT ES PRIVAT?

   Ein Verlauf über das Befinden eines Menschen ist das Empfindlichste,
   was dieses Haus speichert. Er existiert nur, weil er IHM hilft. Also:

     Sieht DogFather ihn?                       (darf nicht)
     Steht etwas davon im Protokoll?            (nur DASS, nie WAS)
     Ändert er die Ampel?                       (darf nicht)

   Aufrufen mit:  node server/pruef-befinden.mjs
   ===================================================================== */

import { mkdtempSync, rmSync, readFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { request as httpAnfrage } from "node:http";
import { portMussFreiSein } from "./helfer-port.mjs";

const PORT = await portMussFreiSein(4419, "pruef-befinden");

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

const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
await import("./index.js");
notbremse(180_000, "pruef-befinden");
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 modul = await import("./workspace-befinden.js");
const kat = await import("./workspace-entwicklungs-punkte.js");
const rechte = await import("./rechte.js");

const oeffne = () => new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();

let idDogi, idFrida;
{
  const d = oeffne();
  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 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;
  };
  idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
  idFrida = anlegen("Frida", "modi", "CODE-MODI-0001");
  d.close();
}

function ruf(pfad, host, methode, kopf = {}, koerper = null) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({ host: "127.0.0.1", port: PORT, path: pfad, method: methode,
      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 ruf("/workspace/api/anmelden", host, "POST", {}, { rolle, code });
  return [].concat(r.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
}
/* DOGFATHER AUF DER TEAM-ADRESSE.

   Nicht aus Bequemlichkeit: Auf workspace. liefert der Server ihm
   `bereiche: null` -- der Browser nimmt dort seine eigene Liste, und
   die kennt diese Kachel gar nicht. Die Kachel, die Filipe im
   Bildschirmfoto angetippt hat, steht auf crew. Wer sie auf der
   falschen Adresse sucht, prueft an ihr vorbei. */
const kDogi = await anmelden("admin", "CODE-DOGI-0001", CREW);
const kFrida = await anmelden("modi", "CODE-MODI-0001", CREW);
ok(!!kDogi && !!kFrida, "DogFather und ein Modi sind angemeldet");

/* =======================================================================
   1. DIE KACHEL HÄLT, WAS SIE VERSPRICHT

   Der gemeldete Fehler. Er war schlimmer als ein falscher Verweis: Auf
   der Kachel steht „die Antworten sieht nur du" -- und sie oeffnete
   eine Seite voller Namen anderer Menschen.
   ======================================================================= */
melde("");
melde("=== 1. Die Kachel ===");
{
  const ich = json(await ruf("/workspace/api/ich", CREW, "GET", { cookie: kDogi }));
  const alle = [...(ich.bereiche || []), ...(ich.bereiche_zusatz || [])];
  const kachel = alle.find((k) => /Wie geht/i.test(k.name || ""));
  ok(!!kachel, `die Kachel „${kachel?.name}“ steht bei DogFather`);
  ok(kachel?.ziel === "befinden.html",
    `und zeigt auf die eigene Seite (${kachel?.ziel})`);
  /* GEGENPROBE -- ohne sie beweist die Zeile nichts: Die Kachel
     „Entwicklung" zeigt weiterhin auf die Entwicklungsseite. */
  const andere = alle.find((k) => k.name === "Entwicklung");
  ok(andere?.ziel === "entwicklung.html",
    `die Kachel „Entwicklung“ zeigt weiterhin dorthin (${andere?.ziel})`);

  ok((rechte.tafelJetzt()["/workspace/befinden.html"] || []).includes("modi"),
    "die Seite steht in der Rechtetafel und ein Modi darf sie öffnen");
  ok(!(rechte.tafelJetzt()["/workspace/befinden.html"] || []).includes("creator"),
    "die Agentur nicht — sie hat auch keine Entwicklungskarte");

  const beiFrida = json(await ruf("/workspace/api/ich", CREW, "GET", { cookie: kFrida }));
  const ihre = [...(beiFrida.bereiche || []), ...(beiFrida.bereiche_zusatz || [])]
    .find((k) => /Wie geht/i.test(k.name || ""));
  ok(ihre?.ziel === "befinden.html", "und bei einem Modi führt sie ebenfalls dorthin");
}

/* =======================================================================
   2. SECHS FRAGEN, EIN RHYTHMUS
   ======================================================================= */
melde("");
melde("=== 2. Sechs Fragen, ein Rhythmus ===");
{
  const d = json(await ruf("/workspace/api/befinden", CREW, "GET", { cookie: kFrida }));
  ok(d.punkte?.length === kat.ENTWICKLUNG_SELBST.length,
    `${d.punkte?.length} Fragen — so viele wie im Katalog`);
  /* Die Recherche: fuenf bis fuenfzehn, unter zwei Minuten. Sechs sind
     richtig; zwanzig waeren es nicht. */
  ok(d.punkte.length >= 5 && d.punkte.length <= 15,
    "zwischen fünf und fünfzehn — kurz genug, dass man sie wirklich beantwortet");
  ok(d.rhythmus_tage === modul.RHYTHMUS_TAGE,
    `alle ${d.rhythmus_tage} Tage wird wieder gefragt`);
  ok(d.rhythmus?.faellig === true, "am Anfang ist sofort etwas fällig");
  ok(d.rhythmus?.letzte === null, "und es gab noch keine Runde");
  ok(Array.isArray(d.verlauf) && d.verlauf.length === 0, "der Verlauf ist leer");

  /* EINE HALBE RUNDE IST KEINE RUNDE. */
  const halb = await ruf("/workspace/api/befinden/runde", CREW, "POST", { cookie: kFrida }, {});
  ok(halb.code === 400, `ohne Antworten lässt sich nichts festhalten (${halb.code})`);
  ok(json(halb).fehler === "unvollstaendig"
    && json(halb).offen === d.punkte.length,
    `und die Absage sagt, wie viele fehlen (${json(halb).offen} von ${json(halb).gesamt})`);
}

/* =======================================================================
   3. EINE RUNDE, EIN VERLAUF
   ======================================================================= */
melde("");
melde("=== 3. Der Verlauf entsteht ===");
{
  const d = json(await ruf("/workspace/api/befinden", CREW, "GET", { cookie: kFrida }));
  for (const p of d.punkte) {
    await ruf(`/workspace/api/entwicklung/mich/${p.schluessel}`, CREW, "PUT",
      { cookie: kFrida }, { stufe: "laeuft" });
  }
  const erste = await ruf("/workspace/api/befinden/runde", CREW, "POST", { cookie: kFrida }, {});
  ok(erste.code === 201, `mit allen Antworten geht es (${erste.code})`);
  ok(json(erste).anzahl === d.punkte.length,
    `${json(erste).anzahl} Antworten sind in den Verlauf gewandert`);

  const nach = json(await ruf("/workspace/api/befinden", CREW, "GET", { cookie: kFrida }));
  ok(nach.verlauf.length === 1, `der Verlauf hat ${nach.verlauf.length} Runde`);
  ok(nach.rhythmus.faellig === false,
    "und es ist erst einmal nichts mehr fällig — die Seite fragt nicht jeden Tag");
  ok(nach.rhythmus.vollstaendig === true, "die Runde gilt als vollständig");

  /* Eine zweite Runde mit anderen Antworten -- erst dann gibt es ein
     Muster, und erst dann ist der Verlauf ueberhaupt etwas wert. */
  await ruf(`/workspace/api/entwicklung/mich/${d.punkte[0].schluessel}`, CREW, "PUT",
    { cookie: kFrida }, { stufe: "hakt", anlass: "Diese Woche war viel los." });
  const zweite = await ruf("/workspace/api/befinden/runde", CREW, "POST", { cookie: kFrida }, {});
  ok(zweite.code === 201, `eine zweite Runde geht auch sofort (${zweite.code})`);

  const nach2 = json(await ruf("/workspace/api/befinden", CREW, "GET", { cookie: kFrida }));
  ok(nach2.verlauf.length === 2, `jetzt ${nach2.verlauf.length} Runden`);
  const neu = nach2.verlauf[0].antworten[d.punkte[0].schluessel];
  const alt = nach2.verlauf[1].antworten[d.punkte[0].schluessel];
  ok(neu === "hakt" && alt === "laeuft",
    `und man sieht die Veränderung (${alt} → ${neu})`);
  /* DIE ANTWORTEN DER ALTEN RUNDE BLEIBEN, WIE SIE WAREN. Ein Verlauf,
     der sich rueckwirkend aendert, ist kein Verlauf. */
  ok(Object.keys(nach2.verlauf[1].antworten).length === d.punkte.length,
    "die alte Runde steht unverändert da");
}

/* =======================================================================
   4. ES BLEIBT PRIVAT

   Die eigentliche Frage. Ein Verlauf ueber das Befinden eines Menschen
   ist das Empfindlichste, was dieses Haus speichert.
   ======================================================================= */
melde("");
melde("=== 4. Privat ===");
{
  /* DogFather bekommt SEINEN Verlauf, nicht ihren. */
  const seiner = json(await ruf("/workspace/api/befinden", CREW, "GET", { cookie: kDogi }));
  ok(seiner.verlauf.length === 0,
    `DogFather hat einen eigenen, leeren Verlauf (${seiner.verlauf.length})`);

  /* Es gibt gar keinen Weg zu einem fremden. */
  const fremd = await ruf(`/workspace/api/befinden?person=${idFrida}`, CREW, "GET", { cookie: kDogi });
  ok(json(fremd).verlauf?.length === 0,
    "auch mit einer fremden Nummer in der Adresse bekommt er nur seinen eigenen");

  /* Im Protokoll steht nur, DASS eine Runde war -- nie was darin stand. */
  const d = oeffne();
  const spur = d.prepare(
    "SELECT detail FROM protokoll WHERE aktion = 'befinden_runde' ORDER BY id DESC").all();
  const verlaufZeilen = d.prepare("SELECT COUNT(*) AS n FROM befinden_verlauf").get().n;
  d.close();
  ok(spur.length === 2, `${spur.length} Runden stehen im Protokoll`);
  ok(spur.every((z) => !/laeuft|hakt|waechst|unklar/.test(z.detail || "")),
    `aber keine einzige Antwort darin (${spur[0]?.detail})`);
  ok(verlaufZeilen === 12, `im Verlauf liegen ${verlaufZeilen} Antworten (2 Runden x 6)`);

  /* UND DIE AMPEL ZAEHLT WEITER NUR DEN AKTUELLEN STAND, ohne Namen. */
  const a = await ruf("/workspace/api/entwicklung/ampel", CREW, "GET", { cookie: kDogi });
  ok(a.code === 200, `die Ampel antwortet (${a.code})`);
  ok(!/Frida/.test(a.text), "und nennt keinen Namen");
}

/* =======================================================================
   5. DIE ENTWICKLUNGSSEITE TUT NUR NOCH EINE SACHE
   ======================================================================= */
melde("");
melde("=== 5. Eine Seite, ein Zweck ===");
{
  const e = readFileSync(new URL("../workspace/entwicklung.html", import.meta.url), "utf8");
  const b = readFileSync(new URL("../workspace/befinden.html", import.meta.url), "utf8");

  ok(/href="befinden\.html"/.test(e),
    "die Entwicklungsseite verweist auf die sechs Fragen");
  ok(!/id="meins"/.test(e),
    "und zeichnet sie nicht mehr selbst — zwei Stände wären zwei Wahrheiten");
  ok(/id="fragen"/.test(b) && /id="verlauf"/.test(b),
    "die neue Seite hat die Fragen und den Verlauf");
  /* AUF DER EIGENEN SEITE STEHT KEIN FREMDER NAME -- nicht einmal ein
     Platz dafuer. */
  ok(!/personen-block|meine-karte|abweichung/.test(b),
    "und keinen einzigen Abschnitt über andere Menschen");

  ok(/befinden\.js/.test(b) && !/entwicklung\.js/.test(b),
    "sie lädt ihr eigenes Skript, nicht das der Entwicklungsseite");
}

/* =======================================================================
   6. IM BROWSER
   ======================================================================= */
melde("");
melde("=== 6. Im Browser ===");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  const kontext = await browser.newContext({ viewport: { width: 1280, height: 1000 } });
  const seite = await kontext.newPage();
  const konsole = [];
  seite.on("console", (m) => { if (m.type() === "error" && !/favicon|ERR_/i.test(m.text())) konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));

  /* ALS MODI, NICHT ALS DOGFATHER: Die Seite gehoert dem Menschen, der
     sie oeffnet -- und der haeufigste Fall ist ein Modi. Der Keks kommt
     von der Anmeldung oben, weil Playwright die Host-Kopfzeile beim
     Seitenaufruf nicht setzen kann. */
  await kontext.addCookies(kFrida.split("; ").filter(Boolean).map((teil) => {
    const i = teil.indexOf("=");
    return { name: teil.slice(0, i), value: teil.slice(i + 1), domain: "127.0.0.1", path: "/" };
  }));
  await seite.goto(`http://127.0.0.1:${PORT}/workspace/start.html`, { waitUntil: "networkidle" });
  await seite.waitForTimeout(700);

  /* DER GEMELDETE FEHLER, IM BROWSER NACHGESTELLT: auf die Kachel
     druecken und nachsehen, wo man landet. */
  const ziel = await seite.evaluate(() => {
    const k = [...document.querySelectorAll('a')]
      .find((a) => /Wie geht/i.test(a.textContent || ''));
    return k ? k.getAttribute('href') : null;
  });
  ok(/befinden\.html/.test(ziel || ""),
    `die Kachel auf der Startseite führt zu ${ziel}`);

  await seite.goto(`http://127.0.0.1:${PORT}/workspace/befinden.html`, { waitUntil: "networkidle" });
  await seite.waitForTimeout(900);

  const stand = await seite.evaluate(() => ({
    fragen: document.querySelectorAll('.e-punkt--meins').length,
    knoepfe: document.querySelectorAll('.e-wahl__knopf').length,
    takt: document.getElementById('takt')?.hidden === false,
    taktText: document.getElementById('takt-satz')?.textContent.trim() || '',
    verlauf: document.getElementById('verlauf-block')?.hidden === false,
    spalten: document.querySelectorAll('.b-verlauf__zeile--kopf .b-verlauf__datum').length,
    punkte: document.querySelectorAll('.b-verlauf__punkt').length,
    text: document.querySelector('main')?.innerText || '',
  }));
  ok(stand.fragen >= 5, `${stand.fragen} Fragen stehen auf der Seite`);
  ok(stand.knoepfe === stand.fragen * 4, `mit je vier Knöpfen (${stand.knoepfe})`);
  ok(stand.takt === true, `der Rhythmus steht oben: „${stand.taktText.slice(0, 70)}“`);
  /* FRIDA HAT ZWEI RUNDEN -- bei ihr MUSS er dastehen. */
  ok(stand.verlauf === true, "ihr Verlauf steht auf der Seite");
  ok(stand.spalten === 2, `mit zwei Ständen nebeneinander (${stand.spalten})`);
  ok(stand.punkte === 12, `und zwölf Antworten darin (${stand.punkte})`);
  /* KEIN FREMDER NAME AUF DEM BILDSCHIRM. Ihr eigener darf oben in der
     Kopfleiste stehen -- gemessen wird deshalb nur der Inhalt, und
     gesucht wird nach DogFather, also nach dem, der hier nichts zu
     suchen hat. */
  ok(!/Filipe/.test(stand.text), "und kein anderer Mensch steht darauf");

  /* GEGENPROBE mit einem zweiten Menschen: DogFather hat keine einzige
     Runde. Bei ihm muss derselbe Block WEG sein -- sonst hiesse „er
     erscheint ab der zweiten Runde" nur, dass er immer erscheint. */
  const zweiter = await browser.newContext({ viewport: { width: 1280, height: 1000 } });
  await zweiter.addCookies(kDogi.split("; ").filter(Boolean).map((teil) => {
    const i = teil.indexOf("=");
    return { name: teil.slice(0, i), value: teil.slice(i + 1), domain: "127.0.0.1", path: "/" };
  }));
  const seite2 = await zweiter.newPage();
  await seite2.goto(`http://127.0.0.1:${PORT}/workspace/befinden.html`, { waitUntil: "networkidle" });
  await seite2.waitForTimeout(800);
  const ohne = await seite2.evaluate(() => ({
    fragen: document.querySelectorAll('.e-punkt--meins').length,
    verlauf: document.getElementById('verlauf-block')?.hidden === false,
    knopf: document.getElementById('takt-knopf')?.hidden === false,
  }));
  ok(ohne.fragen >= 5, `auch bei ihm stehen die Fragen da (${ohne.fragen})`);
  ok(ohne.verlauf === false, "aber kein Verlauf — er hat noch keine Runde");
  ok(ohne.knopf === false,
    "und kein Knopf zum Abschließen, solange nichts beantwortet ist");

  ok(konsole.length === 0,
    konsole.length ? "Fehler im Browser: " + konsole[0].slice(0, 90) : "keine Fehler im Browser");
  await browser.close();
}

/* ------------------------------------------------------------------- */
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);