dogfather-universe/server/workspace-push.js

/* =====================================================================
   workspace-push.js — Benachrichtigungen, die wirklich ankommen.

   Wunsch Filipe (05.09.2026), mit dem Bild eines "Benachrichtigungen
   aus"-Knopfes: *"ich will auch sowas und dass es perfekt funktioniert
   auf der seite fuer jeden."*

   ---------------------------------------------------------------------
   WAS DAS LOEST

   Bis hierher erscheinen Hinweise NUR, wenn man die Seite aufruft. Wer
   nicht hinschaut, verpasst sie -- und genau das ist der Normalfall:
   Man macht den Workspace auf, wenn man ohnehin daran denkt. Der
   Perfektionsplan sagt dazu: *"Das Deck verspricht Erinnerungen. Wer
   nicht hinschaut, verpasst sie."*

   ---------------------------------------------------------------------
   OHNE FREMDEN DIENST, OHNE KONTO, OHNE GEBUEHR

   Push API und Service Worker sind Browserstandard. Der Server braucht
   nur ein eigenes Schluesselpaar (VAPID); die Nachricht wird fuer jedes
   Geraet einzeln verschluesselt. Google, Mozilla und Apple leiten sie
   weiter, sehen aber nur Zeichensalat -- der Inhalt bleibt zwischen
   diesem Server und dem Browser.

   Die Rechnung dafuer steht in workspace-push-krypto.js und ist gegen
   die Testvektoren von RFC 8291 und 8292 geprueft.

   ---------------------------------------------------------------------
   VIER REGELN, DIE DARUEBER ENTSCHEIDEN, OB ES BENUTZT WIRD

   1. NICHTS ZWEIMAL. Jede Erinnerung wird je Person und Sache genau
      einmal verschickt (Tabelle push_verschickt). Viermal am Tag
      dieselbe Meldung ist der schnellste Weg, dass jemand alles
      abschaltet -- und dann fehlt auch die wichtige.

   2. NACHTS NICHT. Zwischen 22 und 7 Uhr wird nichts zugestellt.
      Aufgehoben wird nichts: Was morgens noch gilt, geht morgens raus;
      was sich erledigt hat, ist zu Recht weg.

   3. JE ART ABSCHALTBAR, nicht alles oder nichts.

   4. EINE BENACHRICHTIGUNG HAT IMMER EIN ZIEL. Wer sie antippt, landet
      an der Stelle, um die es geht -- nicht auf der Startseite.

   ---------------------------------------------------------------------
   WICHTIG FUERS IPHONE

   Dort funktioniert Push NUR, wenn die Seite zum Home-Bildschirm
   hinzugefuegt wurde. Im Safari-Reiter gibt es keine Berechtigung --
   der Knopf sagt das dann auch genau so, statt einen Fehler zu zeigen.
   ===================================================================== */

import express from "express";
import {
  db, protokolliere, echteIp, sitzungLesen, istDogFather,
  einstellung, einstellungSetzen, heuteLokal,
} from "./workspace.js";
import { schluesselErzeugen, schicken } from "./workspace-push-krypto.js";

export const pushRouter = express.Router();

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

/* ---------------------------------------------------------------------
   DIE ARTEN. Was es gibt, steht hier -- nicht in der Datenbank: Es ist
   eine bewusste Auswahl, keine Nutzdaten. Wer eine neue Art braucht,
   traegt sie hier ein und sie erscheint von selbst in den
   Einstellungen.
   ------------------------------------------------------------------ */
export const ARTEN = [
  { schluessel: "aufgabe_faellig", name: "Aufgabe wird morgen fällig", vorgabe: true },
  { schluessel: "aufgabe_ueberfaellig", name: "Aufgabe ist überfällig", vorgabe: true },
  { schluessel: "termin_gleich", name: "Termin in einer Stunde", vorgabe: true },
  /* DER WECKER (07.09.2026). Bewusst eine EIGENE Art neben
     "termin_gleich": Die eine ist eine Vorgabe des Hauses fuer jeden
     Termin, der andere ist eine Entscheidung DIESER Person fuer DIESEN
     Termin. Wer die feste Stunden-Erinnerung abschaltet, will damit
     nicht seine selbst gesetzten Wecker verlieren. */
  { schluessel: "termin_wecker", name: "Selbst gesetzter Wecker", vorgabe: true },
  { schluessel: "protokoll_fehlt", name: "Gespräch ohne Protokoll", vorgabe: true },
  { schluessel: "followup", name: "Follow-up in der Pipeline fällig", vorgabe: true },
  /* Chat (06.09.2026). Steht bewusst VOR der Probe: Es ist die Art,
     die am haeufigsten kommt, und wer die Liste ueberfliegt, sucht
     zuerst sie. */
  { schluessel: "chat_nachricht", name: "Neue Nachricht im Chat", vorgabe: true },
  { schluessel: "test", name: "Probe-Benachrichtigung", vorgabe: true },
];
const ARTEN_SCHLUESSEL = new Set(ARTEN.map((a) => a.schluessel));

