dogfather-universe/server/pruef-zentrale-ring.mjs

/* =====================================================================
   DER RING OBEN ZEIGT ARBEIT, NICHT DIE UHRZEIT (17.09.2026)

   Auf der Startseite von Creator, rechter Hand und Modis steht das
   groesste Element ganz oben: ein Ring mit einer Prozentzahl und dem
   Wort darunter. Bis heute rechnete er:

       prozent = (aktuelle Stunde - 6) / 18

   ...und nannte das "Tag geschafft". Um 9 Uhr also 17 %, um 23 Uhr
   94 % -- voellig unabhaengig davon, ob jemand etwas getan hatte.

   AUFGEFALLEN IST ES AUF EINEM BILDSCHIRMFOTO: Bei einem Modi stand
   "0 % TAG GESCHAFFT", waehrend sie ueberhaupt nichts offen hatte.
   Jede der beiden Angaben war fuer sich richtig. Zusammen waren sie
   Unsinn -- und es war das Erste, was sie morgens sah.

   ---------------------------------------------------------------------
   WAS DIESE PRUEFUNG SICHERT

   Drei Faelle, und der dritte ist der, an dem so etwas wieder
   kaputtgeht:

     1. Es liegt etwas an, ein Teil ist fertig -> ein Anteil
     2. Es liegt NICHTS an                     -> voll, und es steht da
     3. Es liegt etwas an, NICHTS ist fertig   -> null

   Fall 3 ist der wichtige. Die naheliegende Rechnung waere "was ist
   heute faellig" -- dann meldete der Ring bei drei UEBERFAELLIGEN
   Sachen "nichts faellig, alles gut". Das waere derselbe Fehler noch
   einmal, nur mit anderen Zahlen. Gezaehlt wird deshalb, was heute auf
   dem Tisch liegt: faellig ODER laenger offen.

   UND DIE GEGENPROBE: Zwischen zwei Abfragen wird eine Aufgabe fertig
   gemacht. Der Ring MUSS sich bewegen. Ohne diesen Teil koennte er
   dauerhaft dieselbe Zahl liefern und alle Faelle oben bestehen.

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

import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { eigenerPort } from "./helfer-port.mjs";
import { heuteLokal, tagLokal } from "./helfer-tag.mjs";

const PORT = await eigenerPort(import.meta, "pruef-zentrale-ring");
const ordner = mkdtempSync(join(tmpdir(), "ws-ring-"));
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-zentrale-ring");
await new Promise((r) => setTimeout(r, 700));
const BASIS = `http://127.0.0.1:${PORT}`;

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 { 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();
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;
}

/* Drei Menschen mit drei Lagen -- getrennt, damit sich die Faelle nicht
   gegenseitig beeinflussen. Ein einziger Mensch, bei dem zwischendurch
   Zeilen geloescht werden, misst am Ende den Loeschvorgang mit. */
const idTut  = anlegen("Marina", "modi", "CODE-TUT-00001");
const idLeer = anlegen("Nane",   "modi", "CODE-LEER-0001");
const idSaeu = anlegen("Rieke",  "modi", "CODE-SAEU-0001");

const setzen = (personId, status, frist, erledigtAm = null) =>
  d.prepare(`INSERT INTO aufgaben (titel, status, verantwortlich_id, frist, erledigt_am, erstellt)
             VALUES (?,?,?,?,?,?)`)
    .run("Sache", status, personId, frist, erledigtAm, jetzt);

/* 1. Etwas liegt an, ein Teil ist fertig: 2 offen (eins ueberfaellig,
      eins heute) + 1 heute erledigt -> 1 von 3 -> 33 % */
setzen(idTut, "offen", tagLokal(-2));
setzen(idTut, "offen", heuteLokal());
setzen(idTut, "erledigt", heuteLokal(), jetzt);
/* Und Dinge, die NICHT mitzaehlen duerfen: morgen faellig, und etwas,
   das vorgestern fertig wurde. Ohne sie waere nicht geprueft, dass der
   Ring den TAG meint und nicht die Gesamtlage. */
setzen(idTut, "offen", tagLokal(3));
setzen(idTut, "erledigt", tagLokal(-9), new Date(Date.now() - 2 * 86400_000).toISOString());

