dogfather-universe/server/pruef-manager-sicht.mjs

/* =====================================================================
   LECKSUCHE: Sieht eine Managerin wirklich nur ihre eigenen Creator?

   Wunsch vom 03.09.2026: "jeder manager soll auch immer nur seine und
   die seiner scouts zugeteilten creator und creator daten sehen. und
   nicht die der anderen."

   ---------------------------------------------------------------------
   WARUM DAS NICHT MIT LESEN ZU BEANTWORTEN IST

   Die Kette "Manager -> seine Scouts -> deren Creator" ist gebaut und
   steht an genau einer Stelle (betreuteIds). Die Frage ist eine andere:
   Benutzt sie auch JEDER Weg, der Creator-Daten herausgibt? Es gibt
   ueber zwanzig Stellen, an denen die Rolle geprueft wird statt der
   Zuteilung -- und ein einziger vergessener Weg reicht.

   Deshalb wird hier nicht Quelltext gelesen, sondern GEMESSEN:

     * Zwei Managerinnen mit vollstaendig getrennten Creators.
     * Bei der fremden Creatorin heisst ALLES "GEHEIM..." -- Aufgabe,
       Termin, Bereichseintrag, Datei, Steckbrief, Notiz, Content.
     * Danach wird jede Leseschnittstelle abgefragt und die ganze
       Antwort nach "GEHEIM" durchsucht.

   Ein Leck faellt damit auf, egal an welcher Stelle es sitzt und egal,
   ob ich es beim Lesen uebersehen haette. Das ist der Unterschied
   zwischen "ich habe nichts gefunden" und "es ist nichts da".

   Die GEGENPROBE ist genauso wichtig: Dieselbe Managerin MUSS ihre
   eigenen Creator sehen -- den direkt zugeteilten und den ueber ihren
   Scout. Ohne sie waere jede Zeile oben auch dann gruen, wenn sie
   ueberhaupt nichts mehr saehe.
   ===================================================================== */
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";

const ordner = mkdtempSync(join(tmpdir(), "ws-msicht-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
process.env.PORT = "4199";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
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 }); };
await import("./index.js");
await new Promise((r) => setTimeout(r, 700));
const BASIS = "http://127.0.0.1:4199";
setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();

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

const { DatabaseSync } = await import("node:sqlite");
const { scryptSync, randomBytes } = await import("node:crypto");
const d = new DatabaseSync(process.env.WORKSPACE_DB);
const jetzt = new Date().toISOString();
const tag = (v) => new Date(Date.now() + v * 86400_000).toISOString().slice(0, 10);

function person(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, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
    .run(name, rolle, hash, salt, 32768, jetzt);
  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
}

const idDogi   = person("Dogfather", "admin", "CODE-DOGI-0001");
/* Seite A -- Cigdem, ihr Scout Ben, und zwei Creator: einer direkt,
   einer ueber den Scout. Genau die Kette aus dem Wunsch. */
const idCigdem = person("Cigdem", "manager", "CODE-CIGDEM-01");
const idBen    = person("Ben", "scout", "CODE-BEN-00001");
const idTili   = person("Tili", "creator", "CODE-TILI-0001");
const idLuna   = person("Luna", "creator", "CODE-LUNA-0001");
/* Seite B -- eine voellig fremde Managerin mit eigener Creatorin. */
const idDana   = person("Dana", "manager", "CODE-DANA-0001");
const idZoe    = person("GEHEIMZoe", "creator", "CODE-ZOE-00001");

d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idCigdem, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idBen, jetzt);
d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)").run(idBen, idCigdem, jetzt);
d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idZoe, idDana, jetzt);

/* Alles von Zoe traegt das Wort GEHEIM. Taucht es irgendwo in einer
   Antwort an Cigdem auf, ist genau dort ein Leck. */
