dogfather-universe/server/workspace-video.js

/* =====================================================================
   EIN VIDEO IN DIE APP HOLEN (17.09.2026) — Stufe A des Video-Plans

   Filipe: „ich will dass sobald ich ein video poste es sofort in der
   app erscheint für die ganze community … und dass jeder sofort von da
   auch aufs video kommen kann um dann zu liken … am besten so, dass man
   das Coverbild und den Text sieht."

   Der Weg hier ist der, der HEUTE funktioniert, ohne Freigabe und ohne
   Geheimnis: Jemand fügt die Adresse ein, alles andere geht von allein.

     Link  →  oEmbed (Titel, Cover-Adresse, Account)
           →  Cover HERUNTERLADEN und bei uns ablegen
           →  Eintrag bei „Highlights" mit Bild, Text und Knopf

   ---------------------------------------------------------------------
   WARUM DAS COVER KOPIERT WIRD — der wichtigste Satz dieser Datei

   TikToks Bildadresse ist signiert und läuft ab. Gemessen am
   17.09.2026 an einem echten Video:

       x-expires = 1789812000  →  in 48 Stunden

   Wer sie nur speichert, hat übermorgen schwarze Kacheln. Das merkt
   man beim Bauen nicht und beim Testen nicht — es fällt erst am
   übernächsten Tag auf, und dann sieht die ganze App kaputt aus.

   Deshalb wandert das Bild in dieselbe Ablage wie jeder Anhang, und
   es geht durch dieselbe Byte-Prüfung: Ein heruntergeladenes Cover ist
   eine FREMDE Datei, und für fremde Dateien wurde die Prüfung gebaut.

   ---------------------------------------------------------------------
   UND NUR SEINE EIGENEN KANÄLE

   Der Account aus der oEmbed-Antwort wird gegen `KANAELE` geprüft
   (`kanalVonHandle`). Ein fremdes Video hat in Filipes Highlights
   nichts zu suchen — und das ist kein Sonderfall, sondern der
   wichtigste Ausgang dieser Datei.

   Aufrufen: POST /workspace/api/bereich/:bereich/video  { url }
   ===================================================================== */

import express from "express";
import { randomBytes } from "node:crypto";
import { join } from "node:path";
import { mkdirSync, writeFileSync, unlinkSync } from "node:fs";
import {
  db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER,
  KANAELE, kanalVonHandle, TREFF_BRETTER, brettAufDieserAdresse,
  heuteLokal,
  hausFuerNeuenEintrag,
} from "./workspace.js";
import { darfSchreiben, sofortFreigeben } from "./workspace-treff.js";
import { sichtbar } from "./workspace-bereiche.js";
import { bildArtVon } from "./workspace-dateien.js";

export const videoRouter = express.Router();

const ORDNER = join(DATEN_ORDNER, "dateien");
try { mkdirSync(ORDNER, { recursive: true }); } catch { /* gibt es schon */ }

/* GRENZEN FÜR DEN WEG NACH DRAUSSEN. Ein fremder Dienst, der nicht
   antwortet, darf unsere Anfrage nicht mit sich ziehen -- genau daran
   ist in diesem Haus schon ein ganzer Pruefdurchlauf drei Stunden lang
   haengengeblieben. */
const FRIST_MS = 8000;
const COVER_MAX = 4 * 1024 * 1024;

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  req.person = person;
  next();
}
videoRouter.use("/workspace/api/bereich", angemeldet);

/** Ist das ueberhaupt eine TikTok-Adresse? Keine Zeichenkettensuche,
 *  sondern der Rechnername -- "tiktok.com.beispiel.de" enthaelt
 *  "tiktok.com" und gehoert jemand anderem. */
export function istTikTok(roh) {
  try {
    const u = new URL(String(roh));
    const h = u.hostname.toLowerCase();
    /* NUR IN EINER PRUEFUNG: Dann liegt der nachgebaute Dienst auf
       127.0.0.1, und die Adresse des "Videos" auch. Ohne diese Zeile
       muesste die Pruefung die echte Regel umgehen -- und pruefte
       damit eine andere als die, die im Betrieb gilt. */
    if (process.env.TIKTOK_OEMBED_BASIS && (h === "127.0.0.1" || h === "localhost")) {
      return true;
    }
    if (u.protocol !== "https:") return false;
    return h === "tiktok.com" || h.endsWith(".tiktok.com");
  } catch { return false; }
}