/** Wie ein Vorlauf heisst, wenn er im Meldungskopf steht.
 *
 *  In Minuten gerechnet, in Worten gemeldet: "In einer Woche" liest
 *  sich beim Aufwachen besser als "10080 Minuten vorher". Die Staffel
 *  ist dieselbe, die die Oberflaeche anbietet -- kaeme hier eine
 *  ungerade Zahl an, faellt sie auf den allgemeinen Satz zurueck statt
 *  auf einen falschen. */
export function vorlauf(minuten) {
  const m = Number(minuten) || 0;
  if (m >= 10080) return "Erinnerung: in einer Woche";
  if (m >= 4320) return "Erinnerung: in drei Tagen";
  if (m >= 1440) return "Erinnerung: morgen";
  if (m >= 720) return "Erinnerung: heute";
  if (m >= 120) return `Erinnerung: in ${Math.round(m / 60)} Stunden`;
  if (m >= 60) return "Erinnerung: in einer Stunde";
  if (m > 0) return `Erinnerung: in ${m} Minuten`;
  return "Erinnerung: jetzt";
}

/* RUHEZEIT. Nichts zwischen 22 und 7 Uhr.

   DIE GRENZEN SIND SEIT DEM 07.09.2026 EINSTELLBAR, und der Grund ist
   eine Pruefung, die sich selbst ins Knie geschossen hat: Die
   Weckerpruefung lief um 23:42 und meldete vier Fehler -- der Melder
   schwieg, weil Ruhezeit war. Sie hat also den Kalender gemessen, nicht
   die Software, und waere um 10 Uhr gruen gewesen. Genau die Zeitbombe,
   die in der Projektnotiz steht.

   Eine Pruefung darf ihre Voraussetzung herstellen duerfen. Deshalb
   liest die Ruhezeit jetzt aus der Umgebung -- Vorgabe unveraendert
   22 bis 7, und im Betrieb setzt niemand etwas anderes. Die Alternative
   waere gewesen, in der Pruefung eine Zeit zu faelschen; das faelscht
   dann irgendwann auch etwas anderes mit.

   Nebennutzen: Wenn das Team eines Tages andere Zeiten will, ist es
   eine Umgebungsvariable und kein Programmierauftrag. */
const RUHE_AB = Number(process.env.PUSH_RUHE_AB ?? 22);
const RUHE_BIS = Number(process.env.PUSH_RUHE_BIS ?? 7);
export function istRuhezeit(d = new Date()) {
  const s = d.getHours();
  return s >= RUHE_AB || s < RUHE_BIS;
}

/* ---------------------------------------------------------------------
   Das Schluesselpaar des Servers. Einmal erzeugt, danach in den
   Einstellungen -- NICHT im Code und nicht in einer Datei im Repo.
   Der private Teil verlaesst den Server nie.
   ------------------------------------------------------------------ */
export function paarHolen() {
  let roh = einstellung("vapid_paar");
  if (roh) {
    try {
      const p = JSON.parse(roh);
      if (p?.oeffentlich && p?.privat) return p;
    } catch { /* kaputt -- unten neu erzeugen */ }
  }
  const neu = schluesselErzeugen();
  einstellungSetzen("vapid_paar", JSON.stringify(neu));
  console.log("[push] Neues VAPID-Schluesselpaar erzeugt.");
  return neu;
}

/** Die Absenderangabe fuer VAPID. Der Push-Dienst schreibt hierhin,
 *  wenn dauerhaft etwas nicht stimmt. */
const ABSENDER = process.env.PUSH_ABSENDER || "mailto:[email protected]";

/* ---------------------------------------------------------------------
   Will diese Person diese Art bekommen?
   ------------------------------------------------------------------ */