d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, creator_id, verantwortlich_id, frist, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?,?,?)`)
  .run("GEHEIM Aufgabe", "GEHEIM Beschreibung", "offen", "hoch", idZoe, idZoe, tag(1), jetzt, idDana);
d.prepare(`INSERT INTO termine (titel, beschreibung, art, beginn, dauer_min, creator_id, teilnehmer_id, erledigt, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?,0,?,?)`)
  .run("GEHEIM Call", "GEHEIM Notiz", "call", tag(-1) + "T18:00", 30, idZoe, idZoe, jetzt, idDana);
for (const bereich of ["live", "content", "community", "technik", "schutz"]) {
  d.prepare(`INSERT INTO eintraege (bereich, art, titel, text, datum, status, creator_id, erstellt, erstellt_von)
             VALUES (?,?,?,?,?,?,?,?,?)`)
    .run(bereich, bereich === "content" ? "idee" : "vorbereitung",
      "GEHEIM " + bereich, "GEHEIM Text", tag(0), "offen", idZoe, jetzt, idDana);
}
d.prepare(`INSERT INTO dateien (name_original, name_datei, groesse, typ, status, notiz, creator_id, hochgeladen_von, erstellt)
           VALUES (?,?,?,?,?,?,?,?,?)`)
  .run("GEHEIM.pdf", "x-geheim.pdf", 10, "application/pdf", "entwurf", "GEHEIM Notiz", idZoe, idDana, jetzt);
d.prepare("UPDATE personen SET ueber_mich = ?, tiktok = ? WHERE id = ?")
  .run("GEHEIM Steckbrief", "GEHEIMhandle", idZoe);
d.prepare("INSERT INTO content_saeulen (creator_id, name, ziel, slot, erstellt) VALUES (?,?,?,?,?)")
  .run(idZoe, "GEHEIM Saeule", 40, 1, jetzt);

/* Und dasselbe harmlos fuer Cigdems eigene Creator -- fuer die
   Gegenprobe. */
d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, creator_id, verantwortlich_id, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?)`)
  .run("Tili-Aufgabe", "offen", "mittel", idTili, idTili, jetzt, idDogi);
d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, creator_id, verantwortlich_id, erstellt, erstellt_von)
           VALUES (?,?,?,?,?,?,?)`)
  .run("Luna-Aufgabe", "offen", "mittel", idLuna, idLuna, jetzt, idDogi);
d.close();

const { chromium } = await import(
  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await chromium.launch();

async function anmelden(rolle, code) {
  const kontext = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
  const seite = await kontext.newPage();
  await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
  await seite.click(`.rolle[data-rolle="${rolle}"]`);
  await seite.fill("#code", code);
  await seite.click("button[type=submit]");
  await seite.waitForURL("**/start.html", { timeout: 15000 });
  return seite;
}
const roh = (seite, pfad) => seite.evaluate(async (p) => {
  try {
    const a = await fetch(p, { credentials: "same-origin" });
    let text = (await a.text()).slice(0, 60000);
    /* Die Suche gibt den SUCHBEGRIFF in ihrer Antwort zurück
       ("frage": "..."), damit die Seite ihn anzeigen kann. Sucht man
       nach "GEHEIM", steht das Wort also zwangsläufig in der Antwort --
       auch bei null Treffern.

       Beim ersten Anlauf hat genau das einen Fehlalarm ausgelöst, und
       ich hätte um ein Haar ein Leck "repariert", das es nie gab. Das
       Echo wird deshalb entfernt, BEVOR gesucht wird -- gemessen wird
       nur, was die Suche GEFUNDEN hat. */
    text = text.replace(/"frage"\s*:\s*"[^"]*"/g, '"frage":""');
    return { status: a.status, text };
  } catch (e) { return { status: 0, text: "" }; }
}, pfad);

const cigdem = await anmelden("manager", "CODE-CIGDEM-01");

/* ---------- Jede Leseschnittstelle, die es gibt ------------------------- */

const WEGE = [
  "/workspace/api/ich",
  "/workspace/api/aufgaben",
  "/workspace/api/uebersicht",
  "/workspace/api/uebersicht/creator",
  "/workspace/api/personen",
  `/workspace/api/termine?von=${tag(-30)}&tage=90`,
  "/workspace/api/serien",
  "/workspace/api/calls",
  "/workspace/api/bereich/live",
  "/workspace/api/bereich/content",
  "/workspace/api/bereich/community",
  "/workspace/api/bereich/technik",
  "/workspace/api/bereich/schutz",
  "/workspace/api/content/saeulen",
  "/workspace/api/content/kennzahlen",
  "/workspace/api/dateien",
  "/workspace/api/hinweise",
  "/workspace/api/suche?q=GEHEIM",
  "/workspace/api/suche?q=Zoe",
  "/workspace/api/report",
  "/workspace/api/report/creator",
  "/workspace/api/startcheck/creator",
  "/workspace/api/steckbrief",
  "/workspace/api/profil",
  "/workspace/api/leads",
  "/workspace/api/leads-scouts",
  "/workspace/api/schulung",
  "/workspace/api/wissen",
  "/workspace/api/vorlagen",
  "/workspace/api/eintrag/ampeln",
  "/workspace/api/checkliste/live",
];

console.log("\n— Sickert etwas von der fremden Creatorin durch? —");

/* DIE STATUSPRÜFUNG IST KEIN BEIWERK.

   Beim Stopfen dieser Lecks ist mir genau das passiert: Ein Import
   fehlte, der Weg warf einen Fehler, antwortete mit 503 -- und weil in
   einer Fehlermeldung natürlich kein "GEHEIM" steht, meldete die
   Prüfung brav "kein Leck". Sie war grün, weil der Weg KAPUTT war.

   Eine Prüfung, die einen Ausfall als Erfolg liest, ist schlimmer als
   keine. Deshalb zählt hier beides: Es darf nichts durchsickern UND der
   Weg muss antworten. */
const lecks = [];
for (const weg of WEGE) {
  const a = await roh(cigdem, weg);
  const leck = /GEHEIM/i.test(a.text);
  const kaputt = a.status === 0 || a.status >= 500;
  if (leck) {
    lecks.push(`${weg} (${a.status})`);
    /* Bei einem Fund gleich zeigen, WO er steckt -- sonst sucht man
       die Nadel anschliessend von Hand im ganzen Heuhaufen. */
    const stelle = a.text.search(/GEHEIM/i);
    lecks.push("      …" + a.text.slice(Math.max(0, stelle - 120), stelle + 120) + "…");
  }
  if (kaputt) lecks.push(`${weg} ANTWORTET NICHT (${a.status})`);
  ok(!leck && !kaputt,
    `${weg.replace("/workspace/api/", "").padEnd(34)} ${a.status}`
    + `${leck ? "  ← LECK" : ""}${kaputt ? "  ← ANTWORTET NICHT" : ""}`);
}

/* ---------- Auch direkte Zugriffe auf fremde Nummern -------------------- */

console.log("\n— Und wenn sie die Nummer der Fremden kennt? —");

for (const [weg, was] of [
  [`/workspace/api/steckbrief/${idZoe}`, "fremder Steckbrief"],
  [`/workspace/api/profil/${idZoe}`, "fremdes Profil"],
  [`/workspace/api/startcheck/${idZoe}`, "fremder Start-Check"],
  [`/workspace/api/report?creator=${idZoe}`, "fremder Report"],
  [`/workspace/api/content/kennzahlen?creator=${idZoe}`, "fremde Content-Zahlen"],
  [`/workspace/api/uebersicht/creator?id=${idZoe}`, "fremde Übersicht"],
]) {
  const a = await roh(cigdem, weg);
  const leck = /GEHEIM/i.test(a.text);
  ok(!leck, `${was.padEnd(24)} ${a.status}${leck ? "  ← LECK" : ""}`);
}

/* ---------- GEGENPROBE: ihre eigenen sieht sie sehr wohl ---------------- */

console.log("\n— Gegenprobe: ihre eigenen Creator —");

const eigene = await roh(cigdem, "/workspace/api/aufgaben");
ok(/Tili-Aufgabe/.test(eigene.text),
  "sie sieht den DIREKT zugeteilten Creator (Tili)");
ok(/Luna-Aufgabe/.test(eigene.text),
  "und den über ihren Scout (Luna) – die Kette Manager → Scout → Creator trägt");

const dana = await anmelden("manager", "CODE-DANA-0001");
const beiDana = await roh(dana, "/workspace/api/aufgaben");
ok(/GEHEIM/.test(beiDana.text),
  "GEGENPROBE ANDERSHERUM: Dana sieht ihre eigene Creatorin sehr wohl");
ok(!/Tili-Aufgabe/.test(beiDana.text) && !/Luna-Aufgabe/.test(beiDana.text),
  "und umgekehrt keine von Cigdems – die Trennung gilt in beide Richtungen");

/* Und DogFather sieht weiterhin alles -- sonst waere aus der Trennung
   eine Mauer geworden, die auch ihn aussperrt. */
const dogi = await anmelden("admin", "CODE-DOGI-0001");
const beiDogi = await roh(dogi, "/workspace/api/aufgaben");
ok(/GEHEIM/.test(beiDogi.text) && /Tili-Aufgabe/.test(beiDogi.text),
  "GEGENPROBE: DogFather sieht weiterhin beide Seiten");

if (lecks.length) {
  console.log("\n--- LECKS ---");
  for (const l of lecks) console.log("   " + l);
}

const ERWARTET = WEGE.length + 11;
console.log("");
ok(geprueft >= ERWARTET, `es sind ${geprueft} Prüfungen gelaufen (erwartet mindestens ${ERWARTET})`);

await browser.close();
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
console.log(`\n${fehler ? "FEHLER: " + fehler : "Alles in Ordnung"} — ${geprueft} Prüfungen`);
process.exit(fehler ? 1 : 0);