/** Mit Frist holen. Ohne sie haengt die Anfrage am fremden Dienst. */
/** Holt etwas von draussen -- MIT Frist ueber den ganzen Vorgang.
 *
 *  DIE ALTE FASSUNG HAT NUR DEN ANFANG BEWACHT (behoben 05.10.2026).
 *
 *  Sie gab die Antwort zurueck, sobald die Kopfzeilen da waren, und
 *  raeumte im `finally` die Uhr weg. Was danach kam -- `a.json()` beim
 *  Abruf der Videodaten, `a.arrayBuffer()` beim Vorschaubild -- lief
 *  OHNE jede Frist. Bleibt der fremde Server mitten im Koerper
 *  stehen, wartet unsere Anfrage fuer immer.
 *
 *  Genau das sieht man als "der Knopf bleibt auf `wird geholt ...`
 *  stehen": keine Fehlermeldung, kein Eintrag, kein Protokolleintrag
 *  -- weil der Vorgang nie endet. Und es braucht keine Aenderung bei
 *  uns, um anzufangen: Es haengt am fremden Netz. "Es ging doch immer
 *  bis jetzt" ist bei so einem Fehler die Regel, nicht die Ausnahme.
 *
 *  Der Koerper wird deshalb GELESEN, solange die Uhr laeuft, und erst
 *  danach abgeraeumt. 8 Sekunden gelten damit fuer alles zusammen. */
async function holeMitFrist(adresse, kopf = {}) {
  const abbruch = new AbortController();
  const uhr = setTimeout(() => abbruch.abort(), FRIST_MS);
  try {
    const a = await fetch(adresse, { signal: abbruch.signal, headers: kopf, redirect: "follow" });
    /* Bei einem Fehlschlag interessiert der Koerper nicht -- aber er
       muss trotzdem weg, sonst bleibt die Verbindung offen. */
    const roh = Buffer.from(await a.arrayBuffer());
    return {
      ok: a.ok, status: a.status, headers: a.headers, roh,
      text: () => roh.toString("utf8"),
    };
  } finally { clearTimeout(uhr); }
}

/* WOHIN GEFRAGT WIRD. Im Betrieb TikTok; in einer Pruefung ein
   nachgebauter Dienst auf 127.0.0.1.

   WARUM UMSTELLBAR: Eine Pruefung, die das echte TikTok braucht, ist
   langsam, haengt am Netz und misst fremde Verfuegbarkeit statt
   unseren Code. Sie waere die Sorte Pruefung, die irgendwann rot wird,
   ohne dass etwas kaputt ist -- und dann schaltet man sie ab.

   Die Umgebungsvariable wird NUR von Pruefungen gesetzt. Steht sie
   nicht da, gilt TikTok -- kein Verhalten, das sich still aendert. */
const OEMBED_BASIS = process.env.TIKTOK_OEMBED_BASIS || "https://www.tiktok.com/oembed";

/** Die Auskunft zu einem Video: Titel, Cover-Adresse, Account. */
export async function videoAuskunft(url) {
  const a = await holeMitFrist(
    `${OEMBED_BASIS}?url=${encodeURIComponent(url)}`,
    { accept: "application/json" });
  if (!a.ok) return { fehler: `TikTok antwortet nicht (${a.status}).` };
  let j = null;
  try { j = JSON.parse(a.text()); } catch { j = null; }
  if (!j || !j.title) return { fehler: "TikTok hat nichts zu diesem Video geschickt." };
  /* Der Account steht in `author_url` (…/@name). `author_name` ist der
     ANZEIGENAME und aendert sich, wenn jemand ihn umstellt -- als
     Schluessel waere er die falsche Wahl. */
  const handle = String(j.author_url || "").split("/@")[1] || "";
  return {
    titel: String(j.title).slice(0, 160),
    cover: j.thumbnail_url || null,
    handle: handle ? `@${handle}` : "",
    kanal: kanalVonHandle(handle),
  };
}

/** Das Cover holen und ablegen. Gibt den Dateinamen zurueck -- oder
 *  `null`, wenn es kein Bild ist. */
