dogfather-universe/server/pruef-alter.mjs

/* =====================================================================
   Das Mindestalter wird eingelöst, nicht behauptet (15.09.2026)

   Letztes Stück von Stufe 8. Auf der Regelseite des Treffs steht seit
   dem 11.09. „ab 18" — und geprüft wurde es nirgends. Eine Regel, die
   nur dasteht, ist keine; im Streitfall ist sie sogar schlechter als
   keine, weil man sie versprochen hat.

   ---------------------------------------------------------------------
   VIER FRAGEN

     1. Kommt jemand ohne Bestätigung herein?          (darf nicht)
     2. Kommt er mit Bestätigung herein?               (muss)
     3. Wird er beim ZWEITEN Mal wieder gefragt?       (darf nicht)
     4. Wird das Team gefragt?                         (darf nicht)

   Die dritte ist die, die man vergisst — und sie ist die, an der eine
   solche Abfrage im Alltag scheitert: Wer sie jedes Mal sieht, klickt
   sie weg, ohne sie zu lesen, und dann bestätigt sie nichts mehr.

   Dazu die unbequemste: Ein richtiger Code mit fehlender Bestätigung
   darf NICHT als Fehlversuch zählen — sonst sperrt sich jemand mit dem
   richtigen Code nach acht Anläufen selbst aus.

   Aufrufen mit:  node server/pruef-alter.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-alter");

const ordner = mkdtempSync(join(tmpdir(), "ws-alter-"));
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-alter");
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 { MINDESTALTER } = await import("./treff-tabellen.js");

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

let idKessi, idRieke;
{
  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;
  };
  anlegen("Filipe", "admin", "CODE-DOGI-0001");
  idRieke = anlegen("Rieke", "hand", "CODE-HAND-0001");
  idKessi = anlegen("Kessi", "gast", "CODE-GAST-0001");
  d.close();
}

function post(pfad, host, koerper, kopf = {}) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({ host: "127.0.0.1", port: PORT, path: pfad, method: "POST",
      headers: { Host: host, "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);
    a.write(JSON.stringify(koerper));
    a.end();
  });
}
function hole(pfad, host, kopf = {}) {
  return new Promise((fertig, schief) => {
    const a = httpAnfrage({ host: "127.0.0.1", port: PORT, path: pfad, method: "GET",
      headers: { Host: host, ...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);
    a.end();
  });
}
const json = (a) => { try { return JSON.parse(a.text); } catch { return {}; } };
const keks = (a) => [].concat(a.kopf?.["set-cookie"] || []).map((c) => c.split(";")[0]).join("; ");
const alterVon = (id) => {
  const d = oeffne();
  const w = d.prepare("SELECT alter_bestaetigt_am FROM personen WHERE id = ?").get(id)?.alter_bestaetigt_am;
  d.close();
  return w;
};

/* =======================================================================
   1. OHNE BESTÄTIGUNG KOMMT NIEMAND HEREIN
   ======================================================================= */
melde("");
melde("=== 1. Ohne Bestätigung ===");
{
  ok(MINDESTALTER === 18, `das Mindestalter steht bei ${MINDESTALTER}`);
  ok(alterVon(idKessi) === null, "Kessi hat noch nichts bestätigt");

  const ohne = await post("/workspace/api/anmelden", CREW, { rolle: "gast", code: "CODE-GAST-0001" });
  ok(ohne.code === 400, `sie kommt nicht herein (${ohne.code})`);
  ok(json(ohne).fehler === "alter_offen",
    `und erfährt, woran es liegt (${json(ohne).fehler})`);
  ok(json(ohne).mindestalter === MINDESTALTER,
    `samt der Zahl, gegen die geprüft wird (${json(ohne).mindestalter})`);
  ok(!keks(ohne), "keine Sitzung dabei — sie ist wirklich draußen");

  /* AUSDRÜCKLICH NEIN ist dasselbe wie gar nichts. */
  const nein = await post("/workspace/api/anmelden", CREW,
    { rolle: "gast", code: "CODE-GAST-0001", alter_ok: false });
  ok(nein.code === 400 && json(nein).fehler === "alter_offen",
    `ein ausdrückliches Nein ebenso (${nein.code})`);

  /* UND KEIN FEHLVERSUCH. Wer den richtigen Code hat, darf sich daran
     nicht selbst aussperren -- acht Anlaeufe, und die IP waere gesperrt. */
  const d = oeffne();
  const versuche = d.prepare("SELECT COUNT(*) AS n FROM versuche").get().n;
  d.close();
  ok(versuche === 0, `und es zählt nicht als Fehlversuch (${versuche} in der Tabelle)`);
}

