Teilen: der Beitrag stellt sich selbst in den Agentur-Kanal

Filipe: "ich will dass wenn ich es teile im discord der agentur, dass
ein banner und ein kompletter fertiger text fuer die creator entsteht
und nicht einfach der link kopiert wird." Den fertigen Text gibt es
seit fdadd5d5; was fehlte, war der letzte Schritt -- bisher musste er
ihn selbst einfuegen.

NEU AN DER KACHEL: ein Knopf "In den Agentur-Kanal stellen", sobald ein
Kanal eingerichtet ist. Der Browser schickt dabei KEINEN Text mit --
der Server stellt ihn aus denselben Daten noch einmal zusammen. Sonst
koennte jemand mit einem veraenderten Text unter unserem Namen posten.

EINGERICHTET WIRD IM WORKSPACE, NICHT AUF DER KOMMANDOZEILE. Die
Webhook-Adresse IST der Schluessel zum Kanal; ueber einen Befehl
eingetragen landet sie im Chatverlauf, im Bildschirmfoto und in
~/.bash_history -- am 03.09.2026 ist genau das mit einem Token
passiert. Gemessen am 08.10.2026 kann `claudian` die Datei ohnehin
nicht anlegen: /home/dogiweb/workspace-daten ist drwxr-xr-x
dogiweb:dogiweb, und `sudo -l` deckt `dogiweb` nicht ab. Der Dienst
kann es. Damit braucht der Weg keine Rechteaenderung, kein root und
keinen Neustart.

DAS GEHEIMNIS liegt in /home/dogiweb/workspace-daten/discord-webhook.txt
mit 600, wird bei JEDEM Aufruf gelesen (ein Austausch wirkt sofort) und
kommt nie wieder heraus: GET beantwortet nur "ist eingerichtet" und
"seit wann", das Protokoll nennt sie nicht, und die Teilen-Antwort
auch nicht.

DIE SCHRANKEN, jede einzeln gemessen:
  - nur discord.com/discordapp.com/ptb./canary., nur https, nur Wege
    unter /api/webhooks/ -- sonst waere das Feld ein Weg, den Server zu
    beliebigen Zielen sprechen zu lassen
  - nur die Leitung, nur die Agentur-Adresse; von crew.* aus 404 statt
    403, damit man nicht erahnen kann, was es woanders gibt
  - allowed_mentions leer: im Beitrag steht TikToks Text, und ein
    "@everyone" darin wuerde sonst den ganzen Server anpingen
  - keine flags: die Vorschau bleibt an, denn genau sie ist das Banner
  - ohne Teilen-Link keine Nachricht
  - zwoelf je Stunde und Person, gezaehlt im Protokoll (Erfolge UND
    Fehlschlaege -- sonst bremst sie den nicht, der in einer Schleife
    haengt; derselbe Fehler wie am 07.10. an der Kampagnen-Bremse)

SIEBEN NEUE KENNUNGEN, sieben Saetze in meldung.js -- verlangt hat sie
`pruef-meldungen`, nicht mein Gedaechtnis. Jeder Satz sagt auch, was
stattdessen geht: Der Beitrag liegt in jedem Fall zum Kopieren da.

ZWEI FEHLER FANDEN NUR DIE PRUEFUNGEN:
  - teilenRouter.use("/workspace/api/eintrag", angemeldet) deckte die
    neuen Kanal-Wege nicht ab. Ohne req.person ist istLeitung falsch,
    also antworteten sie JEDEM mit 403 "nicht_erlaubt", auch
    DogFather. Es ist ZU gescheitert, nicht auf -- aber die Auskunft
    schickte in die falsche Richtung.
  - Das Datum im Dateikopf kam aus UTC (pruef-struktur): zwischen 00:00
    und 02:00 stuende dort der Vortag, in einer Zeile, die spaeter
    jemand liest, um zu wissen, seit wann der Kanal gilt.