export function willHaben(personId, art) {
  const z = db().prepare(
    "SELECT an FROM push_einstellungen WHERE person_id = ? AND art = ?").get(personId, art);
  if (z) return !!z.an;
  return ARTEN.find((a) => a.schluessel === art)?.vorgabe ?? true;
}

/* ---------------------------------------------------------------------
   VERSCHICKEN — der einzige Weg nach draussen.

   Alles laeuft hier durch: Ruhezeit, Einstellung, Doppelsperre,
   Aufraeumen toter Anmeldungen. Eine zweite Stelle, die selbst
   verschickt, wuerde eine dieser Regeln irgendwann vergessen.
   ------------------------------------------------------------------ */
export async function benachrichtige(personId, art, { titel, text, ziel, merkmal }) {
  if (!ARTEN_SCHLUESSEL.has(art)) return { verschickt: 0, grund: "unbekannte_art" };
  if (!willHaben(personId, art)) return { verschickt: 0, grund: "abgeschaltet" };

  /* Die Probe darf immer durch -- sie beantwortet die Frage "kommt
     ueberhaupt etwas an?", und die stellt man sich auch um 23 Uhr. */
  if (art !== "test" && istRuhezeit()) return { verschickt: 0, grund: "ruhezeit" };

  /* Schon einmal geschickt? */
  if (merkmal) {
    const da = db().prepare(
      "SELECT 1 FROM push_verschickt WHERE person_id = ? AND merkmal = ?").get(personId, merkmal);
    if (da) return { verschickt: 0, grund: "schon_geschickt" };
  }

  const anmeldungen = db().prepare(
    "SELECT * FROM push_anmeldungen WHERE person_id = ?").all(personId);
  if (!anmeldungen.length) return { verschickt: 0, grund: "keine_geraete" };

  const paar = paarHolen();
  const inhalt = JSON.stringify({ titel, text, ziel: ziel || "/workspace/start.html", art });

  let raus = 0;
  for (const a of anmeldungen) {
    const e = await schicken(a, inhalt, paar, ABSENDER);
    if (e.ok) {
      raus++;
      db().prepare("UPDATE push_anmeldungen SET zuletzt_ok = ?, fehler = 0 WHERE endpunkt = ?")
        .run(jetzt(), a.endpunkt);
    } else if (e.weg) {
      /* Der Push-Dienst sagt: dieses Geraet gibt es nicht mehr.
         Aufheben waere sinnlos und wuerde bei jedem Lauf erneut
         scheitern. */
      db().prepare("DELETE FROM push_anmeldungen WHERE endpunkt = ?").run(a.endpunkt);
    } else {
      db().prepare("UPDATE push_anmeldungen SET fehler = fehler + 1 WHERE endpunkt = ?")
        .run(a.endpunkt);
    }
  }

  if (raus && merkmal) {
    db().prepare("INSERT OR REPLACE INTO push_verschickt (person_id, merkmal, zeit) VALUES (?,?,?)")
      .run(personId, merkmal, jetzt());
  }
  return { verschickt: raus, grund: raus ? "ok" : "nicht_zugestellt" };
}

/* ---------------------------------------------------------------------
   WAS STEHT AN? — der Takt.

   Fragt dieselben Daten ab, aus denen auch die Hinweisliste auf der
   Startseite entsteht. Bewusst KEINE eigenen Daten: Was erledigt wird,
   verschwindet von selbst, und es gibt nichts zu pflegen, das
   veralten kann.
   ------------------------------------------------------------------ */
