dogfather-universe/server/workspace-wissen.js

/* =====================================================================
   workspace-wissen.js — Wissens-Bibliothek (Anleitungen als PDF).

   Die Gliederung ist der eigentliche Wert dieses Bereichs, deshalb steht
   sie hier im Code und nicht in der Datenbank: zwanzig Kategorien, von
   Filipe vorgegeben, in sechs Welten gebuendelt. Zwanzig gleich
   aussehende Kacheln untereinander findet niemand -- gebuendelt sucht
   man erst die Welt und dann die Kategorie, und das geht mit einem Blick.

   JEDE PDF HAT GENAU EINE HAUPTKATEGORIE. So gibt es sie nur einmal, es
   entstehen keine Doppelungen und keine Frage "wo lag die noch mal".
   Alles Weitere laeuft ueber Tags -- damit ist dieselbe Anleitung
   trotzdem ueber mehrere Suchbegriffe auffindbar.

   Sicherheit beim Ausliefern: Hochgeladen wird nur, was wirklich eine
   PDF ist (geprueft an den ersten Bytes, nicht an der Dateiendung -- die
   kann jeder umbenennen). Nur deshalb darf die Datei ueberhaupt im
   Browser angezeigt statt bloss heruntergeladen werden.
   ===================================================================== */

import express from "express";
import { randomBytes } from "node:crypto";
import { join } from "node:path";
import { mkdirSync, createReadStream, writeFileSync, unlinkSync, statSync } from "node:fs";
import {
  db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER, istLeitung,
} from "./workspace.js";

export const wissenRouter = express.Router();

const ORDNER = join(DATEN_ORDNER, "wissen");
const MAX_BYTES = 40 * 1024 * 1024;      // 40 MB je Anleitung
const TITEL_MAX = 140;
const TEXT_MAX = 400;
const TAGS_MAX = 8;

const jetzt = () => new Date().toISOString();
const heute = () => new Date().toISOString().slice(0, 10);

/* ---------- Die Gliederung ------------------------------------------------
   Die Beschreibungen sind woertlich Filipes Vorgabe -- sie sagen, was in
   die Kategorie gehoert, und beantworten damit die einzige Frage, die
   man beim Einsortieren wirklich hat.                                    */

export const WELTEN = [
  { schluessel: "tiktok",   name: "TikTok" },
  { schluessel: "aufbau",   name: "Streaming einrichten" },
  { schluessel: "bildton",  name: "Bild & Ton" },
  { schluessel: "technik",  name: "Übertragung & Aussehen" },
  { schluessel: "inhalt",   name: "Inhalt & Menschen" },
  { schluessel: "hilfe",    name: "Hilfe & Schnellstart" },
];

