Wächter-Protokoll hält sich selbst klein (keine unbegrenzte Log-Datei)

waechter.log wuchs unbegrenzt: alle 5 Minuten eine Zeile, ~288/Tag. Ohne
Grenze irgendwann zu groß zum Durchsehen -- dann verliert das Protokoll
seinen Zweck.

Der Wächter kürzt jetzt selbst, statt logrotate: Das bräuchte eine Datei
in /etc (kein Schreibrecht) und einen Extra-Dienst. Vor dem Anhängen wird
nur die Größe abgefragt (billig); erst über 1 MB (~45 Tage) wird die Datei
einmal gelesen und auf die jüngsten 2000 Zeilen (~1 Woche) gestutzt.

Beim Bauen einen eigenen Fehler gefangen: statSync war in waechter.mjs
nicht importiert (beim Auslagern der Sicherungsprüfung mit entfernt worden).
node --check meldet das nicht -- es hätte erst zur Laufzeit im nächsten
Cron-Lauf gekracht. Import ergänzt.

Test pruef-protokoll-kuerzen.mjs: klein bleibt unangetastet, groß wird auf
die JÜNGSTEN Zeilen gestutzt (älteste fallen weg), Grenzfall und fehlende
Datei sauber. 8/8.

Co-Authored-By: Claude Opus 5 <[email protected]>

server-internal/waechter.mjs

@@ -37,7 +37,7 @@
    ===================================================================== */
 
 import { execFileSync } from "node:child_process";
-import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "node:fs";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import tls from "node:tls";
@@ -333,9 +333,42 @@ function dateiSichern(pfad) {
   try { chmodSync(pfad, 0o600); } catch { /* Datei noch nicht da */ }
 }
 
+/* Das Protokoll hält sich selbst klein, statt unbegrenzt zu wachsen.
+
+   Der Wächter schreibt alle fünf Minuten eine Zeile -- rund 288 am Tag.
+   Ohne Grenze wüchse die Datei still vor sich hin, bis sie irgendwann zu
+   groß zum Durchsehen ist und damit ihren Zweck verliert.
+
+   Bewusst kein logrotate: Das bräuchte eine Datei in /etc (kein
+   Schreibrecht) und einen zusätzlichen Dienst. Der Wächter kürzt lieber
+   selbst -- er schreibt die Datei ohnehin.
+
+   Der Schnitt kostet fast nie etwas: Erst wird nur die Größe abgefragt
+   (billig). Nur wenn sie die Grenze übersteigt, wird die Datei einmal
+   gelesen und auf die jüngsten Zeilen gestutzt. Bei ~80 Byte pro Zeile
+   sind 1 MB rund 45 Tage; danach bleiben die letzten 2000 Zeilen (gut
+   eine Woche Verlauf) stehen. */
+const PROTOKOLL_MAX_BYTE = 1024 * 1024;
+const PROTOKOLL_BEHALTEN = 2000;
+
+function protokollKuerzenFallsNoetig() {
+  let groesse;
+  try { groesse = statSync(PROTOKOLL).size; } catch { return; } // noch keine Datei
+  if (groesse <= PROTOKOLL_MAX_BYTE) return;
+  try {
+    const zeilen = readFileSync(PROTOKOLL, "utf8").split("\n");
+    /* Die letzte, meist leere Zeile nach dem abschließenden \n fällt beim
+       Zusammensetzen ohnehin wieder an -- deshalb slice auf die Nutzzeilen. */
+    const jung = zeilen.filter((z) => z.length).slice(-PROTOKOLL_BEHALTEN);
+    writeFileSync(PROTOKOLL, jung.join("\n") + "\n", { mode: 0o600 });
+    dateiSichern(PROTOKOLL);
+  } catch { /* Misslingt das Kürzen, wird eben weiter angehängt -- kein Drama. */ }
+}
+
 function protokoll(text) {
   try {
     verzeichnisSichern(PROTOKOLL);
+    protokollKuerzenFallsNoetig();
     writeFileSync(PROTOKOLL,
       `${new Date().toISOString()}  ${text}\n`, { flag: "a", mode: 0o600 });
   } catch { /* Protokoll ist Beiwerk, nicht der Zweck */ }