/* =======================================================================
   2. MIT BESTÄTIGUNG SCHON — UND SIE WIRD FESTGEHALTEN
   ======================================================================= */
melde("");
melde("=== 2. Mit Bestätigung ===");
{
  const mit = await post("/workspace/api/anmelden", CREW,
    { rolle: "gast", code: "CODE-GAST-0001", alter_ok: true });
  ok(mit.code === 200, `mit Häkchen kommt sie herein (${mit.code})`);
  ok(!!keks(mit), "und bekommt eine Sitzung");

  const wann = alterVon(idKessi);
  ok(!!wann, `die Bestätigung steht in der Datenbank (${String(wann).slice(0, 16)})`);
  ok(Math.abs(Date.parse(wann) - Date.now()) < 120_000, "mit dem Zeitpunkt von jetzt");

  const d = oeffne();
  const spur = d.prepare(
    "SELECT detail FROM protokoll WHERE aktion = 'alter_bestaetigt' AND person_id = ?").get(idKessi);
  d.close();
  ok(!!spur, "und im Protokoll");
  ok(/18/.test(spur?.detail || ""), `dort steht, gegen welche Zahl (${spur?.detail})`);
}

/* =======================================================================
   3. BEIM ZWEITEN MAL WIRD NICHT WIEDER GEFRAGT

   Die Frage, die man vergisst -- und an der so eine Abfrage im Alltag
   scheitert: Wer sie jedes Mal sieht, klickt sie weg, ohne sie zu
   lesen. Dann bestaetigt sie nichts mehr.
   ======================================================================= */
melde("");
melde("=== 3. Nur einmal ===");
{
  const vorher = alterVon(idKessi);
  const zweite = await post("/workspace/api/anmelden", CREW,
    { rolle: "gast", code: "CODE-GAST-0001" });
  ok(zweite.code === 200, `ohne Häkchen, und trotzdem herein (${zweite.code})`);
  ok(!!keks(zweite), "mit Sitzung");
  ok(alterVon(idKessi) === vorher,
    "und der Zeitpunkt der Bestätigung bleibt der erste — er wird nicht überschrieben");

  const d = oeffne();
  const spuren = d.prepare(
    "SELECT COUNT(*) AS n FROM protokoll WHERE aktion = 'alter_bestaetigt'").get().n;
  d.close();
  ok(spuren === 1, `und es steht genau einmal im Protokoll (${spuren})`);
}

/* =======================================================================
   4. DAS TEAM WIRD NICHT GEFRAGT
   ======================================================================= */
melde("");
melde("=== 4. Nur die Community ===");
{
  const hand = await post("/workspace/api/anmelden", CREW,
    { rolle: "hand", code: "CODE-HAND-0001" });
  ok(hand.code === 200, `die rechte Hand kommt ohne Häkchen herein (${hand.code})`);
  ok(alterVon(idRieke) === null,
    "und es wird nichts über ihr Alter gespeichert — sie wurde nie gefragt");

  const chef = await post("/workspace/api/anmelden", HAUS,
    { rolle: "admin", code: "CODE-DOGI-0001" });
  ok(chef.code === 200, `DogFather ebenso (${chef.code})`);
}

/* =======================================================================
   5. DER REGELTEXT UND DIE TÜR NENNEN DIESELBE ZAHL

   Bis heute standen sie an zwei Stellen. Ein Regeltext, der sich selbst
   widerspricht, ist rechtlich das Gegenteil dessen, wofuer er da ist.
   ======================================================================= */
melde("");
melde("=== 5. Eine Zahl, nicht zwei ===");
{
  const anm = await post("/workspace/api/anmelden", CREW,
    { rolle: "gast", code: "CODE-GAST-0001" });
  const regeln = json(await hole("/workspace/api/treff/regeln", CREW, { cookie: keks(anm) }));
  ok(regeln.mindestalter === MINDESTALTER,
    `der Regeltext nennt ${regeln.mindestalter}`);

  /* Und die Tuer nennt dieselbe -- gemessen an einem frischen Zugang,
     nicht behauptet. */
  const d = oeffne();
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync("CODE-NEU-00000001", salt, 64,
    { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  const sch = d.prepare("SELECT wert FROM einstellungen WHERE schluessel = 'code_kennung_schluessel'").get().wert;
  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, code_kennung, aktiv, erstellt)"
    + " VALUES ('Neu','gast',?,?,?,?,1,?)")
    .run(hash, salt, 32768, createHmac("sha256", sch).update("CODE-NEU-00000001").digest("hex"), jetzt);
  d.close();
  const tuer = await post("/workspace/api/anmelden", CREW,
    { rolle: "gast", code: "CODE-NEU-00000001" });
  ok(json(tuer).mindestalter === regeln.mindestalter,
    `und die Tür dieselbe (${json(tuer).mindestalter})`);

  /* GEGENPROBE zum Vergleich selbst: Zwei verschiedene Zahlen muessten
     auffallen -- sonst waere die Zeile darueber auch bei undefined gruen. */
  ok(regeln.mindestalter !== undefined && regeln.mindestalter !== null,
    "und beide Zahlen gibt es wirklich");
}