/* 2. Es liegt nichts an -- nur etwas in der Zukunft. */
setzen(idLeer, "offen", tagLokal(5));

/* 3. Drei UEBERFAELLIGE, nichts fertig. Der Fall, an dem eine Rechnung
      ueber "heute faellig" faelschlich "alles gut" melden wuerde. */
setzen(idSaeu, "offen", tagLokal(-4));
setzen(idSaeu, "offen", tagLokal(-3));
setzen(idSaeu, "arbeit", tagLokal(-1));
/* DREI TERMINE IN DERSELBEN STUNDE -- der Fall, an dem "kommt noch"
   Stunden statt Termine zaehlte und deshalb 1 statt 3 meldete. Die
   Stunde liegt bewusst spaet, damit sie in JEDER Tageszeit noch in der
   Zukunft liegt; eine Pruefung, die nur vormittags gruen ist, waere
   eine Zeitbombe. */
const SPAET = 23;
for (let i = 0; i < 3; i++) {
  d.prepare(`INSERT INTO termine (titel, beginn, dauer_min, teilnehmer_id, erstellt, erstellt_von)
             VALUES (?,?,?,?,?,?)`)
    .run("Sendung", `${heuteLokal()}T${SPAET}:${String(10 + i * 5).padStart(2, "0")}:00`,
      30, idTut, jetzt, idTut);
}

d.close();

/* =====================================================================
   DIE ANMELDUNG WAR SEIT DEM 01.10.2026 KAPUTT (repariert 07.10.2026)
   =====================================================================

   Hier stand `rolle: "creator"` -- die drei Testleute weiter oben sind
   aber als `modi` angelegt. Das ging jahrelang gut, weil der stille
   Zugang JEDE Kachel durchliess. Seit die Kachel bindend ist, wird die
   Anmeldung abgewiesen, und `/workspace/api/zentrale` antwortete
   `{"fehler":"nicht_angemeldet"}`.

   WAS DANN PASSIERTE, IST DER EIGENTLICHE SCHADEN: Die Pruefung las
   `r.titel` und `r.prozent` aus einer Fehlermeldung -- also `undefined`.
   Dreizehn Zeilen wurden rot, und sie zeigten alle auf den Ring, der
   voellig in Ordnung war. Eine davon wurde sogar GRUEN:
   `r.prozent !== 20 && r.prozent !== 40` stimmt fuer `undefined`
   natuerlich -- ein Haken, der nichts geprueft hat.

   ZWEI DINGE SIND NOETIG, und beide aus demselben Grund (die Kachel
   gilt):
     1. Die ROLLE muss stimmen -- `modi`, nicht `creator`.
     2. Die WAND muss stimmen -- die Modi-Kachel steht auf der
        Crew-Adresse, nicht auf der Agenturwand.

   UND DESHALB node:http STATT fetch: `fetch` (undici) setzt den
   Host-Kopf selbst aus der Adresse und wirft einen mitgegebenen weg.
   Mit fetch laesst sich die Crew-Wand gar nicht ansprechen -- genau
   diese Stelle steht seit dem 22.09. auch in pruef-chat-kanaele und
   pruef-modi-verborgen. */
const { request: httpAnfrage } = await import("node:http");
const CREW_WAND = "crew.dogfather-universe.com";

function anAlsModi(pfad, art, rumpfObjekt, keks) {
  return new Promise((fertig, schief) => {
    const rumpf = rumpfObjekt ? JSON.stringify(rumpfObjekt) : null;
    const a = httpAnfrage({
      host: "127.0.0.1", port: PORT, path: pfad, method: art,
      headers: {
        Host: CREW_WAND,
        ...(keks ? { Cookie: keks } : {}),
        ...(rumpf ? { "Content-Type": "application/json",
          "Content-Length": Buffer.byteLength(rumpf) } : {}),
      },
    }, (antwort) => {
      let text = "";
      antwort.on("data", (t) => { text += t; });
      antwort.on("end", () => fertig({
        code: antwort.statusCode,
        kekse: [].concat(antwort.headers["set-cookie"] || [])
          .map((z) => z.split(";")[0]).join("; "),
        daten: (() => { try { return JSON.parse(text); } catch { return null; } })(),
      }));
    });
    a.on("error", schief);
    if (rumpf) a.write(rumpf);
    a.end();
  });
}