async function coverAblegen(adresse) {
  if (!adresse) return null;
  let a;
  try { a = await holeMitFrist(adresse); } catch { return null; }
  if (!a.ok) return null;
  const roh = a.roh;
  if (!roh.length || roh.length > COVER_MAX) return null;
  /* DIESELBE BYTEPRUEFUNG WIE BEI HOCHGELADENEN DATEIEN. Was von
     draussen kommt, ist von draussen -- egal ob jemand es hochlaedt
     oder wir es holen. `dateien.typ` waere hier sogar noch
     wertloser: Den Typ behauptet dann ein fremder Server. */
  const art = bildArtVon(roh.subarray(0, 16));
  if (!art) return null;
  const endung = { "image/png": ".png", "image/jpeg": ".jpg",
    "image/gif": ".gif", "image/webp": ".webp" }[art] || ".bin";
  const name = `${Date.now().toString(36)}-${randomBytes(8).toString("hex")}${endung}`;
  writeFileSync(join(ORDNER, name), roh, { flag: "wx" });
  return { name, groesse: roh.length, art };
}

videoRouter.post("/workspace/api/bereich/:bereich/video", async (req, res) => {
  let abgelegt = null;
  try {
    const bereich = String(req.params.bereich);
    /* DIESE ROUTE HAT IHR EIGENES TOR. Sie haengt nicht an der
       Middleware von workspace-bereiche.js -- deshalb steht der
       Adressriegel hier eigens. Ohne ihn liesse sich von der
       Agenturadresse aus weiterhin ein Video anlegen, das danach
       niemand dort sieht: genau der Zustand, der heute gemeldet
       wurde, nur still. */
    if (!TREFF_BRETTER.includes(bereich)
        || !brettAufDieserAdresse(req.person, bereich)) {
      return res.status(404).json({ fehler: "nicht_gefunden" });
    }
    const warum = darfSchreiben(req.person, bereich);
    if (warum) return res.status(403).json({ fehler: warum });

    const url = String(req.body?.url ?? "").trim();
    if (!istTikTok(url)) {
      protokolliere("video_gescheitert", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `${bereich} ${String(url).slice(0, 120)} -- keine TikTok-Adresse`,
      });
      return res.status(400).json({ fehler: "Das ist keine TikTok-Adresse." });
    }

    /* ---- DER KREISLAUF (Stufe 7, 18.09.2026) --------------------------

       „Ein Video aus einem Wunsch zeigt den Namen." Wer sich etwas
       gewuenscht hat, soll sehen, dass daraus etwas geworden ist --
       das ist der ganze Sinn eines Wunschbretts. Ohne diese Verbindung
       ist die Galerie eine Sammlung, und der Wunsch von letzter Woche
       bleibt unbeantwortet im Raum stehen.

       DIE QUELLE MUSS EIN COMMUNITY-BRETT SEIN. Eine Kette, die in die
       Content-Planung eines Creators fuehrt, waere ein Leck: Dort steht
       Arbeit, die die Community nichts angeht -- und der TITEL der
       Quelle wird auf der Kachel angezeigt. Dieselbe Regel wie beim
       „Daraus"-Knopf, aus demselben Grund. */
    const aus = Number(req.body?.aus || 0);
    let ausQuelle = null;
    if (req.body?.aus !== undefined && req.body?.aus !== null && req.body?.aus !== "") {
      if (!Number.isInteger(aus) || aus <= 0) {
        return res.status(400).json({ fehler: "Die Quelle ist keine Nummer." });
      }
      if (!sichtbar(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
      ausQuelle = db().prepare(
        "SELECT id, bereich, titel FROM eintraege WHERE id = ?").get(aus);
      /* Nicht da, oder kein Community-Brett: dieselbe Antwort. Sonst
         liesse sich durch Ausprobieren herausfinden, welche Nummern es
         gibt und in welchem Bereich sie liegen. */
      if (!ausQuelle || !TREFF_BRETTER.includes(ausQuelle.bereich)) {
        return res.status(404).json({ fehler: "nicht_gefunden" });
      }
    }

    /* SCHON DA? Derselbe Link zweimal soll dasselbe Ergebnis geben,
       nicht zwei Eintraege. Wer den Knopf zweimal drueckt, meint nicht
       zwei Videos. */
    const schon = db().prepare(
      "SELECT id FROM eintraege WHERE quelle_url = ? AND bereich = ?").get(url, bereich);
    if (schon) return res.status(200).json({ id: schon.id, schon: true });

    /* IST AUS DIESEM WUNSCH SCHON ETWAS GEWORDEN?

       Den Weg „Daraus ein Highlight machen" gibt es laenger als diesen
       hier. Wer ihn gegangen ist und DANACH das Video einfuegt, bekaeme
       sonst ein ZWEITES Highlight aus demselben Wunsch -- zwei Wege zum
       selben Ziel, die nichts voneinander wissen. Das Video wird
       deshalb an den vorhandenen Eintrag gehaengt. */
    let anhaengenAn = 0;
    if (ausQuelle) {
      const da = db().prepare(
        "SELECT id, quelle_url FROM eintraege WHERE aus_eintrag_id = ? AND bereich = ?")
        .get(aus, bereich);
      if (da?.quelle_url) return res.status(200).json({ id: da.id, schon: true });
      if (da) anhaengenAn = da.id;
    }

    const auskunft = await videoAuskunft(url);
    if (auskunft.fehler) {
      /* NICHT STILL SCHEITERN. Bis heute stand im Protokoll nur der
         Erfolg (`video_eingelesen`). Blieb TikTok eine Antwort
         schuldig, gab es hinterher nichts zum Nachsehen -- und auf
         die Frage "warum kam mein Video nicht an?" liess sich nicht
         einmal sagen, OB der Versuch den Server erreicht hat. Genau
         diese Reihenfolge hat am 06.09. im Shop zwei Stunden
         gekostet, und heute noch einmal einen halben Tag. */
      protokolliere("video_gescheitert", {
        personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
        detail: `${bereich} ${url} -- ${auskunft.fehler}`.slice(0, 180),
      });
      return res.status(502).json({ fehler: auskunft.fehler });
    }

    /* NUR SEINE EIGENEN KANAELE. Ein fremdes Video in Filipes
       Highlights waere nicht bloss falsch einsortiert -- es waere ein
       fremder Inhalt unter seinem Namen. */
    if (!auskunft.kanal) {
      return res.status(403).json({
        fehler: `„${auskunft.handle || "Dieser Account"}“ ist keiner deiner Kanäle. `
          + `Möglich sind: ${KANAELE.map((k) => k.handle).join(", ")}.`,
      });
    }

    /* WOHIN ES GELEGT WIRD, DARF MAN WAEHLEN (22.09.2026).
       ===================================================================
       Filipe: „ich will das wenn man da video holt das man auch
       aussuchen kann in welcher account es unten angezeigt werden soll."

       Bis heute entschied das allein der Link: `kanalVonHandle` liest
       den Account aus der TikTok-Adresse, und dort landete das Video.
       Das ist richtig geraten, aber es IST geraten -- ein Ausschnitt
       vom Hauptkanal gehoert oft unter „Clips", und ein Video, das
       jemand anders hochgeladen hat, steht dann in der falschen Spalte.

       Die Schranke darueber bleibt unangetastet: Der ABSENDER muss
       weiterhin einer der drei eigenen Kanaele sein. Gewaehlt wird nur
       die SPALTE, nicht, ob fremde Inhalte hereinduerfen -- sonst waere
       aus einer Ablagehilfe ein Loch geworden.

       Ohne Angabe bleibt alles wie bisher. Das ist der haeufigste Fall
       und soll keinen zusaetzlichen Handgriff kosten. */
    const gewaehlt = String(req.body?.kanal ?? "").trim();
    if (gewaehlt && !KANAELE.some((k) => k.wert === gewaehlt)) {
      return res.status(400).json({ fehler: "kanal_unbekannt" });
    }
    const ablage = gewaehlt || auskunft.kanal;

    abgelegt = await coverAblegen(auskunft.cover);

    const jetzt = new Date().toISOString();
    const arten = { highlight: "clip", anschlag: "hinweis", treff: "lob" };
    let eintragId;
    if (anhaengenAn) {
      /* DER TITEL WIRD NICHT UEBERSCHRIEBEN. Er stammt vom Wunsch und
         damit von einem Menschen; der von TikTok ist eine Bildunter-
         schrift mit Schlagwoertern. Wer den ersetzte, naehme dem
         Eintrag genau das, was ihn mit dem Wunsch verbindet. */
      db().prepare(`UPDATE eintraege SET quelle_url = ?, quelle_kanal = ?,
                      quelle_geholt_am = ?, geaendert = ?
                    WHERE id = ?`)
        .run(url, ablage, jetzt, jetzt, anhaengenAn);
      eintragId = anhaengenAn;
    } else {
      const { lastInsertRowid } = db().prepare(`
        INSERT INTO eintraege
          (bereich, art, titel, datum, status, erstellt, erstellt_von,
           quelle_url, quelle_kanal, quelle_geholt_am, aus_eintrag_id, haus)
        VALUES (?,?,?,?, 'offen', ?,?,?,?,?,?,?)`)
        /* Der TAG in Ortszeit (01.10.2026), der Zeitstempel daneben in
           UTC -- ein Zeitpunkt ist ueberall derselbe, ein Kalendertag
           nicht. */
        .run(bereich, arten[bereich] || "clip", auskunft.titel, heuteLokal(),
          jetzt, req.person.id, url, ablage, jetzt, ausQuelle ? aus : null,
          hausFuerNeuenEintrag(req.person, bereich));
      eintragId = Number(lastInsertRowid);
    }

    if (abgelegt) {
      db().prepare(`
        INSERT INTO dateien (name_original, name_datei, groesse, typ, status, notiz,
                             hochgeladen_von, erstellt, eintrag_id, haus)
        VALUES (?,?,?,?, 'entwurf', NULL, ?,?,?,?)`)
        .run(`cover-${auskunft.kanal}${abgelegt.name.slice(abgelegt.name.lastIndexOf("."))}`,
          abgelegt.name, abgelegt.groesse, abgelegt.art, req.person.id, jetzt, eintragId,
          req.person.haus || null);
      abgelegt = null;            /* ab hier gehoert die Datei dem Eintrag */
    }

    /* SOFORT ZU SEHEN, WENN DAS TEAM ES EINSETZT (30.09.2026).

       Filipe: „wenn wir bei highlights videos rein setzen will ich
       nicht mehr dass wir sie freigeben müssen, sobald die
       reingesetzt wurden sollen die sofort zu sehen sein."

       Die Freigabe auf dem Highlight-Brett ist ein Filter gegen
       fremde Inhalte. Wer ihn bedienen darf und den Eintrag selbst
       anlegt, hat ihn damit schon passiert. Ein Community-Mitglied
       ab „Stamm" darf denselben Weg gehen — sein Eintrag wartet
       weiter auf jemanden aus dem Team. */
    sofortFreigeben(bereich, req.person, eintragId);

    protokolliere("video_eingelesen", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `${auskunft.kanal} ${url}${ausQuelle ? ` (aus #${aus})` : ""}`.slice(0, 120),
    });
    res.status(201).json({
      /* GEMELDET WIRD DIE ABLAGE, NICHT DAS ERKANNTE (22.09.2026).
         Hier stand `auskunft.kanal` -- also das, was aus dem Link
         gelesen wurde. Seit die Spalte waehlbar ist, sind das zwei
         verschiedene Dinge, und die Antwort muss sagen, wo der Eintrag
         wirklich gelandet ist. Sonst meldet die Seite "DogFather",
         waehrend das Video unter "Clips" steht. */
      id: eintragId, schon: false, kanal: ablage,
      titel: auskunft.titel, cover: !!abgelegt || undefined,
      ...(ausQuelle ? { aus: aus, angehaengt: !!anhaengenAn } : {}),
    });
  } catch (fehler) {
    /* GING ETWAS SCHIEF, NACHDEM DIE DATEI SCHON LAG: wegraeumen. Eine
       Datei ohne Eintrag findet niemand wieder und niemand loescht sie
       -- sie liegt einfach fuer immer da. */
    if (abgelegt) { try { unlinkSync(join(ORDNER, abgelegt.name)); } catch { /* egal */ } }
    /* Auch der Absturz gehoert ins Protokoll -- er ist der Fall, bei
       dem sonst GAR nichts dasteht. */
    try {
      protokolliere("video_gescheitert", {
        personId: req.person?.id, rolle: req.person?.rolle, ip: echteIp(req),
        detail: `Abbruch: ${String(fehler?.message || fehler)}`.slice(0, 180),
      });
    } catch { /* das Protokoll darf die Antwort nicht aufhalten */ }
    console.error("[workspace] Video einlesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});


/* =====================================================================
   STUFE 5: FUEHRT DER KNOPF NOCH IRGENDWOHIN? (18.09.2026)

   Ein Video kann bei TikTok geloescht oder auf privat gestellt werden.
   Bei uns bleibt der Eintrag stehen -- Cover, Text, und ein Knopf „Auf
   TikTok ansehen", der auf eine Fehlerseite fuehrt. Das faellt beim
   Bauen nicht auf und beim Testen nicht; es faellt dem auf, der
   klickt, und das ist die Community.

   ---------------------------------------------------------------------
   DREI ANTWORTEN, NICHT ZWEI

   Die naheliegende Fassung fragt TikTok und setzt bei einem Fehlschlag
   „weg". Die waere an einem einzigen schlechten Nachmittag von TikTok
   in der Lage, die halbe Galerie als geloescht zu markieren -- und
   niemand haette einen Anhaltspunkt, warum ploetzlich alles fort ist.

   Deshalb wird unterschieden:

     TikTok schickt Daten        -> DA. Zaehler zurueck auf null, eine
                                    frueher gesetzte Markierung faellt
                                    weg (ein privat gestelltes Video
                                    kann wiederkommen).
     TikTok sagt „gibt es nicht" -> ein FEHLVERSUCH. Erst der dritte an
                                    drei verschiedenen Tagen markiert.
     Niemand antwortet / 5xx     -> WEISS NICHT. Aendert gar nichts,
                                    nicht einmal den Zaehler.

   Der dritte Fall ist der wichtige: Unerreichbar ist kein Befund.
   ===================================================================== */

/** Ab wie vielen Fehlversuchen ein Video als „nicht mehr da" gilt. */
const FEHLT_AB = 3;

/** Wie viele je Lauf. Nicht alle auf einmal: Ein Schwall Anfragen an
 *  einen fremden Dienst ist das, was man von einem Programm erwartet,
 *  das man nicht mehr bedienen will. */
const WACHE_JE_LAUF = 40;

/** Abstand zwischen zwei Abfragen. */
const WACHE_PAUSE_MS = 300;

/** Wie oft ein unauffaelliges Video nachgesehen wird (Tage).
 *
 *  DREI GESCHWINDIGKEITEN, und jede hat ihren Grund:
 *
 *    unauffaellig        alle sieben Tage -- es gibt keinen Anlass.
 *    verdaechtig         taeglich. Sonst dauerte es drei Wochen, bis
 *    (1-2 Fehlversuche)  ein geloeschtes Video als geloescht dasteht.
 *    schon markiert      wieder alle sieben Tage. Die Frage ist
 *                        beantwortet; taeglich nachzufragen waere
 *                        Hammern auf einem fremden Dienst fuer eine
 *                        Auskunft, die wir schon haben. Dass eine
 *                        Rueckkehr dann bis zu eine Woche braucht, ist
 *                        der richtige Preis. */
const WACHE_ABSTAND_TAGE = 7;

/** Fragt nach, ob es das Video noch gibt.
 *
 *  @returns {Promise<{da: boolean|null, grund: string}>} `da === null`
 *    heisst ausdruecklich „konnte nicht nachsehen" -- nicht „weg".
 */
export async function videoNochDa(url) {
  let a;
  try {
    a = await holeMitFrist(`${OEMBED_BASIS}?url=${encodeURIComponent(url)}`,
      { accept: "application/json" });
  } catch (f) {
    /* Zeitueberschreitung, DNS, kein Netz -- alles Aussagen ueber die
       Leitung, keine ueber das Video. */
    return { da: null, grund: `nicht erreichbar (${f?.name || "Fehler"})` };
  }
  if (a.status >= 500) return { da: null, grund: `TikTok stoert (${a.status})` };
  /* 400 und 404 sind die Antworten, mit denen TikTok auf geloeschte und
     auf privat gestellte Videos antwortet. 403 ebenso. */
  if (a.status === 400 || a.status === 403 || a.status === 404) {
    return { da: false, grund: `TikTok kennt es nicht (${a.status})` };
  }
  if (!a.ok) return { da: null, grund: `unerwartet (${a.status})` };
  let j = null;
  try { j = JSON.parse(a.text()); } catch { j = null; }
  /* Antwort ohne Titel: TikTok liefert das auch fuer entfernte Videos
     mit Status 200. Ein leerer Titel ist deshalb eine Aussage. */
  if (!j || !j.title) return { da: false, grund: "Antwort ohne Titel" };
  return { da: true, grund: "" };
}

/** Sieht die faelligen Videos durch.
 *
 *  Getrennt vom Zeitgeber, damit die Pruefung sie aufrufen kann, ohne
 *  einen Tag zu warten -- und damit sie gemessen werden kann.
 *
 *  @returns {Promise<{geprueft: number, weg: number, zurueck: number,
 *                     unklar: number}>}
 */
export async function videoWacheLauf() {
  const d = db();
  const grenze = new Date(Date.now() - WACHE_ABSTAND_TAGE * 86400_000).toISOString();
  /* ORTSZEIT (01.10.2026) -- nicht der UTC-Tag. */
  const heute = heuteLokal();

  /* WELCHE ZUERST: die mit Fehlversuchen (die sind verdaechtig und
     sollen schnell geklaert sein), dann die am laengsten ungesehenen.
     `quelle_geprueft_am IS NULL` zuerst -- das sind die neuen. */
  let faellig = [];
  try {
    faellig = d.prepare(`
      SELECT id, quelle_url, COALESCE(quelle_fehlversuche, 0) AS fehl,
             quelle_geprueft_am, quelle_fehlt_seit
        FROM eintraege
       WHERE quelle_url IS NOT NULL AND quelle_url <> ''
         AND ( quelle_geprueft_am IS NULL
               OR ( COALESCE(quelle_fehlversuche, 0) > 0
                    AND quelle_fehlt_seit IS NULL
                    AND substr(quelle_geprueft_am, 1, 10) < ? )
               OR quelle_geprueft_am < ? )
       ORDER BY COALESCE(quelle_fehlversuche, 0) DESC,
                COALESCE(quelle_geprueft_am, '') ASC
       LIMIT ?`).all(heute, grenze, WACHE_JE_LAUF);
  } catch (f) {
    /* Die Spalten gibt es erst nach dem ersten angemeldeten Aufruf
       (sie werden nachgeruestet). Das ist kein Fehler, nur zu frueh. */
    return { geprueft: 0, weg: 0, zurueck: 0, unklar: 0, grund: String(f?.message || f) };
  }

  let weg = 0, zurueck = 0, unklar = 0, geprueft = 0;
  for (const e of faellig) {
    const { da, grund } = await videoNochDa(e.quelle_url);
    const jetzt = new Date().toISOString();

    if (da === null) {
      /* WEISS NICHT AENDERT NICHTS -- auch nicht den Zeitstempel. Wer
         ihn setzte, verschoebe die naechste Nachfrage um sieben Tage,
         obwohl nichts gemessen wurde. */
      unklar++;
      continue;
    }
    geprueft++;

    if (da) {
      /* Wieder da -- oder war nie weg. Beides raeumt auf. */
      if (e.quelle_fehlt_seit || e.fehl) zurueck++;
      d.prepare(`UPDATE eintraege SET quelle_geprueft_am = ?,
                   quelle_fehlversuche = 0, quelle_fehlt_seit = NULL
                 WHERE id = ?`).run(jetzt, e.id);
      continue;
    }

    const fehl = e.fehl + 1;
    const markieren = fehl >= FEHLT_AB && !e.quelle_fehlt_seit;
    d.prepare(`UPDATE eintraege SET quelle_geprueft_am = ?,
                 quelle_fehlversuche = ?, quelle_fehlt_seit = ?
               WHERE id = ?`)
      .run(jetzt, fehl, markieren ? jetzt : (e.quelle_fehlt_seit || null), e.id);
    if (markieren) {
      weg++;
      protokolliere("video_nicht_mehr_da", {
        detail: `#${e.id} nach ${fehl} Versuchen: ${grund}`.slice(0, 120),
      });
    }
    if (WACHE_PAUSE_MS) await new Promise((f) => setTimeout(f, WACHE_PAUSE_MS));
  }

  return { geprueft, weg, zurueck, unklar };
}

/** Einmal am Tag, erstmals fuenf Minuten nach dem Start.
 *
 *  Fuenf Minuten und nicht neunzig Sekunden wie beim Aufraeumen: Dieser
 *  Lauf geht nach DRAUSSEN. Er soll nicht mit dem Start um die ersten
 *  Anfragen der Leute konkurrieren, und er hat es nie eilig -- ein
 *  Video, das gestern geloescht wurde, darf noch fuenf Minuten laenger
 *  verlinkt sein. */
export function videoWacheStarten() {
  const erster = setTimeout(() => {
    videoWacheLauf().catch((f) => console.error("[video-wache]", f?.message));
  }, 5 * 60_000);
  const takt = setInterval(() => {
    videoWacheLauf().catch((f) => console.error("[video-wache]", f?.message));
  }, 24 * 3600_000);
  erster.unref?.();
  takt.unref?.();
}