dogfather-universe/server/workspace-support.js

/* =====================================================================
   DER SUPPORT (24.09.2026)

   Filipe: „da fehlt auch eine support kachel. die jeder sieht. jeder
   benutzen kann. jeder kann da probleme von der seite melden und
   hinweisen. fotos mit schicken mit einem text. es soll alles hoch
   profissionell gemacht werden aber so einfach wie möglich, will
   nichts kompliziertes oder zu viel. kurz und knapp … also bei
   dogfather und der rechten hand soll die kachel anders gebaut sein
   weil die sind die die sich um die probleme kümmern."

   Die Regeln und ihre Begründung stehen im Kopf von
   support-tabellen.js. Hier sind die Wege — und die vier Stellen, an
   denen etwas schiefgehen kann:

   1. EINE MELDUNG DARF NIE BEIM FALSCHEN LANDEN. Jede Leseroute geht
      über `meldungFuer()`, das den Datensatz zurückgibt oder `null` —
      nie `true`/`false`. So kann keine Route „darf sehen" beantworten
      und danach trotzdem den falschen Datensatz laden. Dasselbe
      Muster wie im vertraulichen Meldeweg.

   2. DER TYP EINES BILDES KOMMT AUS DEM INHALT. `dateiErkennen()`
      liest die ersten Bytes; Dateiname und Content-Type kommen vom
      Absender und sind frei erfunden. Die Funktion wird aus
      workspace-chat.js IMPORTIERT und nicht abgeschrieben: Eine
      zweite Fassung wäre die, die beim nächsten Dateiformat vergessen
      wird — und an ihr hängt die ganze Sicherheit der Uploads.

   3. DER RUMPF WIRD ERST ANGENOMMEN, WENN DIE BERECHTIGUNG STEHT.
      Wer nicht angemeldet ist, kommt gar nicht bis zur Datei.

   4. ERLEDIGT IST ERLEDIGT. Auch für die Leitung — eine geschlossene
      Meldung wird nicht stillschweigend wieder geöffnet und anders
      beantwortet.
   ===================================================================== */