export async function laufen() {
  const d = db();
  const heute = heuteLokal();
  const morgen = new Date(Date.parse(heute + "T00:00:00Z") + 86400_000).toISOString().slice(0, 10);
  let gesamt = 0;

  const senden = async (personId, art, sache) => {
    const e = await benachrichtige(personId, art, sache);
    gesamt += e.verschickt;
  };

  try {
    /* --- Aufgaben, die morgen faellig sind ---------------------------- */
    for (const a of d.prepare(`
      SELECT a.id, a.titel, a.verantwortlich_id FROM aufgaben a
      WHERE a.status NOT IN ('erledigt', 'abgebrochen') AND a.frist = ? AND a.verantwortlich_id IS NOT NULL`).all(morgen)) {
      await senden(a.verantwortlich_id, "aufgabe_faellig", {
        titel: "Morgen fällig",
        text: a.titel,
        ziel: "/workspace/aufgaben.html",
        merkmal: `aufgabe_faellig:${a.id}:${morgen}`,
      });
    }

    /* --- Aufgaben, die ueberfaellig sind ------------------------------ */
    for (const a of d.prepare(`
      SELECT a.id, a.titel, a.frist, a.verantwortlich_id FROM aufgaben a
      WHERE a.status NOT IN ('erledigt', 'abgebrochen') AND a.frist IS NOT NULL AND a.frist < ?
        AND a.verantwortlich_id IS NOT NULL`).all(heute)) {
      await senden(a.verantwortlich_id, "aufgabe_ueberfaellig", {
        titel: "Überfällig",
        text: a.titel,
        ziel: "/workspace/aufgaben.html",
        /* Das Datum gehoert ins Merkmal: Eine Aufgabe, die drei Wochen
           liegen bleibt, soll nicht dreimal am Tag erinnern -- aber
           einmal am Tag schon. */
        merkmal: `aufgabe_ueberfaellig:${a.id}:${heute}`,
      });
    }

    /* --- Termine in der naechsten Stunde ------------------------------ */
    const gleich = new Date(Date.now() + 60 * 60_000);
    const p = (n) => String(n).padStart(2, "0");
    const bis = `${gleich.getFullYear()}-${p(gleich.getMonth() + 1)}-${p(gleich.getDate())}`
      + `T${p(gleich.getHours())}:${p(gleich.getMinutes())}`;
    const jetztText = (() => {
      const n = new Date();
      return `${n.getFullYear()}-${p(n.getMonth() + 1)}-${p(n.getDate())}`
        + `T${p(n.getHours())}:${p(n.getMinutes())}`;
    })();

    for (const t of d.prepare(`
      SELECT t.id, t.titel, t.beginn, t.art FROM termine t
      WHERE t.erledigt = 0 AND t.beginn >= ? AND t.beginn <= ?`).all(jetztText, bis)) {
      /* An ALLE Teilnehmer, nicht nur an das Haupt-Gegenueber -- seit
         ein Termin mehrere haben kann (05.09.2026). */
      const leute = d.prepare(
        "SELECT person_id FROM termin_teilnehmer WHERE termin_id = ?").all(t.id).map((r) => r.person_id);
      for (const pid of new Set(leute)) {
        await senden(pid, "termin_gleich", {
          titel: t.art === "call" ? "Call in Kürze" : "Termin in Kürze",
          text: `${t.titel} · ${t.beginn.slice(11, 16)} Uhr`,
          ziel: t.art === "call" ? "/workspace/calls.html" : "/workspace/kalender.html",
          merkmal: `termin_gleich:${t.id}`,
        });
      }
    }

    /* --- DIE SELBST GESETZTEN WECKER ----------------------------------

       Ein Wecker steht als ABSTAND in der Datenbank (minuten_vorher),
       nicht als Zeitpunkt. Die Weckzeit wird deshalb hier gerechnet --
       und ist damit auch nach einer Terminverschiebung richtig, ohne
       dass irgendjemand etwas nachziehen muss.

       ZWEI GRENZEN, und beide sind noetig:

         faellig    die Weckzeit ist erreicht (beginn - abstand <= jetzt)
         nicht zu spaet   der Termin liegt noch VOR uns

       Ohne die zweite wuerde beim ersten Lauf nach einer Auszeit des
       Dienstes jeder alte Wecker der letzten Wochen nachtraeglich
       klingeln -- ein Schwall Meldungen zu Terminen, die laengst vorbei
       sind. Das ist der Fall, den man beim Bauen nie sieht und der beim
       ersten Neustart nach einem Ausfall sofort auffaellt.

       DIE RUHEZEIT VERSCHLUCKT NICHTS. `benachrichtige` merkt sich erst
       nach dem Verschicken, dass etwas raus ist -- was zwischen 22 und
       7 Uhr faellig wird, geht also am Morgen raus, sobald der Termin
       noch bevorsteht. Ein Wecker, der nachts still ist und dafuer
       morgens klingelt, ist genau richtig; einer, der verschluckt wird,
       waere schlimmer als keiner.

       Rechnen auf Textebene geht hier NICHT (Abstand in Minuten), also
       mit Date -- aber ausschliesslich lokal, nie ueber toISOString. */
    const alsText = (dt) => {
      const p2 = (n) => String(n).padStart(2, "0");
      return `${dt.getFullYear()}-${p2(dt.getMonth() + 1)}-${p2(dt.getDate())}`
        + `T${p2(dt.getHours())}:${p2(dt.getMinutes())}`;
    };
    for (const w of d.prepare(`
      SELECT w.termin_id, w.person_id, w.minuten_vorher,
             t.titel, t.beginn, t.art
        FROM termin_wecker w
        JOIN termine t ON t.id = w.termin_id
       WHERE t.erledigt = 0 AND t.beginn > ?`).all(jetztText)) {
      const beginn = new Date(String(w.beginn).replace(" ", "T"));
      if (Number.isNaN(beginn.getTime())) continue;
      const weckzeit = new Date(beginn.getTime() - w.minuten_vorher * 60_000);
      if (alsText(weckzeit) > jetztText) continue;          // noch nicht so weit

      await senden(w.person_id, "termin_wecker", {
        titel: vorlauf(w.minuten_vorher),
        text: `${w.titel} · ${String(w.beginn).slice(8, 10)}.${String(w.beginn).slice(5, 7)}. `
          + `um ${String(w.beginn).slice(11, 16)} Uhr`,
        ziel: w.art === "call" ? "/workspace/calls.html" : "/workspace/kalender.html",
        /* Der Abstand gehoert ins Merkmal. Ohne ihn wuerde der erste
           Wecker eines Termins alle weiteren als "schon geschickt"
           sperren -- und genau das Mehrfach-Wecken, um das es geht,
           faende nie statt. */
        merkmal: `wecker:${w.termin_id}:${w.minuten_vorher}`,
      });
    }

    /* --- Gespraeche ohne Protokoll ------------------------------------ */
    for (const t of d.prepare(`
      SELECT t.id, t.titel, t.erstellt_von FROM termine t
      LEFT JOIN protokolle pr ON pr.termin_id = t.id
      WHERE t.art IN ('call','review') AND t.beginn < ? AND pr.id IS NULL
        AND t.beginn > ? AND t.erstellt_von IS NOT NULL`)
      .all(jetztText, heute + "T00:00")) {
      await senden(t.erstellt_von, "protokoll_fehlt", {
        titel: "Protokoll fehlt",
        text: t.titel,
        ziel: "/workspace/calls.html",
        merkmal: `protokoll_fehlt:${t.id}`,
      });
    }

    /* --- Faellige Follow-ups in der Pipeline --------------------------- */
    for (const l of d.prepare(`
      SELECT l.id, l.name, l.scout_id FROM leads l
      WHERE l.naechster_followup IS NOT NULL AND l.naechster_followup <= ?
        AND l.status NOT IN ('uebergeben','abgelehnt') AND l.scout_id IS NOT NULL`).all(heute)) {
      await senden(l.scout_id, "followup", {
        titel: "Nachfassen",
        text: l.name,
        ziel: "/workspace/scouting.html",
        merkmal: `followup:${l.id}:${heute}`,
      });
    }

    /* Alte Merkmale aufraeumen -- nach 60 Tagen braucht sie niemand
       mehr, und die Tabelle soll nicht ewig wachsen. */
    const grenze = new Date(Date.now() - 60 * 86400_000).toISOString();
    d.prepare("DELETE FROM push_verschickt WHERE zeit < ?").run(grenze);
  } catch (fehler) {
    console.error("[push] Lauf:", fehler?.message);
  }
  return gesamt;
}