export const KATEGORIEN = [
  { nr: 1, schluessel: "tiktok-grundlagen", welt: "tiktok", symbol: "tiktok",
    name: "TikTok – Grundlagen & Funktionen",
    beschreibung: "Allgemeine TikTok-Erklärungen, Einstellungen, LIVE-Funktionen, Gäste, Co-Hosts, Abos, Geschenke, Coins und neue Features." },
  { nr: 2, schluessel: "tiktok-regeln", welt: "tiktok", symbol: "schild",
    name: "TikTok – Regeln & Sicherheit",
    beschreibung: "Community-Richtlinien, erlaubte und verbotene Inhalte, Altersprüfung, Sperren, Verwarnungen, Datenschutz, Jugendschutz und sicheres Verhalten." },
  { nr: 17, schluessel: "events-einnahmen", welt: "tiktok", symbol: "pokal",
    name: "Events, Kampagnen & Einnahmen",
    beschreibung: "TikTok-Events, Ranglisten, Kampagnen, LIVE-Geschenke, Abonnements, Monetarisierung und Teilnahmebedingungen." },
  { nr: 20, schluessel: "neuigkeiten", welt: "tiktok", symbol: "glocke",
    name: "Neuigkeiten & Updates",
    beschreibung: "Neue TikTok-Funktionen, Änderungen an Regeln, Software-Updates und aktuelle Entwicklungen im Streaming-Bereich." },

  { nr: 3, schluessel: "streaming-pc", welt: "aufbau", symbol: "monitor",
    name: "Streaming mit PC",
    beschreibung: "Komplettes Streaming-Setup am Computer, TikTok LIVE Studio, PC-Einstellungen, Leistung, Verkabelung und Einrichtung." },
  { nr: 4, schluessel: "obs", welt: "aufbau", symbol: "ebenen",
    name: "OBS & Streaming-Software",
    beschreibung: "OBS Studio, Szenen, Quellen, Übergänge, Plugins, virtuelle Kamera, TikTok-Anbindung und weitere Streaming-Programme." },
  { nr: 5, schluessel: "streaming-handy", welt: "aufbau", symbol: "handy",
    name: "Streaming mit Handy & Outdoor-Lives",
    beschreibung: "Mobile Livestreams, IRL-Streaming, Internetverbindung unterwegs, Powerbanks, Smartphone-Halterungen, mobile Mikrofone und Outdoor-Ausrüstung." },

  { nr: 6, schluessel: "kamera", welt: "bildton", symbol: "kamera",
    name: "Kamera & Bildqualität",
    beschreibung: "Webcams, Kameras, Kameraeinstellungen, Auflösung, FPS, Belichtung, Fokus, Unschärfe, Bildausschnitt, Filter und optimale Bildqualität." },
  { nr: 7, schluessel: "licht", welt: "bildton", symbol: "licht",
    name: "Licht & Hintergrund",
    beschreibung: "Beleuchtung, Ringlichter, Softboxen, LED-Lichter, Greenscreen, Hintergrundgestaltung und richtige Positionierung." },
  { nr: 8, schluessel: "audio", welt: "bildton", symbol: "mikrofon",
    name: "Mikrofone & Audio",
    beschreibung: "Mikrofone, Audioeinstellungen, Lautstärke, Rauschunterdrückung, Equalizer, Sprachqualität, Musik und Soundprobleme." },
  { nr: 9, schluessel: "mischpulte", welt: "bildton", symbol: "regler",
    name: "Mischpulte, Soundboards & Effekte",
    beschreibung: "Maono, RØDECaster, Stream Deck, Soundpads, Sprach- und Soundeffekte sowie das Belegen von Tasten mit Sounds." },
  { nr: 10, schluessel: "hardware", welt: "bildton", symbol: "stecker",
    name: "Streaming-Hardware & Zubehör",
    beschreibung: "Computer, Monitore, Capture Cards, Kabel, Adapter, Stative, Kopfhörer, Stream Decks und weiteres Zubehör." },

  { nr: 11, schluessel: "internet", welt: "technik", symbol: "wlan",
    name: "Internet & Stream-Qualität",
    beschreibung: "WLAN, LAN, Upload-Geschwindigkeit, Bitrate, Verbindungsabbrüche, Lags, eingefrorene Bilder und Optimierung der Übertragung." },
  { nr: 12, schluessel: "design", welt: "technik", symbol: "rahmen",
    name: "Stream-Design & Darstellung",
    beschreibung: "Overlays, Rahmen, Szenen, Animationen, Einblendungen, Alerts, Logos, Chat-Anzeigen und ein professionelles Stream-Layout." },
  { nr: 13, schluessel: "tools", welt: "technik", symbol: "zahnrad",
    name: "Tools, Bots & Automatisierungen",
    beschreibung: "Tikfinity, Discord-Bots, Benachrichtigungen, automatische Aktionen, Chat-Befehle und weitere hilfreiche Programme." },

  { nr: 14, schluessel: "content", welt: "inhalt", symbol: "kalender",
    name: "Content & Stream-Planung",
    beschreibung: "Stream-Ideen, Vorbereitung, Ablaufpläne, Challenges, Spiele, Themenstreams, Zuschauerbindung und Content-Planung." },
  { nr: 15, schluessel: "community", welt: "inhalt", symbol: "menschen",
    name: "Community & Moderation",
    beschreibung: "Aufgaben der Modis, Chatregeln, Deeskalation, Community-Aufbau, Umgang mit Zuschauern, Trollen und Konflikten." },
  { nr: 16, schluessel: "reichweite", welt: "inhalt", symbol: "wachstum",
    name: "Reichweite & Wachstum",
    beschreibung: "TikTok-Wachstum, Videos, Clips, Highlights, Hashtags, Stream-Zeiten, Zuschauergewinnung und Verbesserung der Reichweite." },

  { nr: 18, schluessel: "fehler", welt: "hilfe", symbol: "werkzeug",
    name: "Fehlerbehebung & Problemlösungen",
    beschreibung: "Lösungen für technische Fehler, fehlenden Ton, schlechtes Bild, Abstürze, Verbindungsprobleme, OBS-Fehler und TikTok-LIVE-Probleme." },
  { nr: 19, schluessel: "checklisten", welt: "hilfe", symbol: "haken",
    name: "Checklisten & Schnellstart-Anleitungen",
    beschreibung: "Kurze Schritt-für-Schritt-Anleitungen, Einsteiger-Checklisten, Stream-Vorbereitung und schnelle Einrichtungshilfen." },
];