import express from "express";
import { createReadStream, statSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs";
import { join } from "node:path";
import { randomBytes } from "node:crypto";
import { db, protokolliere, DATEN_ORDNER, echteIp } from "./workspace.js";
import { SUPPORT_STAND, AUFBEWAHRUNG_TAGE } from "./support-tabellen.js";
import { dateiErkennen } from "./workspace-chat.js";
import { benachrichtige } from "./workspace-push.js";

export const supportRouter = express.Router();

/** Wer alle Meldungen sieht und sie bearbeitet.
 *
 *  GENAU ZWEI ROLLEN, wie bestellt: DogFather und die rechte Hand.
 *  Dieselbe Menge wie im vertraulichen Meldeweg — und aus einem
 *  ähnlichen Grund: Wer sich kümmert, muss alles sehen; wer nur
 *  meldet, sieht seine eigene Meldung. */
const LEITUNG = new Set(["admin", "hand"]);
const istLeitung = (person) => LEITUNG.has(person?.rolle);

const TEXT_MAX = 2000;
const SEITE_MAX = 120;
const GERAET_MAX = 200;
const ANTWORT_MAX = 2000;

/** Zwölf Megabyte — dieselbe Grenze wie bei Chat-Anhängen.
 *  Ein Bildschirmfoto vom Handy liegt bei 2 bis 5 MB. */
const BILD_MAX = 12 * 1024 * 1024;

/** Wie viele offene Meldungen eine Person gleichzeitig haben darf.
 *
 *  Zehn, und damit deutlich großzügiger als die drei im vertraulichen
 *  Meldeweg. Dort ist die Grenze ein Schutz vor Überforderung auf
 *  beiden Seiten; hier wäre sie eine Bremse für genau die Person, die
 *  sich die Mühe macht, fünf kleine Fehler einzeln zu melden. Sie
 *  steht nur da, damit ein hängendes Skript nicht tausend Zeilen
 *  anlegt. */
const OFFEN_MAX = 10;

/* Der Ordner steht über join(DATEN_ORDNER, …) — genau dieses Muster
   liest tools/wiederherstellung-proben.mjs aus, um zu prüfen, ob die
   Sicherung ihn mitnimmt. Eine gepflegte Liste wäre die, die beim
   nächsten Ordner vergessen wird. */
const BILD_ORDNER = join(DATEN_ORDNER, "support-bilder");

const jetzt = () => new Date().toISOString();

function sauber(s, max) {
  return String(s ?? "").replace(/\s+/g, " ").trim().slice(0, max);
}

/** Mehrzeiliger Text: Absätze bleiben, Leerzeilenwüsten nicht.
 *
 *  Beim Melden schreibt man „Schritt 1 … Schritt 2 …" untereinander.
 *  Das über `\s+` plattzumachen wie einen Betreff würde genau die
 *  Struktur zerstören, die den Fehler nachvollziehbar macht. */
function textSauber(s, max) {
  return String(s ?? "")
    .replace(/\r\n/g, "\n")
    .replace(/[ \t]+/g, " ")
    .replace(/\n{3,}/g, "\n\n")
    .trim()
    .slice(0, max);
}

/** Darf diese Person diese Meldung sehen?
 *
 *  Gibt die Meldung zurück oder `null`. NIE `true`/`false` — dasselbe
 *  Muster wie `fallFuer()` im vertraulichen Meldeweg, und aus
 *  demselben Grund. */
function meldungFuer(person, id) {
  const m = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(Number(id));
  if (!m) return null;
  if (istLeitung(person)) return m;
  return m.person_id === person?.id ? m : null;
}

/** Darf DIESE Person bei DIESER Meldung jetzt bestätigen?
 *
 *  AN EINER STELLE, weil es zwei Stellen gibt, die es wissen müssen:
 *  die Route, die die Antwort annimmt, und die Anzeige, die die
 *  Knöpfe zeigt. Standen sie getrennt da, driften sie — und genau das
 *  ist am 25.09.2026 im ersten Anlauf passiert: Der Server lehnte die
 *  Leitung richtig mit 404 ab, die Karte zeigte ihr die Knöpfe
 *  trotzdem. Zwei Knöpfe, die nur eine Fehlermeldung können, sind
 *  schlimmer als gar keine.
 *
 *  ES IST DER MELDER, NICHT „WER NICHT LEITUNG IST": Die Leitung darf
 *  ihre eigene Meldung sehr wohl selbst bestätigen — sie hat sie ja
 *  geschrieben. Verboten ist nur, FREMDE Arbeit abzunicken. */
function darfBestaetigen(m, personId) {
  return !!m && m.person_id === personId && m.stand === SUPPORT_STAND.wartet;
}

/** Wie eine Meldung nach draußen aussieht.
 *
 *  AN EINER STELLE, weil vier Routen sie ausgeben. Vier Stellen wären
 *  vier Gelegenheiten, ein Feld zu vergessen — oder eines zu viel
 *  mitzuschicken.
 *
 *  `fuerLeitung` entscheidet nur über die Zusatzangaben, nicht über
 *  den Inhalt: Wer meldet, sieht seine eigene Meldung vollständig,
 *  auch den Namen, den er selbst trägt.
 *
 *  `werFragtId` ist Pflicht, seit es die Knöpfe des Melders gibt —
 *  ohne sie ist `darf_bestaetigen` eine Aussage über die Meldung
 *  statt über den Betrachter, und die Leitung bekommt Knöpfe, die sie
 *  nicht drücken darf. */
function nachDraussen(m, fuerLeitung, werFragtId) {
  return {
    id: m.id,
    text: m.text,
    stand: m.stand,
    antwort: m.antwort || null,
    erstellt: m.erstellt,
    geaendert: m.geaendert,
    erledigt_am: m.erledigt_am || null,
    seite: m.seite || null,
    /* Das Bild als fertige ADRESSE, nicht als Dateiname — sonst setzt
       jede Stelle im Browser denselben Pfad zusammen, und eine davon
       setzt ihn irgendwann anders. Dieselbe Entscheidung wie beim
       Chat-Anhang. */
    bild: m.bild_datei ? `/workspace/api/support/${m.id}/bild` : null,
    bild_breite: m.bild_breite || 0,
    bild_hoehe: m.bild_hoehe || 0,
    von: m.von_name || null,
    von_rolle: m.von_rolle || null,
    /* Nur die Leitung braucht zu wissen, mit welchem Gerät gemeldet
       wurde. Für den Melder ist es seine eigene Angabe und nur
       Rauschen. */
    geraet: fuerLeitung ? (m.geraet || null) : undefined,
    /* ==== DER WEG BIS HIERHER (25.09.2026) =========================

       Filipe: „mit dem gedanken das manchmal sachen mehrmal nicht
       sofort perfekt sein werden."

       Die Runde und der ganze Verlauf gehen mit. Nur die letzte
       Antwort zu schicken hiesse: Bei Runde drei ist nicht mehr zu
       sehen, was beim ersten Mal versucht wurde -- und genau das
       loest einen wiederkehrenden Fehler.

       BEIDE SEITEN BEKOMMEN DENSELBEN VERLAUF. Der Melder soll lesen
       koennen, was schon probiert wurde; die Leitung, was er dazu
       gesagt hat. Es gibt hier nichts zu verbergen -- es sind seine
       eigenen Worte und die Antworten darauf. */
    runde: m.runde || 1,
    verlauf: verlaufVon(m.id),
    /* DARF ICH JETZT BESTAETIGEN? Vom Server beantwortet, nicht im
       Browser nachgerechnet: Dort stuende die Regel ein zweites Mal,
       und die zweite Fassung waere ab der naechsten Aenderung falsch. */
    darf_bestaetigen: darfBestaetigen(m, werFragtId),
  };
}

/** Der Verlauf einer Meldung -- eine Zeile je Runde. */
function verlaufVon(id) {
  return db().prepare(`SELECT nr, antwort, von_name, am, urteil, urteil_text, urteil_am
      FROM support_runden WHERE meldung_id = ? ORDER BY nr`).all(id)
    .map((r) => ({
      nr: r.nr, antwort: r.antwort, von: r.von_name || null, am: r.am,
      urteil: r.urteil || null, urteil_text: r.urteil_text || null,
      urteil_am: r.urteil_am || null,
    }));
}

/* =====================================================================
   LESEN
   ===================================================================== */

/** Die eigenen Meldungen — oder für die Leitung alle.
 *
 *  EINE ROUTE FÜR BEIDE, nicht zwei. Zwei Routen hießen zwei Stellen,
 *  an denen die Sichtbarkeitsregel gepflegt werden muss — und eine
 *  davon läuft irgendwann auseinander. */
supportRouter.get("/workspace/api/support", (req, res) => {
  try {
    const leitung = istLeitung(req.person);
    const zeilen = leitung
      ? db().prepare(`SELECT * FROM support_meldungen ORDER BY
          /* Offene zuerst, und darin die ältesten oben: Was am
             längsten wartet, gehört nach vorn. Erledigte danach, das
             Neueste zuerst. */
          CASE stand WHEN 'neu' THEN 0 WHEN 'in_arbeit' THEN 1 ELSE 2 END,
          CASE WHEN stand = 'erledigt' THEN -id ELSE id END
          LIMIT 300`).all()
      : db().prepare(`SELECT * FROM support_meldungen WHERE person_id = ?
          ORDER BY id DESC LIMIT 100`).all(req.person.id);

    res.json({
      leitung,
      meldungen: zeilen.map((m) => nachDraussen(m, leitung, req.person.id)),
      /* Die Zahlen stehen in der Antwort und werden nicht im Browser
         nachgezählt: Die Liste ist bei 300 abgeschnitten, eine Zählung
         darauf wäre ab der 301. Meldung still falsch. */
      offen: leitung
        ? db().prepare("SELECT COUNT(*) AS n FROM support_meldungen WHERE stand <> 'erledigt'")
          .get().n
        : db().prepare(`SELECT COUNT(*) AS n FROM support_meldungen
            WHERE person_id = ? AND stand <> 'erledigt'`).get(req.person.id).n,
      hoechstens_bytes: BILD_MAX,
      text_max: TEXT_MAX,
    });
  } catch (fehler) {
    console.error("[support] Liste:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Das Bild einer Meldung.
 *
 *  Dieselben Kopfzeilen wie beim Chat-Anhang: der Typ aus der
 *  ERKENNUNG (nicht der eingeschickte), nosniff, und eine Richtlinie,
 *  die dem Dokument jede Ausführung nimmt. */
supportRouter.get("/workspace/api/support/:id(\\d+)/bild", (req, res) => {
  try {
    const m = meldungFuer(req.person, req.params.id);
    if (!m || !m.bild_datei) return res.status(404).json({ fehler: "nicht_gefunden" });
    const pfad = join(BILD_ORDNER, m.bild_datei);
    try { statSync(pfad); } catch {
      return res.status(410).json({ fehler: "Das Bild fehlt auf der Platte." });
    }
    res.setHeader("Content-Type", m.bild_typ || "image/png");
    res.setHeader("X-Content-Type-Options", "nosniff");
    res.setHeader("Content-Security-Policy", "default-src 'none'; sandbox");
    res.setHeader("Cache-Control", "private, max-age=86400");
    createReadStream(pfad).pipe(res);
  } catch (fehler) {
    console.error("[support] Bild:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* =====================================================================
   MELDEN
   ===================================================================== */

/** Vor express.raw: Darf diese Person überhaupt melden?
 *
 *  Angemeldet sein genügt — „die jeder sieht, jeder benutzen kann".
 *  Die Prüfung steht trotzdem VOR der Annahme des Rumpfes, sonst
 *  wanderten zwölf Megabyte durch die Leitung, bevor irgendjemand
 *  fragt, wer da schickt. */
function darfMelden(req, res, next) {
  if (!req.person?.id) return res.status(401).json({ fehler: "nicht_angemeldet" });
  const offen = db().prepare(`SELECT COUNT(*) AS n FROM support_meldungen
    WHERE person_id = ? AND stand <> 'erledigt'`).get(req.person.id).n;
  if (offen >= OFFEN_MAX) {
    return res.status(429).json({
      fehler: `Du hast schon ${offen} offene Meldungen. Warte kurz ab, `
        + "bis sich jemand darum gekümmert hat.",
    });
  }
  next();
}

/** Eine Meldung abschicken.
 *
 *  EIN WEG FÜR BEIDES — mit Bild und ohne. Der Text reist im Kopf
 *  (`x-text`, prozentkodiert), das Bild im Rumpf. Zwei Routen zu
 *  bauen („/support" für Text, "/support/bild" für Bild) wäre die
 *  naheliegende Aufteilung und hätte einen Zustand dazwischen: eine
 *  Meldung, die schon existiert, während das Bild noch hochlädt —
 *  und bei einem Abbruch für immer ohne Bild dasteht.
 *
 *  Ein leerer Rumpf ist zulässig: Dann gibt es eben kein Bild. */
supportRouter.post("/workspace/api/support",
  darfMelden,
  express.raw({ type: "*/*", limit: BILD_MAX }),
  (req, res) => {
    let geschrieben = null;
    try {
      let text = "";
      try { text = decodeURIComponent(req.get("x-text") || ""); } catch { text = ""; }
      text = textSauber(text, TEXT_MAX);
      if (text.length < 5) {
        return res.status(400).json({
          fehler: "Schreib bitte kurz, was los ist – ein Satz reicht.",
        });
      }

      let bildDatei = null, bildTyp = null, bildBreite = 0, bildHoehe = 0;
      if (Buffer.isBuffer(req.body) && req.body.length) {
        const erkannt = dateiErkennen(req.body);
        /* NUR BILDER. dateiErkennen kennt auch PDF und Ton — hier geht
           es um Bildschirmfotos, und alles andere wäre eine Tür, die
           niemand bestellt hat. */
        if (!erkannt || erkannt.art !== "bild") {
          return res.status(415).json({
            fehler: "Als Anhang geht ein Foto – PNG, JPEG, WebP oder GIF.",
          });
        }
        mkdirSync(BILD_ORDNER, { recursive: true });
        bildDatei = `${Date.now()}-${randomBytes(8).toString("hex")}${erkannt.endung}`;
        writeFileSync(join(BILD_ORDNER, bildDatei), req.body);
        geschrieben = join(BILD_ORDNER, bildDatei);
        bildTyp = erkannt.typ;
        bildBreite = erkannt.breite || 0;
        bildHoehe = erkannt.hoehe || 0;
      }

      const n = jetzt();
      const info = db().prepare(`INSERT INTO support_meldungen
          (person_id, von_name, von_rolle, text, seite, geraet,
           bild_datei, bild_typ, bild_breite, bild_hoehe,
           stand, erstellt, geaendert)
        VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)`)
        .run(req.person.id, req.person.name || null, req.person.rolle || null,
          text, sauber(req.get("x-seite"), SEITE_MAX) || null,
          sauber(req.get("user-agent"), GERAET_MAX) || null,
          bildDatei, bildTyp, bildBreite, bildHoehe,
          SUPPORT_STAND.neu, n, n);
      const id = Number(info.lastInsertRowid);

      protokolliere("support_gemeldet", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${id} ${text.slice(0, 80)}`,
      });

      /* DIE LEITUNG ERFÄHRT ES SOFORT. Eine Meldung, die erst auffällt,
         wenn jemand die Seite zufällig öffnet, ist keine Meldung,
         sondern ein Zettel im Schrank.

         NICHT DRINGEND: Ein kaputter Knopf weckt niemanden um drei Uhr
         nachts. Die Ruhezeit gilt (siehe workspace-push.js). */
      for (const p of db().prepare(
        `SELECT id FROM personen WHERE aktiv = 1 AND rolle IN ('admin','hand')`).all()) {
        benachrichtige(p.id, "support", {
          titel: "Neue Support-Meldung",
          text: text.slice(0, 120),
          ziel: `/workspace/support.html?meldung=${id}`,
        }).catch(() => { /* eine ausgefallene Benachrichtigung darf die
                            Meldung nicht verhindern */ });
      }

      const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(id);
      res.status(201).json({
        meldung: nachDraussen(frisch, istLeitung(req.person), req.person.id),
      });
    } catch (fehler) {
      /* DIE DATEI GEHT MIT, WENN DIE ZEILE NICHT ZUSTANDE KAM. Sonst
         sammelt der Ordner Bilder an, zu denen es keine Meldung gibt —
         und niemand merkt es, weil nichts darauf zeigt. */
      if (geschrieben) { try { unlinkSync(geschrieben); } catch { /* egal */ } }
      console.error("[support] Melden:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

/* =====================================================================
   SICH KÜMMERN — nur die Leitung
   ===================================================================== */

/** Stand ändern und antworten.
 *
 *  EINE ROUTE FÜR BEIDES, weil es in der Oberfläche eine Handlung ist:
 *  „erledigt, und zwar deshalb". Zwei Routen hießen zwei Anfragen, und
 *  bei der zweiten kann das Netz abbrechen — dann steht die Meldung
 *  auf „erledigt" ohne den Satz, der sie erklärt. */
/* =====================================================================
   DER MELDER ANTWORTET: GEHT WIEDER ODER NOCH NICHT (25.09.2026)
   =====================================================================

   Filipe: „damit die bescheid wissen und dan anklicken koennen, es
   funktioniert, oder noch nicht. und erst wenn es funktioniert
   gedrueckt wird, will ich dass alles richtig fertig ist.
   perfektionier den ganzen weg und mit dem gedanken das manchmal
   sachen mehrmal nicht sofort perfekt sein werden."

   NUR DER MELDER, und zwar ausdruecklich NICHT die Leitung: Sonst
   koennte sie ihre eigene Arbeit bestaetigen, und der ganze Umweg
   waere Zierde. Deshalb steht hier `person_id !== req.person.id` --
   nicht „ist Leitung".

   „NOCH NICHT" IST KEINE BESCHWERDE, SONDERN DIE NAECHSTE RUNDE. Die
   Meldung geht zurueck in Arbeit, die Rundenzahl waechst um eins, und
   der Verlauf behaelt, was beim letzten Mal versucht wurde. Nichts
   wird geloescht, und niemand faengt von vorn an.

   EIN WORT DAZU IST BEI „NOCH NICHT" PFLICHT. „Geht immer noch nicht"
   ohne Zusatz erzeugt genau die Rueckfrage, die dieser ganze Weg
   sparen soll. Bei „geht wieder" ist es freiwillig -- da gibt es
   nichts mehr zu klaeren.

   `:id` OHNE MUSTER, dafuer mit einer Pruefung in der Zeile darunter:
   Ein Muster im Pfad ist eine zweite Stelle, an der eine Zahl
   geprueft wird -- und die im Code ist die, die man liest.
   ===================================================================== */
supportRouter.post("/workspace/api/support/:id/rueckmeldung",
  express.json(), (req, res) => {
    try {
      const id = Number(req.params.id);
      if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
      const m = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(id);
      /* 404 UND NICHT 403: Wer eine fremde Meldung nicht sehen darf,
         soll auch nicht erfahren, dass es sie gibt. Dieselbe
         Ueberlegung wie ueberall im Haus. */
      if (!m || m.person_id !== req.person.id) {
        return res.status(404).json({ fehler: "nicht_gefunden" });
      }
      /* 404 oben war die SICHTBARKEITSFRAGE, das hier ist die
         STANDFRAGE -- zwei verschiedene Auskünfte, deshalb zwei Codes.
         Gefragt wird mit derselben Funktion, die auch die Knöpfe
         zeigt: Was der Bildschirm anbietet und was der Server annimmt,
         ist damit ein Satz und nicht zwei. */
      if (!darfBestaetigen(m, req.person.id)) {
        return res.status(409).json({
          fehler: "Hier wartet gerade nichts auf deine Antwort.",
        });
      }

      const geht = req.body?.geht === true;
      const wort = textSauber(req.body?.text, ANTWORT_MAX);
      if (!geht && wort.length < 3) {
        return res.status(400).json({
          fehler: "Schreib kurz, was noch nicht geht – sonst fängt die Suche von vorn an.",
        });
      }

      const n = jetzt();
      const runde = m.runde || 1;
      db().prepare(`UPDATE support_runden
          SET urteil = ?, urteil_text = ?, urteil_am = ?
        WHERE meldung_id = ? AND nr = ?`)
        .run(geht ? "geht" : "nicht", wort || null, n, m.id, runde);

      if (geht) {
        db().prepare(`UPDATE support_meldungen
            SET stand = ?, geaendert = ?, erledigt_am = ?, erledigt_von = ?
          WHERE id = ?`)
          .run(SUPPORT_STAND.erledigt, n, n, req.person.id, m.id);
      } else {
        /* ZURUECK IN ARBEIT UND EINE RUNDE WEITER. Nicht auf „neu":
           Es hat ja schon jemand hingesehen, und „neu" waere die Sorte
           Zahl, die morgens laut ist und nichts meint. */
        db().prepare(`UPDATE support_meldungen
            SET stand = ?, runde = ?, geaendert = ?,
                erledigt_am = NULL, erledigt_von = NULL
          WHERE id = ?`)
          .run(SUPPORT_STAND.inArbeit, runde + 1, n, m.id);
      }

      protokolliere(geht ? "support_bestaetigt" : "support_nochmal", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `#${m.id} Runde ${runde}`,
      });

      /* UND DIE LEITUNG ERFAEHRT ES. Ohne diese Zeile merkt niemand,
         dass etwas zurueckgekommen ist -- die Meldung stuende wieder
         in der Liste, aber keiner saehe hin. */
      if (!geht) {
        const leitung = db().prepare(
          "SELECT id FROM personen WHERE rolle IN ('admin','hand') AND aktiv = 1").all();
        for (const l of leitung) {
          benachrichtige(l.id, "support", {
            titel: "Geht noch nicht – Runde " + (runde + 1),
            text: wort.slice(0, 120),
            ziel: `/workspace/support.html?meldung=${m.id}`,
          }).catch(() => { /* eine Meldung, die nicht ankommt, darf die
                              Antwort nicht verhindern */ });
        }
      }

      const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(m.id);
      res.json({ meldung: nachDraussen(frisch, false, req.person.id) });
    } catch (fehler) {
      console.error("[support] Rueckmeldung:", fehler?.message);
      res.status(503).json({ fehler: "nicht_verfuegbar" });
    }
  });

supportRouter.patch("/workspace/api/support/:id(\\d+)", express.json(), (req, res) => {
  try {
    if (!istLeitung(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
    const m = db().prepare("SELECT * FROM support_meldungen WHERE id = ?")
      .get(Number(req.params.id));
    if (!m) return res.status(404).json({ fehler: "nicht_gefunden" });

    /* ERLEDIGT IST ERLEDIGT. Eine geschlossene Meldung wird nicht
       stillschweigend wieder geöffnet und anders beantwortet — sonst
       ist „zugemacht" eine Meinung und keine Tatsache. Dieselbe Regel
       wie im vertraulichen Meldeweg. */
    if (m.stand === SUPPORT_STAND.erledigt) {
      return res.status(409).json({
        fehler: "Diese Meldung ist erledigt. Für etwas Neues bitte eine neue.",
      });
    }

    const wunsch = String(req.body?.stand || "");
    if (!Object.values(SUPPORT_STAND).includes(wunsch)) {
      /* EIN SATZ, KEINE KENNUNG (24.09.2026, gefunden von
         pruef-meldungen am selben Tag, an dem diese Datei entstand).

         Hier stand `fehler: "ungueltiger_stand"`. Das Haus verlangt
         zu jeder Kennung einen Satz in meldung.js -- sonst steht auf
         dem Bildschirm ein Wort mit Unterstrichen. Diesen Fall
         trifft ein Mensch zwar nie (die Oberflaeche schickt nur
         gueltige Staende), aber "trifft nie ein" ist genau die
         Begruendung, mit der solche Stellen stehen bleiben, bis sie
         doch jemand sieht.

         Ein Satz direkt hier statt eines Eintrags in der Tabelle:
         Die anderen Absagen dieser Route machen es ebenso, und ein
         Wort, das nur an einer Stelle vorkommt, braucht keine
         Uebersetzung an einer zweiten. */
      return res.status(400).json({
        fehler: "Diesen Stand gibt es nicht. Moeglich sind: neu, "
          + "in Arbeit, erledigt.",
      });
    }
    const antwort = textSauber(req.body?.antwort, ANTWORT_MAX);
    /* WER ZUMACHT, SAGT WARUM. Nicht als Schikane: Der Melder sieht
       nur, dass seine Sache zu ist — ohne einen Satz weiß er nicht, ob
       sie behoben wurde oder ob niemand Lust hatte. */
    if ((wunsch === SUPPORT_STAND.erledigt || wunsch === SUPPORT_STAND.wartet)
        && antwort.length < 3) {
      return res.status(400).json({
        fehler: "Schreib kurz dazu, was daraus geworden ist – der Melder sieht nur das.",
      });
    }

    /* ==== DER MELDER MACHT ZU, NICHT DIE LEITUNG (25.09.2026) ======

       Filipe: „damit die bescheid wissen und dan anklicken koennen, es
       funktioniert, oder noch nicht. und erst wenn es funktioniert
       gedrueckt wird, will ich dass alles richtig fertig ist."

       Wer „erledigt" waehlt, schickt die Meldung deshalb nicht zu,
       sondern ZURUECK AN DEN MELDER. Er sieht die Antwort und sagt,
       ob es bei ihm wirklich geht. Erst sein Druck schliesst.

       DIE AUSNAHME IST NOETIG, SONST HAENGT ES EWIG: Wenn die Leitung
       ihre EIGENE Meldung bearbeitet -- oder der Zugang des Melders
       geloescht wurde --, gibt es niemanden, der bestaetigen koennte.
       Dann bleibt „erledigt" erledigt. Ohne diese Zeile waere jede
       solche Meldung dauerhaft offen, und die Zahl oben stimmte nie
       wieder. */
    const braucht = wunsch === SUPPORT_STAND.erledigt
      && m.person_id && m.person_id !== req.person.id;
    const stand = braucht ? SUPPORT_STAND.wartet : wunsch;

    const n = jetzt();
    db().prepare(`UPDATE support_meldungen
        SET stand = ?, antwort = ?, geaendert = ?,
            erledigt_am = ?, erledigt_von = ?
      WHERE id = ?`)
      .run(stand, antwort || m.antwort || null, n,
        stand === SUPPORT_STAND.erledigt ? n : null,
        stand === SUPPORT_STAND.erledigt ? req.person.id : null,
        m.id);

    /* DIE RUNDE WIRD FESTGEHALTEN, sobald die Leitung antwortet. Sie
       entsteht hier und nicht beim Melden: Runde 1 beginnt mit dem
       ersten „so, probier mal", nicht mit dem Problem. */
    if (stand === SUPPORT_STAND.wartet && antwort) {
      /* NACHLEGEN ERSETZT, ES VERDOPPELT NICHT. Antwortet die Leitung
         ein zweites Mal, waehrend die Meldung schon beim Melder liegt
         („ach, und noch etwas ..."), gehoert das in DIESELBE Runde.
         Ohne diese Zeile stuenden zwei „Runde 1" untereinander, und
         sein spaeteres Urteil traefe beide gleichzeitig. */
      db().prepare(`INSERT INTO support_runden
          (meldung_id, nr, antwort, von_id, von_name, am)
          VALUES (?,?,?,?,?,?)
          ON CONFLICT (meldung_id, nr) DO UPDATE
            SET antwort = excluded.antwort, von_id = excluded.von_id,
                von_name = excluded.von_name, am = excluded.am`)
        .run(m.id, m.runde || 1, antwort, req.person.id, req.person.name, n);
    }

    protokolliere("support_bearbeitet", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${m.id} -> ${wunsch}`,
    });

    /* DER MELDER ERFÄHRT ES. Wer etwas meldet und nie wieder davon
       hört, meldet beim nächsten Mal nichts mehr. */
    if (m.person_id && m.person_id !== req.person.id) {
      benachrichtige(m.person_id, "support", {
        /* DER TITEL SAGT, WER JETZT DRAN IST. „Deine Meldung ist
           erledigt" waere bei „wartet" eine Luege -- sie ist es ja
           erst, wenn er es bestaetigt. Und ein Hinweis, der nicht
           sagt, dass man etwas tun soll, wird weggewischt. */
        titel: stand === SUPPORT_STAND.wartet
          ? "Geht es wieder? Kurz bestätigen"
          : (stand === SUPPORT_STAND.erledigt
            ? "Deine Meldung ist erledigt" : "Jemand kümmert sich"),
        text: antwort ? antwort.slice(0, 120) : m.text.slice(0, 120),
        ziel: `/workspace/support.html?meldung=${m.id}`,
      }).catch(() => { /* siehe oben */ });
    }

    const frisch = db().prepare("SELECT * FROM support_meldungen WHERE id = ?").get(m.id);
    res.json({ meldung: nachDraussen(frisch, true, req.person.id) });
  } catch (fehler) {
    console.error("[support] Bearbeiten:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* =====================================================================
   AUFRÄUMEN
   ===================================================================== */

/** Erledigte Meldungen nach der Aufbewahrungsfrist entfernen.
 *
 *  Wird aus dem Rundgang aufgerufen, nicht beim Lesen — sonst hängt
 *  das Aufräumen davon ab, dass jemand die Seite öffnet, und auf einem
 *  ruhigen System wächst der Bilderordner still weiter.
 *
 *  DIE DATEI GEHT MIT DER ZEILE. Ein Bild ohne Meldung zeigt auf
 *  nichts und niemand findet es je wieder. */
export function supportAufraeumen() {
  try {
    const grenze = new Date(Date.now() - AUFBEWAHRUNG_TAGE * 86400000).toISOString();
    const alt = db().prepare(`SELECT id, bild_datei FROM support_meldungen
      WHERE stand = 'erledigt' AND erledigt_am IS NOT NULL AND erledigt_am < ?`).all(grenze);
    if (!alt.length) return 0;
    for (const m of alt) {
      if (m.bild_datei) {
        try { unlinkSync(join(BILD_ORDNER, m.bild_datei)); } catch { /* schon weg */ }
      }
      db().prepare("DELETE FROM support_meldungen WHERE id = ?").run(m.id);
    }
    console.log(`[support] ${alt.length} erledigte Meldungen aelter als `
      + `${AUFBEWAHRUNG_TAGE} Tage entfernt.`);
    return alt.length;
  } catch (fehler) {
    console.error("[support] Aufraeumen:", fehler?.message);
    return 0;
  }
}