/* ---------------------------------------------------------------------
   Der Takt. Wie bei der Sicherung: im Prozess, kein Systemdienst, kein
   Cron -- eine Sache weniger, die stillschweigend ausfallen kann.
   ------------------------------------------------------------------ */
let takt = null;
export function pushStarten() {
  if (takt) return;
  /* Alle fuenf Minuten. Feiner braucht es nicht: Die feinste
     Erinnerung ist "Termin in einer Stunde". */
  takt = setInterval(() => { laufen().catch(() => {}); }, 5 * 60_000);
  takt.unref?.();
  setTimeout(() => { laufen().catch(() => {}); }, 20_000).unref?.();
}

/* =====================================================================
   Die Schnittstellen
   ===================================================================== */

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  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();
}

pushRouter.use("/workspace/api/push", angemeldet);

/** Was der Browser braucht, um sich anzumelden: der oeffentliche
 *  Schluessel. Der private bleibt hier. */
pushRouter.get("/workspace/api/push/schluessel", (req, res) => {
  try {
    res.json({ schluessel: paarHolen().oeffentlich });
  } catch (fehler) {
    console.error("[push] Schluessel:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Der eigene Stand: angemeldete Geraete und die Einstellungen. */
pushRouter.get("/workspace/api/push/stand", (req, res) => {
  try {
    const geraete = db().prepare(`
      SELECT endpunkt, geraet, erstellt, zuletzt_ok FROM push_anmeldungen
      WHERE person_id = ? ORDER BY erstellt`).all(req.person.id);
    const arten = ARTEN.map((a) => ({
      ...a, an: willHaben(req.person.id, a.schluessel),
    }));
    res.json({
      /* Nur die Anzahl und ein Kuerzel nach aussen -- der volle
         Endpunkt ist die Zustelladresse dieses Geraets und hat in der
         Oberflaeche nichts zu suchen. */
      geraete: geraete.map((g) => ({
        kennung: g.endpunkt.slice(-12),
        geraet: g.geraet || "Unbekanntes Gerät",
        erstellt: g.erstellt, zuletzt_ok: g.zuletzt_ok,
      })),
      arten,
      ruhe: { ab: RUHE_AB, bis: RUHE_BIS, jetzt: istRuhezeit() },
    });
  } catch (fehler) {
    console.error("[push] Stand:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Ein Geraet anmelden. */
pushRouter.post("/workspace/api/push/anmelden", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
  try {
    const { endpunkt, p256dh, auth, geraet } = req.body || {};
    if (typeof endpunkt !== "string" || !/^https:\/\//.test(endpunkt) || endpunkt.length > 1000) {
      return res.status(400).json({ fehler: "Die Adresse sieht nicht richtig aus." });
    }
    if (typeof p256dh !== "string" || typeof auth !== "string" || !p256dh || !auth) {
      return res.status(400).json({ fehler: "Es fehlen die Schlüssel des Browsers." });
    }

    /* INSERT OR REPLACE auf dem Endpunkt: Meldet sich derselbe Browser
       erneut, wird der Eintrag ersetzt statt verdoppelt -- sonst kaeme
       jede Nachricht mehrfach an. */
    db().prepare(`
      INSERT OR REPLACE INTO push_anmeldungen
        (endpunkt, person_id, p256dh, auth, geraet, erstellt, zuletzt_ok, fehler)
      VALUES (?,?,?,?,?,?,NULL,0)`).run(
      endpunkt, req.person.id, p256dh, auth,
      String(geraet || "").slice(0, 80) || null, jetzt());

    protokolliere("push_angemeldet", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: String(geraet || "").slice(0, 60),
    });
    res.status(201).json({ ok: true });
  } catch (fehler) {
    console.error("[push] Anmelden:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Ein Geraet abmelden. */
pushRouter.post("/workspace/api/push/abmelden", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
  try {
    const endpunkt = String(req.body?.endpunkt || "");
    /* NUR die eigenen -- sonst koennte man fremde Geraete stumm
       schalten, wenn man deren Adresse kennt. */
    const e = db().prepare("DELETE FROM push_anmeldungen WHERE endpunkt = ? AND person_id = ?")
      .run(endpunkt, req.person.id);
    protokolliere("push_abgemeldet", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
    });
    res.json({ ok: true, entfernt: Number(e.changes) });
  } catch (fehler) {
    console.error("[push] Abmelden:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Eine Art an- oder abschalten. */
pushRouter.put("/workspace/api/push/art", gleicheHerkunft, express.json({ limit: "8kb" }), (req, res) => {
  try {
    const art = String(req.body?.art || "");
    if (!ARTEN_SCHLUESSEL.has(art)) return res.status(400).json({ fehler: "Diese Art gibt es nicht." });
    const an = req.body?.an ? 1 : 0;
    db().prepare(`INSERT INTO push_einstellungen (person_id, art, an) VALUES (?,?,?)
      ON CONFLICT(person_id, art) DO UPDATE SET an = excluded.an`).run(req.person.id, art, an);
    res.json({ ok: true, art, an: !!an });
  } catch (fehler) {
    console.error("[push] Art:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/** Eine Probe an die eigenen Geraete. Beantwortet die einzige Frage,
 *  die man wirklich hat: Kommt etwas an? */
pushRouter.post("/workspace/api/push/probe", gleicheHerkunft, async (req, res) => {
  try {
    const e = await benachrichtige(req.person.id, "test", {
      titel: "Es funktioniert",
      text: "So sieht eine Benachrichtigung aus dem Workspace aus.",
      ziel: "/workspace/start.html",
    });
    res.json(e);
  } catch (fehler) {
    console.error("[push] Probe:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});