dogfather-universe/server/pruef-pin-fuer-mich.mjs

/* =====================================================================
   EINEN AUSHANG FUER SICH WEGNEHMEN -- ODER FUER ALLE (25.09.2026)
   =====================================================================

   Filipe:

     „jeder soll das fixierte individuel für sich lösen können aber
      niemals so dass es sich für alle löst. außer dogfather macht es
      oder die rechte hand dan ist es bei jedem weg ansonsten sollen
      alle anderen rollen es individuell für sich lösen können.
      dogfather und die rechte hand sollen die option haben für sich
      selbst oder für alle zu lösen."

   ---------------------------------------------------------------------
   DREI FRAGEN, UND DIE MITTLERE IST DIE, UM DIE ES GEHT

     1. Kann jeder den Aushang bei sich wegnehmen? (Und zurueckholen --
        sonst braeuchte es eine Rueckfrage davor.)
     2. BLEIBT ER DABEI BEI ALLEN ANDEREN STEHEN? Das ist der Satz
        „niemals so dass es sich fuer alle loest", und er laesst sich
        nur mit ZWEI Anmeldungen messen: Was der eine wegnimmt, muss
        der andere weiterhin sehen. Eine Pruefung mit einer einzigen
        Sitzung koennte hier gruen sein und trotzdem falsch.
     3. Und duerfen DogFather und die rechte Hand es fuer alle loesen,
        waehrend alle anderen das nicht koennen?

   ---------------------------------------------------------------------
   WARUM DAZU EINE VIERTE FRAGE GEHOERT

   Es haengen hoechstens DREI Aushaenge. Nimmt jemand einen fuer sich
   weg, darf er nicht einfach fehlen -- der naechste muss nachruecken,
   sonst sieht er zwei, waehrend ein vierter danebenliegt und nie
   erscheint. Das ist der Unterschied zwischen „ausgeblendet" und
   „verloren", und man sieht ihn nur, wenn man vier anheftet.

   Aufrufen mit:  node server/pruef-pin-fuer-mich.mjs
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-pinmich-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");

const { eigenerPort } = await import("./helfer-port.mjs");
const PORT = await eigenerPort(import.meta, "die Aushang-Pruefung");

process.env.PORT = `${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(120_000, "pruef-pin-fuer-mich");
await new Promise((r) => setTimeout(r, 1000));
process.on("uncaughtException", (f) => { console.error("ABSTURZ:", f); process.exit(7); });
process.on("unhandledRejection", (f) => { console.error("ABSTURZ (Versprechen):", f); process.exit(7); });

const BASIS = `http://127.0.0.1:${PORT}`;
const CREW = "crew.dogfather-universe.com";

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++; };

/* ---- Leute ---------------------------------------------------------- */
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 sch = randomBytes(32).toString("hex");
d.prepare("INSERT INTO einstellungen (schluessel, wert, geaendert, von)"
  + " VALUES (?,?,?,NULL) ON CONFLICT(schluessel) DO NOTHING")
  .run("code_kennung_schluessel", sch, jetzt);