async function ring(code) {
  const an = await anAlsModi("/workspace/api/anmelden", "POST", { rolle: "modi", code });
  /* DER DRITTE AUSGANG: Scheitert die Anmeldung, ist das KEIN Befund
     am Ring -- und genau so soll es dastehen. Sonst sucht beim
     naechsten Mal wieder jemand dreizehn Fehler an einer Stelle, an
     der keiner ist. */
  if (an.code !== 200 || !an.kekse) {
    throw new Error(`KONNTE NICHT NACHSEHEN: Anmeldung als Modi misslang `
      + `(HTTP ${an.code}, ${JSON.stringify(an.daten)}). `
      + `Die Kachel gilt seit dem 01.10.2026 -- Rolle und Wand muessen zusammenpassen.`);
  }
  const a = await anAlsModi("/workspace/api/zentrale", "GET", null, an.kekse);
  if (a.code !== 200) {
    throw new Error(`KONNTE NICHT NACHSEHEN: /api/zentrale antwortete ${a.code} `
      + `(${JSON.stringify(a.daten)})`);
  }
  return a.daten;
}

/* =======================================================================
   1. ES LIEGT ETWAS AN
   ======================================================================= */
melde("");
melde("=== 1. Etwas liegt an, ein Teil ist fertig ===");
{
  const r = await ring("CODE-TUT-00001");
  ok(r.titel === "Heute geschafft", `der Ring heisst "${r.titel}"`);
  ok(r.prozent === 33, `und steht auf ${r.prozent} % (1 von 3)`);
  /* DIE ENTSCHEIDENDE ABGRENZUNG: Ohne diese Zeile koennte der Ring
     alle fuenf Zeilen zaehlen und zufaellig auch auf eine plausible
     Zahl kommen. */
  ok(r.prozent !== 20 && r.prozent !== 40,
    "morgen und vorgestern zaehlen nicht mit");
}

/* =======================================================================
   2. ES LIEGT NICHTS AN
   ======================================================================= */
melde("");
melde("=== 2. Es liegt nichts an ===");
{
  const r = await ring("CODE-LEER-0001");
  /* GAR KEINE ZAHL, WENN ES NICHTS ZU TUN GAB (berichtigt 20.09.2026).

     Hier stand `prozent === 100`. Der Gedanke dahinter war richtig --
     ein leerer Ring darf nicht wie "du hast nichts geschafft"
     aussehen --, die Umsetzung aber nicht: Gelesen wird zuerst die
     Zahl in der Mitte, und "100 %" heisst fuer jeden Menschen
     "fertig", nicht "leer". Am ersten Tag, ohne eine einzige Aufgabe,
     stand damit "100 % — HEUTE NICHTS OFFEN" als groesstes Element
     der Startseite.

     Seit dem 19.09. steht dort ein STRICH statt einer Zahl. Das ist
     die ehrlichere Antwort: Ein Anteil von nichts ist keine Null und
     keine Hundert, sondern nicht definiert. Geprueft wird deshalb der
     Strich -- und dass gar keine Zahl gezeigt wird. */
  ok(r.mitte === "–", `kein Prozentwert, sondern ein Strich (${r.mitte ?? "—"})`);
  /* UND ES STEHT IN WORTEN DA. Ein voller Ring ohne Erklaerung waere
     wieder eine Zahl, bei der man raten muss -- genau der Fehler, der
     hier repariert wurde. */
  ok(r.titel === "Heute nichts offen", `und er sagt es: "${r.titel}"`);
}

/* =======================================================================
   3. ÜBERFÄLLIG IST NICHT "NICHTS"
   ======================================================================= */
melde("");
melde("=== 3. Drei ueberfaellige Sachen ===");
{
  const r = await ring("CODE-SAEU-0001");
  ok(r.prozent === 0, `leerer Ring (${r.prozent} %)`);
  ok(r.titel === "Heute geschafft",
    `und NICHT "nichts offen" -- ueberfaellig liegt an ("${r.titel}")`);
}

/* =======================================================================
   4. GEGENPROBE: BEWEGT ER SICH?
   ======================================================================= */