/* =======================================================================
   6. DAS HÄKCHEN STEHT AN DER WAND — UND NUR DORT
   ======================================================================= */
melde("");
melde("=== 6. An der Wand ===");
{
  const { readFileSync } = await import("node:fs");
  const crew = readFileSync(new URL("../workspace/crew-index.html", import.meta.url), "utf8");
  const agentur = readFileSync(new URL("../workspace/index.html", import.meta.url), "utf8");
  ok(/id="alterfrage"/.test(crew), "die Wand von Team Dogi hat die Frage");
  ok(!/id="alterfrage"/.test(agentur),
    "die Agenturwand nicht — dort gibt es die Community-Kachel gar nicht");
  ok(/id="alter-zahl">18</.test(crew), "die Zahl steht als Vorgabe im Text");
  ok(/hidden/.test(crew.split('id="alterfrage"')[1].slice(0, 40)),
    "und sie ist zunächst verborgen — sie erscheint mit der Kachel");
}

/* =======================================================================
   7. IM BROWSER: ERSCHEINT SIE, UND WIRKT SIE?
   ======================================================================= */
melde("");
melde("=== 7. Im Browser ===");
{
  const { chromium } = await import(
    "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
  const browser = await chromium.launch();
  /* 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", (m) => { if (m.type() === "error" && !/favicon|ERR_/i.test(m.text())) konsole.push(m.text()); });
  seite.on("pageerror", (e) => konsole.push("Absturz: " + e.message));

  /* Die Crew-Wand haengt am Host-Kopf. Ueber 127.0.0.1 kommt die
     Agenturwand -- deshalb die Datei direkt ansehen ist keine Loesung.
     Playwright kann den Host-Kopf fuer Navigationen nicht setzen; also
     wird hier geprueft, was OHNE Server zu pruefen ist: das Verhalten
     der Kachelauswahl auf der ausgelieferten Seite. */
  await seite.goto(`http://127.0.0.1:${PORT}/workspace/crew-index.html`,
    { waitUntil: "domcontentloaded" });
  await seite.waitForTimeout(400);

  const start = await seite.evaluate(() => {
    const f = document.getElementById("alterfrage");
    return { da: !!f, verborgen: f?.hidden };
  });
  ok(start.da === true, "die Frage steht auf der ausgelieferten Seite");
  ok(start.verborgen === true, "und ist zu Beginn verborgen");

  await seite.click('.rolle[data-rolle="gast"]');
  await seite.waitForTimeout(200);
  const nachGast = await seite.evaluate(() => document.getElementById("alterfrage")?.hidden);
  ok(nachGast === false, "nach dem Tippen auf „Community“ erscheint sie");

  /* GEGENPROBE: bei einer anderen Kachel verschwindet sie wieder --
     sonst waere „erscheint" auch dann gruen, wenn sie immer da ist. */
  await seite.click('.rolle[data-rolle="modi"]');
  await seite.waitForTimeout(200);
  const nachModi = await seite.evaluate(() => document.getElementById("alterfrage")?.hidden);
  ok(nachModi === true, "bei einer anderen Kachel verschwindet sie wieder");

  /* Und der Haken faellt dabei zurueck -- wer die Kachel wechselt, soll
     nicht mit einer Bestaetigung dastehen, die er fuer etwas anderes
     gesetzt hat. */
  await seite.click('.rolle[data-rolle="gast"]');
  await seite.check("#alter-ok");
  await seite.click('.rolle[data-rolle="modi"]');
  await seite.click('.rolle[data-rolle="gast"]');
  const haken = await seite.evaluate(() => document.getElementById("alter-ok")?.checked);
  ok(haken === false, "und ein gesetzter Haken fällt beim Wechseln zurück");

  /* Beruehrziel: 24 px ist das Mindestmass nach WCAG 2.5.8. */
  const ziel = await seite.evaluate(() => {
    const z = document.querySelector(".alterfrage__zeile");
    if (!z) return null;
    const r = z.getBoundingClientRect();
    return { h: Math.round(r.height), w: Math.round(r.width) };
  });
  ok(ziel && ziel.h >= 40, `die Zeile ist ${ziel?.h} px hoch — ein Daumen trifft sie`);

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