const KAT_SCHLUESSEL = new Set(KATEGORIEN.map((k) => k.schluessel));

export const STUFEN = { einsteiger: "Einsteiger", fortgeschritten: "Fortgeschritten", profi: "Profi" };
export const GERAETE = { egal: "Egal", pc: "PC", handy: "Handy", beide: "PC & Handy" };

/* Vorschlaege, keine Vorschrift -- eigene Tags bleiben moeglich. */
export const TAG_VORSCHLAEGE = [
  "tiktok", "obs", "pc", "handy", "audio", "kamera", "licht", "internet",
  "overlay", "moderation", "einnahmen", "sicherheit", "checkliste",
];

/* ---------- Zugang ------------------------------------------------------
   Lesen darf jeder Angemeldete -- die Bibliothek ist fuer das ganze Team.
   Pflegen darf nur DogFather: Es ist kuratiertes Wissen, kein Ablageort.  */

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  next();
}
function nurDogFather(req, res, next) {
  if (!istLeitung(req.person)) {
    return res.status(403).json({ fehler: "Die Bibliothek pflegt DogFather." });
  }
  next();
}
function gleicheHerkunft(req, res, next) {
  const herkunft = req.get("origin");
  if (!herkunft) return next();
  let erlaubt;
  try { erlaubt = new URL(herkunft).host === req.get("host"); } catch { erlaubt = false; }
  if (!erlaubt) return res.status(403).json({ fehler: "fremde_herkunft" });
  next();
}

wissenRouter.use("/workspace/api/wissen", angemeldet);

/* ---------- Aufbau: Kategorien mit Anzahl -------------------------------- */