melde("");
melde("=== 4. Die Gegenprobe ===");
{
  const vorher = await ring("CODE-SAEU-0001");
  const e = new DatabaseSync(process.env.WORKSPACE_DB);
  /* SQLite kennt ORDER BY im UPDATE nicht (ohne eigenes Uebersetzen).
     Deshalb die Zeile ueber eine Unterabfrage auswaehlen. */
  e.prepare(`UPDATE aufgaben SET status = 'erledigt', erledigt_am = ?
              WHERE id = (SELECT id FROM aufgaben
                           WHERE verantwortlich_id = ? AND status = 'offen'
                           ORDER BY id LIMIT 1)`).run(jetzt, idSaeu);
  e.close();
  const nachher = await ring("CODE-SAEU-0001");
  /* OHNE DIESE ZEILE beweisen die drei Abschnitte darueber nichts: Ein
     Ring, der immer dieselbe Zahl liefert, koennte sie alle bestehen,
     solange die Zahl zufaellig passt. */
  ok(nachher.prozent > vorher.prozent,
    `eine Aufgabe fertig gemacht: ${vorher.prozent} % -> ${nachher.prozent} %`);
  ok(nachher.prozent === 33, `und zwar auf 1 von 3 (${nachher.prozent} %)`);
}

/* =======================================================================
   5. DIE UHRZEIT SPIELT KEINE ROLLE MEHR
   ======================================================================= */
melde("");
melde("=== 5. Was der Ring NICHT mehr ist ===");
{
  /* Die alte Rechnung, wortwoertlich, mit der jetzigen Stunde. Sie
     steht hier, damit auffaellt, wenn jemand sie zurueckholt: Der Ring
     darf nicht zufaellig wieder auf ihren Wert fallen. */
  const alt = Math.round((Math.min(Math.max(new Date().getHours() - 6, 0), 18) / 18) * 100);
  const r = await ring("CODE-LEER-0001");
  /* Auch hier auf den Strich umgestellt: Solange in der Mitte gar
     keine Zahl steht, KANN dort auch nicht der Uhrzeitwert stehen --
     das ist die schaerfere Aussage. Zusaetzlich wird der Wert selbst
     verglichen, damit die Zeile auch dann noch etwas misst, wenn der
     Strich eines Tages wieder einer Zahl weicht. */
  ok(r.mitte === "–" && r.prozent !== alt,
    `die alte Uhrzeit-Rechnung ergaebe jetzt ${alt} %, der Ring zeigt "${r.mitte ?? r.prozent}"`);
}

/* =======================================================================
   6. DIE DREI ZAHLEN UNTER DEM RING
   ======================================================================= */
melde("");
melde("=== 6. Termine heute, kommt noch ===");
{
  const r = await ring("CODE-TUT-00001");
  const schilder = (r.zahlen || []).map((z) => z.schild);
  /* "heute" ALLEIN WAR ZWEIDEUTIG: Der Ring darueber sagt jetzt "Heute
     geschafft" und meint Aufgaben, diese Zahl meint Termine. */
  ok(schilder[0] === "Termine heute",
    `die erste Zahl sagt, WAS heute ist ("${schilder[0]}")`);

  /* UND DER EIGENTLICHE FEHLER: drei Termine in derselben Stunde. */
  const kommtNoch = (r.zahlen || [])[1];
  const jetztStunde = new Date().getHours();
  if (jetztStunde > 23) {
    melde("  --   nach 23 Uhr nicht messbar -- die drei Termine liegen dann hinter uns");
  } else {
    ok(kommtNoch?.wert === 3,
      `drei Termine um 23 Uhr zaehlen als drei, nicht als eine Stunde (${kommtNoch?.wert})`);
  }

  /* GEGENPROBE: Wer keine Termine hat, bekommt hier auch keine -- sonst
     hiesse "3" nur, dass immer 3 herauskommt. */
  const leer = await ring("CODE-LEER-0001");
  ok((leer.zahlen || [])[1]?.wert === 0,
    `und wer keine hat, sieht null (${(leer.zahlen || [])[1]?.wert})`);
  ok((leer.zahlen || [])[0]?.wert === 0,
    `auch bei "Termine heute" (${(leer.zahlen || [])[0]?.wert})`);
}

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