Geprueft: pruef-kampagne 190 -> 226 (Abschnitte 12c und 12d), mit einer
ehrlichen Luecke -- die Dateirechte lassen sich auf Windows nicht
messen, auf dem Server schon; die Schlusszeile sagt jetzt "IN ORDNUNG,
mit Luecke" statt "ALLES IN ORDNUNG". bild-kampagne 53 -> 83
(Kanalfeld vermessen und abgebildet, Eingabefeld 45/46 px auf beiden
Breiten). Dazu gruen: meldungen 10, struktur, css-klassen, zeichen,
deutsche-texte, alle-wege, schranke, ports, portnummern, tippziele,
lesbarkeit, agentur 67, eventkarte 190, workspace-seiten 37,
haus-trennung 107, formulare 23, fingermass.

SECHS GEGENPROBEN am Weg in den Kanal, alle sechs schlagen an:
Rechnerliste uebergangen, Erwaehnungen wieder erlaubt, Vorschau
unterdrueckt, Bremse aus, ohne Teilen-Link gesendet, Adresse in die
Antwort gelegt.

NEBENBEI, UND ES WAR MEIN EIGENER REST: pruef-kampagne-lesen war seit
698c23e2 rot, also seit heute Vormittag. Mit dem Bildleser kamen drei
Pruefdaten in den Ordner, und die Wache dort verlangt zu Recht, dass
nichts Unerklaertes liegenbleibt. Ich hatte sie VOR dem Commit
gemessen und danach nicht noch einmal -- ein Pruefstand von vorher ist
keiner. Die drei sind jetzt benannt, mit Grund, und eine Gegenwache
prueft, dass es jede noch gibt. 186 -> 187, zwei Gegenproben: eine
unbekannte Datei faellt auf, ein toter Eintrag in der Liste auch.

server/workspace-teilen.js

@@ -61,7 +61,7 @@
 import express from "express";
 import { randomBytes } from "node:crypto";
 import { join } from "node:path";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, chmodSync, rmSync, statSync } from "node:fs";
 import {
   db, protokolliere, echteIp, sitzungLesen, istLeitung,
   DATEN_ORDNER } from "./workspace.js";
@@ -73,6 +73,11 @@ import { liefereDatei } from "./helfer-ausliefern.mjs";
    geteilte Seite zeigt irgendwann etwas anderes als die Kachel,
    und niemand koennte sagen, welche von beiden recht hat. */
 import { gliederung } from "./kampagne-lesen.mjs";
+/* ORTSZEIT, NICHT UTC. `toISOString()` schreibt zwischen 00:00 und
+   02:00 deutscher Zeit den Vortag -- in eine Zeile, die später
+   jemand liest, um zu wissen, seit wann der Kanal gilt. Gefunden
+   hat das `pruef-struktur`, nicht das Nachdenken. */
+import { heuteLokal } from "./helfer-tag.mjs";
 import { punkteAusText } from "./workspace-bereiche.js";
 
 export const teilenRouter = express.Router();