wissenRouter.get("/workspace/api/wissen/aufbau", (req, res) => {
  try {
    const zaehler = new Map(db().prepare(
      "SELECT kategorie, COUNT(*) AS n FROM wissen GROUP BY kategorie")
      .all().map((z) => [z.kategorie, z.n]));

    /* Tags, die tatsaechlich benutzt werden -- eine Filterliste mit
       Begriffen ohne Treffer waere eine Einladung ins Leere. */
    const benutzt = new Set();
    for (const z of db().prepare("SELECT tags FROM wissen WHERE tags IS NOT NULL").all()) {
      for (const t of String(z.tags).split(",")) if (t.trim()) benutzt.add(t.trim());
    }

    res.json({
      welten: WELTEN,
      kategorien: KATEGORIEN.map((k) => ({ ...k, anzahl: zaehler.get(k.schluessel) || 0 })),
      stufen: STUFEN,
      geraete: GERAETE,
      tags: [...benutzt].sort(),
      tag_vorschlaege: TAG_VORSCHLAEGE,
      darf_pflegen: istLeitung(req.person),
      gesamt: [...zaehler.values()].reduce((s, n) => s + n, 0),
    });
  } catch (fehler) {
    console.error("[workspace] Wissen Aufbau:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Liste, Suche und Filter -------------------------------------- */

function muster(text) {
  return "%" + text.replace(/[\\%_]/g, (z) => "\\" + z) + "%";
}

wissenRouter.get("/workspace/api/wissen", (req, res) => {
  try {
    const bedingungen = [];
    const werte = [];

    const k = String(req.query.k ?? "").trim();
    if (k && KAT_SCHLUESSEL.has(k)) { bedingungen.push("w.kategorie = ?"); werte.push(k); }

    const stufe = String(req.query.stufe ?? "").trim();
    if (stufe && Object.hasOwn(STUFEN, stufe)) { bedingungen.push("w.stufe = ?"); werte.push(stufe); }

    /* "PC" soll auch die Anleitungen zeigen, die fuer beide Geraete
       gelten -- sonst filtert man sich versehentlich das Halbe weg. */
    const geraet = String(req.query.geraet ?? "").trim();
    if (geraet === "pc" || geraet === "handy") {
      bedingungen.push("(w.geraet = ? OR w.geraet = 'beide')");
      werte.push(geraet);
    }

    const tag = String(req.query.tag ?? "").trim().toLowerCase();
    if (tag) {
      /* Kommas drumherum, sonst wuerde der Filter "pc" auch bei
         "pc-spiele" anschlagen. COALESCE, weil Tags leer sein duerfen --
         NULL || ',' waere NULL und die Zeile fiele stumm raus. */
      bedingungen.push("(',' || COALESCE(w.tags, '') || ',') LIKE ? ESCAPE '\\'");
      werte.push(muster("," + tag + ","));
    }

    const q = String(req.query.q ?? "").trim().slice(0, 80);
    if (q.length >= 2) {
      const m = muster(q);
      bedingungen.push("(w.titel LIKE ? ESCAPE '\\' OR w.beschreibung LIKE ? ESCAPE '\\' OR w.tags LIKE ? ESCAPE '\\' OR w.name_original LIKE ? ESCAPE '\\')");
      werte.push(m, m, m, m);
    }

    const wo = bedingungen.length ? "WHERE " + bedingungen.join(" AND ") : "";
    const liste = db().prepare(`
      SELECT w.id, w.titel, w.beschreibung, w.kategorie, w.stufe, w.geraet, w.tags,
             w.name_original, w.groesse, w.wichtig, w.veroeffentlicht, w.aktualisiert,
             p.name AS von
      FROM wissen w LEFT JOIN personen p ON p.id = w.erstellt_von
      ${wo}
      ORDER BY w.wichtig DESC,
               COALESCE(w.aktualisiert, w.veroeffentlicht) DESC,
               w.titel`).all(...werte);

    for (const e of liste) e.tags = e.tags ? String(e.tags).split(",").filter(Boolean) : [];

    /* Neu und wichtig -- der Einstieg fuer alle, die nicht suchen,
       sondern schauen wollen, was sich getan hat. */
    const neu = !k && !q && !stufe && !geraet && !tag
      ? liste.filter((e) => e.wichtig
          || (Date.now() - Date.parse(e.aktualisiert || e.veroeffentlicht) < 30 * 86400_000))
          .slice(0, 6)
      : [];

    res.json({ eintraege: liste, neu, gesamt: liste.length });
  } catch (fehler) {
    console.error("[workspace] Wissen lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Angaben pruefen ---------------------------------------------- */

function pruefe(kopf, { neu }) {
  const fehler = [];
  const aus = {};
  const hole = (name) => {
    const roh = kopf[name];
    if (roh === undefined) return undefined;
    try { return decodeURIComponent(String(roh)); } catch { return String(roh); }
  };

  const titel = hole("titel");
  if (neu || titel !== undefined) {
    const t = String(titel ?? "").trim();
    if (t.length < 3) fehler.push("Der Titel fehlt.");
    else if (t.length > TITEL_MAX) fehler.push("Der Titel ist zu lang.");
    else aus.titel = t;
  }

  const besch = hole("beschreibung");
  if (besch !== undefined) aus.beschreibung = String(besch).trim().slice(0, TEXT_MAX) || null;

  const kat = hole("kategorie");
  if (neu || kat !== undefined) {
    if (!KAT_SCHLUESSEL.has(String(kat))) fehler.push("Diese Kategorie gibt es nicht.");
    else aus.kategorie = String(kat);
  }

  const stufe = hole("stufe");
  if (stufe !== undefined) {
    if (!Object.hasOwn(STUFEN, String(stufe))) fehler.push("Unbekannte Stufe.");
    else aus.stufe = String(stufe);
  }

  const geraet = hole("geraet");
  if (geraet !== undefined) {
    if (!Object.hasOwn(GERAETE, String(geraet))) fehler.push("Unbekanntes Gerät.");
    else aus.geraet = String(geraet);
  }

  const tags = hole("tags");
  if (tags !== undefined) {
    /* Klein geschrieben und ohne Komma gespeichert -- sonst waeren
       "OBS" und "obs" zwei verschiedene Filter, und ein Komma im Tag
       wuerde die Liste zerlegen. */
    const liste = [...new Set(String(tags).split(",")
      .map((t) => t.trim().toLowerCase().replace(/[^a-z0-9äöüß+\- ]/g, "").trim())
      .filter(Boolean))].slice(0, TAGS_MAX);
    aus.tags = liste.length ? liste.join(",") : null;
  }

  const wichtig = hole("wichtig");
  if (wichtig !== undefined) aus.wichtig = (wichtig === "1" || wichtig === "true") ? 1 : 0;

  const datum = hole("veroeffentlicht");
  if (datum !== undefined && String(datum).trim()) {
    const d = String(datum).trim();
    if (!/^\d{4}-\d{2}-\d{2}$/.test(d) || Number.isNaN(Date.parse(d))) {
      fehler.push("Das Veröffentlichungsdatum ist ungültig.");
    } else aus.veroeffentlicht = d;
  }

  return { aus, fehler };
}

/* ---------- Hochladen ----------------------------------------------------
   Angaben stehen in Kopfzeilen, weil der Rumpf die Datei selbst ist --
   dieselbe Loesung wie bei den Dateien, kein multipart-Paket noetig.     */

wissenRouter.post(
  "/workspace/api/wissen",
  gleicheHerkunft,
  nurDogFather,
  express.raw({ type: "*/*", limit: MAX_BYTES }),
  (req, res) => {
    let pfad = null;
    try {
      if (!req.body?.length) return res.status(400).json({ fehler: "Keine Datei angekommen." });

      /* Ist das wirklich eine PDF? Geprueft an den ersten Bytes, nicht an
         der Endung -- die kann jeder umbenennen. Nur weil das hier sicher
         ist, darf die Datei spaeter im Browser angezeigt werden. */
      const kopf = req.body.subarray(0, 5).toString("latin1");
      if (kopf !== "%PDF-") {
        return res.status(400).json({ fehler: "Das ist keine PDF-Datei." });
      }

      const felder = {};
      for (const n of ["titel", "beschreibung", "kategorie", "stufe", "geraet", "tags", "wichtig", "veroeffentlicht"]) {
        const w = req.get("x-" + n);
        if (w !== undefined) felder[n] = w;
      }
      const { aus, fehler } = pruefe(felder, { neu: true });
      if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });

      let name = "anleitung.pdf";
      try { name = decodeURIComponent(req.get("x-dateiname") || "").trim() || name; } catch { /* Vorgabe */ }
      name = name.replace(/[\x00-\x1f\x7f/\\<>:"|?*]/g, "").slice(0, 160) || "anleitung.pdf";

      mkdirSync(ORDNER, { recursive: true });
      const dateiname = `${Date.now().toString(36)}-${randomBytes(8).toString("hex")}.pdf`;
      pfad = join(ORDNER, dateiname);
      writeFileSync(pfad, req.body, { flag: "wx" });

      const { lastInsertRowid } = db().prepare(`
        INSERT INTO wissen
          (titel, beschreibung, kategorie, stufe, geraet, tags,
           name_original, name_datei, groesse, wichtig, veroeffentlicht, erstellt_von)
        VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`).run(
        aus.titel, aus.beschreibung ?? null, aus.kategorie,
        aus.stufe ?? "einsteiger", aus.geraet ?? "egal", aus.tags ?? null,
        name, dateiname, req.body.length, aus.wichtig ?? 0,
        aus.veroeffentlicht ?? heute(), req.person.id);

      protokolliere("wissen_hochgeladen", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${lastInsertRowid} ${aus.titel} (${Math.round(req.body.length / 1024)} KB)`.slice(0, 120),
      });
      res.status(201).json({ id: Number(lastInsertRowid) });
    } catch (fehler) {
      /* Liegt die Datei schon auf der Platte, der Eintrag aber nicht in
         der Datenbank, waere sie fuer immer verwaist. */
      if (pfad) { try { unlinkSync(pfad); } catch { /* war nie da */ } }
      console.error("[workspace] Wissen hochladen:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* ---------- Angaben aendern ---------------------------------------------- */

wissenRouter.patch("/workspace/api/wissen/:id", gleicheHerkunft, nurDogFather, express.json(), (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    const vorhanden = db().prepare("SELECT id FROM wissen WHERE id = ?").get(id);
    if (!vorhanden) return res.status(404).json({ fehler: "nicht_gefunden" });

    /* Der Aenderungsweg nimmt die Werte im Rumpf, nicht in Kopfzeilen --
       hier haengt keine Datei dran. */
    const felder = {};
    for (const n of ["titel", "beschreibung", "kategorie", "stufe", "geraet", "tags", "wichtig", "veroeffentlicht"]) {
      if (req.body?.[n] !== undefined) felder[n] = encodeURIComponent(String(req.body[n]));
    }
    const { aus, fehler } = pruefe(felder, { neu: false });
    if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });
    const namen = Object.keys(aus);
    if (!namen.length) return res.status(400).json({ fehler: "nichts_zu_aendern" });

    const setz = namen.map((n) => `${n} = ?`);
    const daten = namen.map((n) => aus[n]);
    setz.push("aktualisiert = ?"); daten.push(heute());

    db().prepare(`UPDATE wissen SET ${setz.join(", ")} WHERE id = ?`).run(...daten, id);
    protokolliere("wissen_geaendert", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${namen.join(",")}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Wissen ändern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

wissenRouter.delete("/workspace/api/wissen/:id", gleicheHerkunft, nurDogFather, (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    const e = db().prepare("SELECT titel, name_datei FROM wissen WHERE id = ?").get(id);
    if (!e) return res.status(404).json({ fehler: "nicht_gefunden" });

    db().prepare("DELETE FROM wissen WHERE id = ?").run(id);
    try { unlinkSync(join(ORDNER, e.name_datei)); } catch { /* schon weg */ }

    protokolliere("wissen_geloescht", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${e.titel}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Wissen löschen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Ausliefern ---------------------------------------------------- */

wissenRouter.get("/workspace/api/wissen/:id/datei", (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    const e = db().prepare("SELECT titel, name_original, name_datei FROM wissen WHERE id = ?").get(id);
    if (!e) return res.status(404).json({ fehler: "nicht_gefunden" });

    const pfad = join(ORDNER, e.name_datei);
    try { statSync(pfad); } catch { return res.status(410).json({ fehler: "Datei fehlt auf der Platte." }); }

    /* Anzeigen ist nur erlaubt, weil beim Hochladen geprueft wurde, dass
       es wirklich eine PDF ist. Die strenge Regel darunter verbietet der
       Datei trotzdem jeden Nachladeversuch und jedes Skript. */
    const ansehen = req.query.modus === "ansehen";
    res.setHeader("Content-Type", ansehen ? "application/pdf" : "application/octet-stream");
    res.setHeader("X-Content-Type-Options", "nosniff");
    res.setHeader("Content-Security-Policy", "default-src 'none'; object-src 'self'; sandbox");
    res.setHeader("Content-Disposition",
      `${ansehen ? "inline" : "attachment"}; filename*=UTF-8''${encodeURIComponent(e.name_original)}`);

    protokolliere(ansehen ? "wissen_angesehen" : "wissen_geladen", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${e.titel}`.slice(0, 120),
    });
    createReadStream(pfad).pipe(res);
  } catch (fehler) {
    console.error("[workspace] Wissen ausliefern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* Grosse Datei: express.raw bricht ab, BEVOR der eigene Code laeuft --
   ohne diesen Fanghaken kaeme ein nackter 500er. */
wissenRouter.use((fehler, req, res, next) => {
  if (fehler?.type === "entity.too.large" || fehler?.status === 413) {
    return res.status(413).json({
      fehler: `Die PDF ist zu groß – erlaubt sind ${Math.round(MAX_BYTES / 1024 / 1024)} MB.`,
    });
  }
  return next(fehler);
});