const anlegen = (name, rolle, code) => {
  const s = randomBytes(16).toString("hex");
  const h = scryptSync(code, s, 64,
    { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
  return d.prepare("INSERT INTO personen"
    + " (name, rolle, code_hash, code_salt, code_n, code_kennung, aktiv, erstellt)"
    + " VALUES (?,?,?,?,?,?,1,?) RETURNING id")
    .get(name, rolle, h, s, 32768,
      createHmac("sha256", sch).update(code).digest("hex"), jetzt).id;
};
const idDogi = anlegen("Filipe", "admin", "CODE-DOGI-0001");
const idHand = anlegen("Rieke", "hand", "CODE-HAND-0001");
const idModi = anlegen("Kessi", "modi", "CODE-MODI-0001");
const idModi2 = anlegen("Mara", "modi", "CODE-MODI-0002");
const idFremd = anlegen("Tili", "modi", "CODE-TILI-0001");
d.close();

/* ==== `node:http` UND NICHT `fetch` ================================

   Diese Pruefung braucht Team-Dogi-Rollen (Modi, rechte Hand), und die
   gibt es nur auf der CREW-Adresse. Dafuer muss der `Host`-Kopf
   gesetzt werden -- und genau den laesst `fetch` nicht zu: Er steht
   auf der Liste der verbotenen Koepfe, undici verwirft ihn stumm.
   Die Anfrage kam damit auf 127.0.0.1 an, waehrend der `Origin`-Kopf
   die Crew-Adresse nannte; `gleicheHerkunft` verglich beides und
   antwortete mit 403 „fremde_herkunft" -- auf JEDE schreibende
   Anfrage. Im ersten Lauf sah das aus, als sei die neue Route kaputt.

   Mit `node:http` setzt man den Kopf selbst, und beides passt
   zusammen. Dieselbe Loesung benutzen pruef-anruf und die anderen
   Pruefungen, die ueber Haeuser hinweg messen. */
const { request: httpAnfrage } = await import("node:http");
const roh = (keks, pfad, methode = "GET", koerper = null) =>
  new Promise((fertig, schief) => {
    const daten = koerper === null ? null : JSON.stringify(koerper);
    const a = httpAnfrage({
      host: "127.0.0.1", port: PORT, path: pfad, method: methode,
      headers: {
        Host: CREW,
        ...(keks ? { Cookie: keks } : {}),
        Origin: `https://${CREW}`,
        Referer: `https://${CREW}/workspace/chat.html`,
        ...(daten ? { "Content-Type": "application/json",
          "Content-Length": Buffer.byteLength(daten) } : {}),
      },
    }, (r) => {
      let t = ""; r.on("data", (x) => { t += x; });
      r.on("end", () => fertig({
        status: r.statusCode, kopf: r.headers, text: t,
        json: () => { try { return JSON.parse(t); } catch { return {}; } },
      }));
    });
    a.on("error", schief);
    if (daten) a.write(daten);
    a.end();
  });

const hol = async (keks, pfad, wie = {}) =>
  roh(keks, pfad, wie.method || "GET", wie.body ? JSON.parse(wie.body) : null);

const anmelden = async (rolle, code) => {
  const a = await roh(null, "/workspace/api/anmelden", "POST", { rolle, code });
  if (a.status !== 200) { console.log(`ABBRUCH: Anmeldung ${rolle} ${a.status}`); process.exit(2); }
  return [].concat(a.kopf["set-cookie"] || []).map((z) => z.split(";")[0]).join("; ");
};

const kDogi = await anmelden("admin", "CODE-DOGI-0001");
const kHand = await anmelden("hand", "CODE-HAND-0001");
const kModi = await anmelden("modi", "CODE-MODI-0001");
const kModi2 = await anmelden("modi", "CODE-MODI-0002");
const kFremd = await anmelden("modi", "CODE-TILI-0001");
ok(!!kDogi && !!kHand && !!kModi && !!kModi2 && !!kFremd, "fuenf Leute sind angemeldet");

/* ---- Ein Raum mit vier Leuten --------------------------------------- */
const gr = await hol(kDogi, "/workspace/api/chat/gruppe", {
  method: "POST", body: JSON.stringify({ name: "Ansagen", mit: [idHand, idModi, idModi2] }),
});
const raumId = (gr.json()).raum_id;
ok(gr.status === 201 && !!raumId, `ein Raum entsteht (${gr.status}, #${raumId})`);

const schreiben = async (keks, text) => {
  const a = await hol(keks, `/workspace/api/chat/raeume/${raumId}/nachrichten`, {
    method: "POST", body: JSON.stringify({ text }),
  });
  const j = a.json();
  return j.nachricht?.id || j.id;
};
const anheften = (keks, id, an) =>
  hol(keks, `/workspace/api/chat/nachrichten/${id}/anheften`, {
    method: "PUT", body: JSON.stringify({ an }),
  });
const fuerMich = (keks, id, aus) =>
  hol(keks, `/workspace/api/chat/nachrichten/${id}/pin-fuer-mich`, {
    method: "PUT", body: JSON.stringify({ aus }),
  });
const aushaenge = async (keks) => {
  const a = await hol(keks, `/workspace/api/chat/raeume/${raumId}/nachrichten`);
  const j = a.json();
  return {
    ids: (j.angeheftet || []).map((x) => x.id),
    darfFuerAlle: Object.fromEntries((j.angeheftet || []).map((x) => [x.id, x.darf_fuer_alle])),
    ausBeiMir: (j.nachrichten || []).filter((n) => n.pin_fuer_mich_aus).map((n) => n.id),
    darfPinFuerAlle: j.darf_pin_fuer_alle,
  };
};

const n1 = await schreiben(kDogi, "Freitag um 20 Uhr geht es los.");
const a1 = await anheften(kDogi, n1, true);
ok(a1.status === 200, `DogFather heftet eine Ansage an (${a1.status})`);

/* =======================================================================
   1. JEDER NIMMT SIE BEI SICH WEG -- UND NUR BEI SICH
   ======================================================================= */
melde("");
melde("=== 1. Fuer mich wegnehmen ===");
{
  const vorher = await aushaenge(kModi);
  ok(vorher.ids.includes(n1), `der Modi sieht die Ansage (${vorher.ids.join(",")})`);

  const weg = await fuerMich(kModi, n1, true);
  ok(weg.status === 200, `er nimmt sie bei sich weg (${weg.status})`);

  const beiIhm = await aushaenge(kModi);
  ok(!beiIhm.ids.includes(n1),
    `bei ihm haengt sie nicht mehr (${beiIhm.ids.join(",") || "nichts"})`);

  /* DER KERN DES GANZEN AUFTRAGS. Ohne diese zwei Zeilen koennte das
     „Wegnehmen" in Wahrheit ein Loesen fuer alle sein, und niemand
     wuerde es bemerken -- bis jemand fragt, wo die Ansage hin ist. */
  const beiDogi = await aushaenge(kDogi);
  const beiModi2 = await aushaenge(kModi2);
  ok(beiDogi.ids.includes(n1), "bei DogFather haengt sie weiter");
  ok(beiModi2.ids.includes(n1), "und beim zweiten Modi auch");

  ok(beiIhm.ausBeiMir.includes(n1),
    "die Nachricht selbst weiss, dass ER sie weggenommen hat");
  ok(!beiModi2.ausBeiMir.includes(n1),
    "  und beim anderen steht das NICHT dran (Gegenprobe)");
}

/* =======================================================================
   2. UND ER HOLT SIE ZURUECK
   ======================================================================= */
melde("");
melde("=== 2. Der Rueckweg ===");
{
  const zurueck = await fuerMich(kModi, n1, false);
  ok(zurueck.status === 200, `er holt sie zurueck (${zurueck.status})`);
  const jetztWieder = await aushaenge(kModi);
  ok(jetztWieder.ids.includes(n1), "sie haengt wieder oben");
  ok(!jetztWieder.ausBeiMir.includes(n1), "und die Marke ist weg");

  /* Noch einmal wegnehmen -- fuer die Pruefungen darunter. Zweimal
     dasselbe darf keinen Fehler geben (ON CONFLICT DO NOTHING). */
  await fuerMich(kModi, n1, true);
  const nochmal = await fuerMich(kModi, n1, true);
  ok(nochmal.status === 200, `zweimal wegnehmen ist kein Fehler (${nochmal.status})`);
}

/* =======================================================================
   3. FUER ALLE LOESEN DARF NICHT JEDER
   ======================================================================= */
melde("");
melde("=== 3. Fuer alle loesen ===");
{
  const modiVersuch = await anheften(kModi, n1, false);
  ok(modiVersuch.status === 403,
    `ein Modi kann sie NICHT fuer alle loesen (${modiVersuch.status})`);
  const grund = modiVersuch.json();
  ok(/für dich selbst/i.test(grund.fehler || ""),
    `  und die Absage sagt, was stattdessen geht ("${(grund.fehler || "").slice(0, 60)}")`);

  const nochDa = await aushaenge(kModi2);
  ok(nochDa.ids.includes(n1), "  die Ansage haengt nach dem Versuch weiter");

  const lage = await aushaenge(kModi);
  ok(lage.darfPinFuerAlle === false, "der Modi bekommt die Wahl gar nicht angeboten");
  const lageDogi = await aushaenge(kDogi);
  ok(lageDogi.darfPinFuerAlle === true, "DogFather schon");
  ok(lageDogi.darfFuerAlle[n1] === true, "  und an der Ansage steht es auch");
}

/* =======================================================================
   4. DIE RECHTE HAND DARF ES -- UND DANN IST SIE BEI JEDEM WEG
   ======================================================================= */
melde("");
melde("=== 4. Die rechte Hand loest fuer alle ===");
{
  const los = await anheften(kHand, n1, false);
  ok(los.status === 200, `die rechte Hand loest fuer alle (${los.status})`);

  for (const [wer, keks] of [["DogFather", kDogi], ["Modi 2", kModi2], ["die Hand", kHand]]) {
    const l = await aushaenge(keks);
    ok(!l.ids.includes(n1), `bei ${wer} ist sie weg`);
  }
}

/* =======================================================================
   5. WER SELBST ANGEHEFTET HAT, NIMMT ES AUCH ZURUECK
   =======================================================================

   Steht nicht in Filipes Satz und ist trotzdem noetig: Es haengen
   hoechstens drei. Eine Gruppenleitung, die drei angeheftet hat und
   keinen abnehmen darf, koennte nie wieder etwas anheften. */
melde("");
melde("=== 5. Wer anheftet, darf auch abheften ===");
{
  /* Der zweite Modi bekommt die Leitung im Raum -- dann darf er
     anheften. */
  const dd = new DatabaseSync(process.env.WORKSPACE_DB);
  dd.prepare("UPDATE chat_teilnehmer SET leitung = 1 WHERE raum_id = ? AND person_id = ?")
    .run(raumId, idModi2);
  dd.close();

  const n2 = await schreiben(kModi2, "Kurze Zwischenansage.");
  const an2 = await anheften(kModi2, n2, true);
  ok(an2.status === 200, `der zweite Modi darf anheften (${an2.status})`);

  const seins = await aushaenge(kModi2);
  ok(seins.darfFuerAlle[n2] === true, "  und darf seinen eigenen Aushang wieder loesen");

  const fremderAushang = await schreiben(kDogi, "Und noch eine von DogFather.");
  await anheften(kDogi, fremderAushang, true);
  const seins2 = await aushaenge(kModi2);
  ok(seins2.darfFuerAlle[fremderAushang] === false,
    "  aber NICHT den von DogFather (Gegenprobe)");

  const versuch = await anheften(kModi2, fremderAushang, false);
  ok(versuch.status === 403,
    `  und der Versuch wird abgewiesen (${versuch.status})`);

  const eigenes = await anheften(kModi2, n2, false);
  ok(eigenes.status === 200, `  seinen eigenen loest er (${eigenes.status})`);
}

/* =======================================================================
   6. ES HAENGEN DREI -- UND DER VIERTE RUECKT NACH
   ======================================================================= */
melde("");
melde("=== 6. Der naechste rueckt nach ===");
{
  /* Aufraeumen: alles loesen, was noch haengt. */
  const stand = await aushaenge(kDogi);
  for (const id of stand.ids) await anheften(kDogi, id, false);

  const vier = [];
  for (let i = 1; i <= 4; i++) vier.push(await schreiben(kDogi, `Ansage ${i}`));
  for (const id of vier.slice(0, 3)) await anheften(kDogi, id, true);

  const voll = await anheften(kDogi, vier[3], true);
  ok(voll.status === 409, `der vierte passt nicht drauf (${voll.status})`);

  const dreiDa = await aushaenge(kModi);
  ok(dreiDa.ids.length === 3, `es haengen drei (${dreiDa.ids.length})`);

  /* Jetzt nimmt der Modi einen fuer sich weg. Der vierte haengt ja
     nicht -- also darf danach nichts nachruecken, und er sieht ZWEI.
     Das ist die richtige Antwort: „fuer mich weg" ist kein Platz
     schaffen. */
  await fuerMich(kModi, dreiDa.ids[0], true);
  const zweiDa = await aushaenge(kModi);
  ok(zweiDa.ids.length === 2,
    `nach dem Wegnehmen sieht er zwei (${zweiDa.ids.length})`);
  const beiDogiDrei = await aushaenge(kDogi);
  ok(beiDogiDrei.ids.length === 3,
    `  und DogFather weiterhin drei (${beiDogiDrei.ids.length})`);

  /* UND JETZT DER FALL, DER DAS NACHRUECKEN BEWEIST: Vier haengen
     nicht gleichzeitig -- also loest DogFather einen fuer alle und
     heftet den vierten an. Der Modi hat einen der drei bei sich
     weggenommen; er muss trotzdem drei sehen, sobald es vier gibt,
     von denen einer bei ihm aus ist. */
  await anheften(kDogi, dreiDa.ids[2], false);
  await anheften(kDogi, vier[3], true);
  const nachher = await aushaenge(kModi);
  ok(nachher.ids.length === 2 && !nachher.ids.includes(dreiDa.ids[0]),
    `der weggenommene bleibt weg, die anderen ruecken nach `
    + `(${nachher.ids.length}: ${nachher.ids.join(",")})`);
}

/* =======================================================================
   7. GEGENPROBEN
   ======================================================================= */
melde("");
melde("=== 7. Gegenproben (jede MUSS anschlagen) ===");
{
  const stand = await aushaenge(kDogi);
  const einer = stand.ids[0];

  const fremd = await fuerMich(kFremd, einer, true);
  ok(fremd.status === 404,
    `wer nicht im Raum ist, kommt nicht heran (${fremd.status})`);

  const ohne = await roh(null, `/workspace/api/chat/nachrichten/${einer}/pin-fuer-mich`,
    "PUT", { aus: true });
  ok(ohne.status === 401, `ohne Anmeldung gar nichts (${ohne.status})`);

  const erfunden = await fuerMich(kDogi, 999999, true);
  ok(erfunden.status === 404, `eine erfundene Nummer gibt es nicht (${erfunden.status})`);
}

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