@@ -102,6 +107,13 @@ function angemeldet(req, res, next) {
 /* ---------- Der Knopf im Workspace ------------------------------------ */
 
 teilenRouter.use("/workspace/api/eintrag", angemeldet);
+/* UND FÜR DIE KANAL-WEGE (08.10.2026). Ein `use` mit Pfad gilt nur
+   für diesen Pfad -- wer daneben eine Route anlegt, hat dort kein
+   `req.person`. Beim ersten Prüflauf antworteten die drei Kanal-Wege
+   deshalb jedem mit 403 „dafür fehlt dir die Berechtigung", auch
+   DogFather. Es ist ZU gescheitert, nicht auf -- aber die Auskunft
+   schickte in die falsche Richtung. */
+teilenRouter.use("/workspace/api/teilen", angemeldet);
 
 /** Das Event holen und prüfen, ob es überhaupt geteilt werden darf. */
 function eventFuer(req, res) {
@@ -183,7 +195,13 @@ teilenRouter.post("/workspace/api/eintrag/:id(\\d+)/teilen", (req, res) => {
       console.error("[teilen] Beitrag:", f?.message);
       beitrag = null;
     }
-    return res.json({ weg: basis, text: beitrag, schon: !!e.teilen_token });
+    /* `discord` sagt NUR, ob ein Kanal eingerichtet ist -- nie, welcher.
+       Ohne diese Auskunft stünde im Browser ein Knopf, der jedes Mal
+       absagt, und niemand wüsste warum. */
+    return res.json({
+      weg: basis, text: beitrag, schon: !!e.teilen_token,
+      discord: webhookBereit(),
+    });
   } catch (fehler) {
     console.error("[teilen] anlegen:", fehler?.message);
     return res.status(503).json({ fehler: "Das Teilen hat gerade nicht geklappt." });
@@ -208,6 +226,292 @@ teilenRouter.delete("/workspace/api/eintrag/:id(\\d+)/teilen", (req, res) => {
   }
 });
 
+/* =====================================================================
+   DER BEITRAG STELLT SICH SELBST IN DEN KANAL (08.10.2026)
+   =====================================================================
+   Filipe: „ich will dass wenn ich es teile im discord der agentur, dass
+   ein banner und ein kompletter fertiger text für die creator entsteht
+   und nicht einfach der link kopiert wird."
+
+   WO DAS GEHEIMNIS LIEGT -- und warum nicht woanders:
+
+     * NICHT im Quelltext und nicht in Gitea. Eine Webhook-Adresse IST
+       der Schlüssel: Wer sie hat, schreibt in den Kanal, ohne
+       angemeldet zu sein.
+     * NICHT in der Datenbank. Sie wird gesichert und liegt in Kopien.
+     * NICHT in der Dienstdatei. Die liegt in /etc, dort darf ich nichts
+       ändern (gemessen: `sudo -l` erlaubt systemctl, nicht das
+       Bearbeiten von Dateien) -- und jede Änderung bräuchte einen
+       Neustart.
+     * SONDERN in einer Datei neben der Datenbank, die nur `dogiweb`
+       lesen darf. Sie wird bei JEDEM Aufruf gelesen, nicht beim Start:
+       Dann wirkt eine neue Adresse sofort, und ein Austausch braucht
+       keinen Neustart.
+
+   SIE WIRD NIE AUSGEGEBEN. Nicht im Protokoll, nicht in einer Antwort
+   an den Browser, nicht in einer Fehlermeldung. Nach draußen geht
+   ausschließlich die Antwort auf die Frage „ist eingerichtet: ja/nein".
+   ===================================================================== */
+
+const WEBHOOK_DATEI = join(DATEN_ORDNER, "discord-webhook.txt");
+const WEBHOOK_FRIST_MS = 10_000;
+/* Zwölf je Stunde und Person. Mehr ist kein Teilen mehr, sondern eine
+   Schleife -- und am anderen Ende hängt ein fremder Dienst, der uns
+   dafür sperren kann. */
+const DISCORD_JE_STUNDE = 12;
+
+/* Nur echte Discord-Adressen. Ohne diese Liste wäre das Feld ein Weg,
+   unseren Server zu beliebigen Zielen sprechen zu lassen -- dieselbe
+   Falle wie bei der Banneradresse am 07.10.2026, nur umgekehrt. */
+const WEBHOOK_HOSTS = new Set([
+  "discord.com", "discordapp.com", "ptb.discord.com", "canary.discord.com",
+]);
+
+/** Die Webhook-Adresse — oder `null`, wenn keine brauchbare dasteht.
+ *
+ *  Die Datei darf Kommentarzeilen mit `#` enthalten; genommen wird die
+ *  erste Zeile, die keine ist. So kann daneben stehen, wofür sie gilt,
+ *  ohne dass eine zweite Datei nötig wird.
+ */
+/** Taugt diese Zeile als Webhook-Adresse? Gibt die saubere Adresse
+ *  zurück — oder `null`.
+ *
+ *  EINE STELLE FÜR BEIDE WEGE. Sie wird beim Lesen der Datei
+ *  gebraucht UND beim Eintragen über die Oberfläche. Zwei Fassungen
+ *  derselben Sicherheitsregel laufen auseinander, und beim zweiten
+ *  Mal merkt es niemand — genau das war heute an den Meldungen zu
+ *  sehen, wo eine zweite Satztabelle neun Sätze allein führte.
+ */
+function adresseTaugt(zeile) {
+  if (!zeile) return null;
+  let u;
+  try { u = new URL(String(zeile).trim()); } catch { return null; }
+  /* NUR IN EINER PRÜFUNG: Dann liegt der nachgebaute Kanal auf
+     127.0.0.1. Derselbe Schalter wie bei `istTikTok` — und er ist zu,
+     solange die Umgebungsvariable nicht gesetzt ist, also im Betrieb
+     immer. Ohne ihn wäre dieser Weg nur am echten Discord prüfbar,
+     und das heißt: in Filipes Kanal. */
+  const basisTest = process.env.DISCORD_WEBHOOK_BASIS;
+  const nachgebaut = !!basisTest && zeile.startsWith(basisTest)
+    && (u.hostname === "127.0.0.1" || u.hostname === "localhost");
+  if (!nachgebaut) {
+    if (u.protocol !== "https:") return null;
+    if (!WEBHOOK_HOSTS.has(u.hostname)) return null;
+  }
+  if (!u.pathname.startsWith("/api/webhooks/")) return null;
+  return u.toString();
+}
+
+/** Die eingetragene Adresse — oder `null`.
+ *
+ *  Kommentarzeilen mit `#` sind erlaubt; genommen wird die erste
+ *  Zeile, die keine ist. So kann daneben stehen, wofür sie gilt.
+ */
+function webhookAdresse() {
+  let inhalt;
+  try { inhalt = readFileSync(WEBHOOK_DATEI, "utf8"); } catch { return null; }
+  const zeile = String(inhalt).split("\n")
+    .map((z) => z.trim()).find((z) => z && !z.startsWith("#"));
+  return adresseTaugt(zeile);
+}
+
+/** Ist ein Kanal eingerichtet? Das darf die Oberfläche wissen — die
+ *  Adresse nicht. Ohne diese Auskunft stünde ein Knopf da, der
+ *  jedes Mal absagt, und niemand wüsste, warum. */
+export function webhookBereit() { return !!webhookAdresse(); }
+
+/** Wie viele Beiträge hat diese Person in der letzten Stunde gestellt?
+ *
+ *  GEZÄHLT WIRD IM PROTOKOLL, nicht an Erfolgen — sonst bremst die
+ *  Bremse genau den nicht, dessen Versuche scheitern und der deshalb
+ *  in einer Schleife hängt (gelernt am 07.10.2026 an der
+ *  Kampagnen-Bremse, die 21 Versuche durchließ).
+ *
+ *  `senden_gebremst` steht bewusst NICHT in der Liste: Sonst zählte
+ *  die Bremse ihre eigenen Absagen mit und würde immer strenger. */
+function beitraegeLetzteStunde(personId) {
+  const seit = new Date(Date.now() - 3600_000).toISOString();
+  const z = db().prepare(
+    `SELECT COUNT(*) AS anzahl, MIN(zeitpunkt) AS aeltester
+       FROM protokoll
+      WHERE person_id = ? AND zeitpunkt >= ?
+        AND aktion IN ('event_gesendet','event_nicht_gesendet')`)
+    .get(personId, seit);
+  return { anzahl: z?.anzahl || 0, aeltester: z?.aeltester || null };
+}
+
+/** Den Beitrag in den Kanal stellen. Gibt `{ ok: true }` oder
+ *  `{ fehler }` mit einer Kennung, zu der es in `meldung.js` einen
+ *  Satz gibt — `pruef-meldungen` erzwingt das.
+ */
+async function inDenKanal(adresse, text) {
+  let antwort;
+  try {
+    antwort = await fetch(adresse, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      /* `allowed_mentions: { parse: [] }` IST KEIN SCHMUCK.
+         Im Beitrag steht der Text der KAMPAGNE, und den schreibt
+         TikTok, nicht wir. Stünde darin „@everyone", würde unser
+         Beitrag den ganzen Server anpingen — ausgelöst von einem
+         fremden Text. Mit dieser Zeile bleibt eine Erwähnung sichtbar
+         und wirkungslos. */
+      body: JSON.stringify({
+        content: text,
+        allowed_mentions: { parse: [] },
+      }),
+      /* KEIN `flags: 4`. Das wäre „Vorschauen unterdrücken" — und
+         genau die Vorschau ist das Banner, das Filipe will. Der Link
+         steht deshalb nackt am Ende des Textes; Discord holt sich
+         Bild, Titel und Beschreibung aus den og-Marken der offenen
+         Seite (sie stehen weiter unten in dieser Datei). */
+      signal: AbortSignal.timeout(WEBHOOK_FRIST_MS),
+    });
+  } catch (f) {
+    /* ABSICHTLICH OHNE DIE ADRESSE im Protokolltext. Eine
+       Fehlermeldung von `fetch` enthält sie sonst mitsamt dem
+       Schlüssel — und Protokolle liest man später in Ruhe. */
+    console.error("[teilen] Discord nicht erreichbar:", f?.name || "Fehler");
+    return { fehler: "discord_nicht_erreichbar" };
+  }
+  if (antwort.ok) return { ok: true };
+  /* 4xx heißt: an uns liegt es — falscher oder gelöschter Haken.
+     5xx und 429 heißen: dort liegt es, später nochmal. */
+  if (antwort.status >= 400 && antwort.status < 500 && antwort.status !== 429) {
+    console.error("[teilen] Discord lehnt ab:", antwort.status);
+    return { fehler: "discord_abgelehnt" };
+  }
+  console.error("[teilen] Discord antwortet:", antwort.status);
+  return { fehler: "discord_nicht_erreichbar" };
+}
+
+/* ---------- Den Kanal eintragen, ohne Kommandozeile ------------------
+
+   Das Geheimnis geht von Filipes Zwischenablage über TLS direkt an
+   den Dienst, der es in eine Datei schreibt, die nur `dogiweb` lesen
+   darf. Es passiert NICHT den Chat, keine Befehlszeile und keine
+   `~/.bash_history` — am 03.09.2026 hat genau dieser Weg einen Token
+   in ein Bildschirmfoto und einen Chatverlauf getragen, und er
+   musste zurückgezogen werden.
+
+   HERAUS GEHT SIE NIE WIEDER. `GET` beantwortet nur „ist eingerichtet"
+   und „seit wann". Wer sie ändern will, trägt eine neue ein; wer sie
+   nachlesen will, kann das nicht — auch DogFather nicht. Das ist
+   Absicht: Ein Feld, das ein Geheimnis zurückgibt, ist eine Kopie
+   mehr, und jede Kopie ist eine Stelle, an der sie wegkommen kann.
+   ------------------------------------------------------------------- */
+
+/** Darf diese Person den Kanal der Agentur sehen und setzen? */
+function nurLeitungAgentur(req, res) {
+  /* ZWEI GETRENNTE HÄUSER (24.09.2026). Auf der Adresse von Team Dogi
+     gibt es den Agentur-Kanal nicht — auch nicht für DogFather, der in
+     beiden Häusern arbeitet. 404 und nicht 403: Was es hier nicht
+     gibt, soll man auch nicht erahnen können. */
+  if (req.person?.haus === "crew") {
+    res.status(404).json({ fehler: "nicht_hier" });
+    return false;
+  }
+  if (!istLeitung(req.person)) {
+    res.status(403).json({ fehler: "nicht_erlaubt" });
+    return false;
+  }
+  return true;
+}
+
+teilenRouter.get("/workspace/api/teilen/kanal", (req, res) => {
+  if (!nurLeitungAgentur(req, res)) return undefined;
+  const bereit = !!webhookAdresse();
+  let seit = null;
+  try { seit = statSync(WEBHOOK_DATEI).mtime.toISOString(); } catch { seit = null; }
+  /* `steht` sagt, ob überhaupt eine Datei da ist. Sie kann da sein und
+     trotzdem untauglich — dann hat jemand etwas eingetragen, was keine
+     Discord-Adresse ist, und genau das soll man sehen statt zu rätseln,
+     warum der Knopf fehlt. */
+  return res.json({ bereit, seit, steht: existsSync(WEBHOOK_DATEI) });
+});
+
+teilenRouter.put("/workspace/api/teilen/kanal", (req, res) => {
+  if (!nurLeitungAgentur(req, res)) return undefined;
+  const adresse = adresseTaugt(req.body?.adresse);
+  if (!adresse) return res.status(400).json({ fehler: "adresse_untauglich" });
+  try {
+    const kopf = [
+      "# Discord-Kanal der Agentur.",
+      `# Eingetragen am ${heuteLokal()} über den Workspace.`,
+      "# Wer diese Adresse hat, schreibt in den Kanal. Sie gehört nirgends",
+      "# sonst hin -- nicht in eine Notiz, nicht in einen Chat, nicht in Gitea.",
+      adresse,
+      "",
+    ].join("\n");
+    /* `mode` BEIM SCHREIBEN GILT NUR FÜR EINE NEUE DATEI. Liegt schon
+       eine da, behält sie ihre Rechte — deshalb danach noch einmal
+       ausdrücklich. Ohne das wäre eine einmal falsch angelegte Datei
+       für immer lesbar, und niemand würde es sehen. */
+    writeFileSync(WEBHOOK_DATEI, kopf, { encoding: "utf8", mode: 0o600 });
+    try { chmodSync(WEBHOOK_DATEI, 0o600); } catch { /* Windows kennt das nicht */ }
+    /* IM PROTOKOLL STEHT KEINE ADRESSE. Ein Protokoll liest man später
+       in Ruhe, und es wird gesichert. */
+    protokolliere("kanal_eingetragen", {
+      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
+      detail: "Discord-Kanal der Agentur",
+    });
+    return res.json({ bereit: true });
+  } catch (f) {
+    console.error("[teilen] Kanal eintragen:", f?.code || f?.message);
+    return res.status(503).json({ fehler: "nicht_gespeichert" });
+  }
+});
+
+teilenRouter.delete("/workspace/api/teilen/kanal", (req, res) => {
+  if (!nurLeitungAgentur(req, res)) return undefined;
+  try { rmSync(WEBHOOK_DATEI); } catch { /* war nicht da -- dann ist er weg */ }
+  protokolliere("kanal_entfernt", {
+    personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
+    detail: "Discord-Kanal der Agentur",
+  });
+  return res.json({ bereit: !!webhookAdresse() });
+});
+
+teilenRouter.post("/workspace/api/eintrag/:id(\\d+)/discord", async (req, res) => {
+  const e = eventFuer(req, res);
+  if (!e) return undefined;
+  /* OHNE SCHLÜSSEL KEIN BEITRAG. Der Link ist der Kern der Nachricht;
+     ihn ohne Ziel zu verschicken wäre eine Einladung ins Leere. */
+  if (!e.teilen_token) return res.status(409).json({ fehler: "nicht_geteilt" });
+
+  const adresse = webhookAdresse();
+  if (!adresse) return res.status(409).json({ fehler: "discord_nicht_eingerichtet" });
+
+  const bremse = beitraegeLetzteStunde(req.person.id);
+  if (bremse.anzahl >= DISCORD_JE_STUNDE) {
+    protokolliere("senden_gebremst", {
+      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
+      detail: `${bremse.anzahl} Beiträge seit ${bremse.aeltester}`,
+    });
+    return res.status(429).json({ fehler: "senden_gebremst" });
+  }
+
+  let text = null;
+  try {
+    const voll = eventMitNummer(e.id);
+    const basis = `${TEILEN_BASIS}/e/${e.teilen_token}`;
+    if (voll) text = discordText(teilenDaten(voll, basis));
+  } catch (f) {
+    console.error("[teilen] Beitrag fuer Discord:", f?.message);
+    text = null;
+  }
+  if (!text) return res.status(503).json({ fehler: "kein_beitrag" });
+
+  const r = await inDenKanal(adresse, text);
+  protokolliere(r.ok ? "event_gesendet" : "event_nicht_gesendet", {
+    personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
+    detail: `Eintrag ${e.id} "${String(e.titel).slice(0, 60)}"`
+      + (r.ok ? ` (${text.length} Zeichen)` : ` -- ${r.fehler}`),
+  });
+  if (!r.ok) return res.status(502).json({ fehler: r.fehler });
+  return res.json({ ok: true, zeichen: text.length });
+});
+
 /* ---------- Das Plakat, offen für alle -------------------------------- */
 
 /** Was in HTML nicht roh stehen darf. Vier Zeichen, keine Bibliothek: