/* ===================================================================== nachtlauf.mjs — einmal in der Nacht alles prüfen und es AUFSCHREIBEN Filipe am 23.09.2026 auf die Frage, ob ein nächtlicher Lauf die Prüfungen selbst anstoßen und morgens sagen soll, welche rot sind: „ja". --------------------------------------------------------------------- WARUM ES DAS BRAUCHT — drei Funde an EINEM Tag Am 23.09.2026 sind mir drei Prüfungen aufgefallen, die rot waren, ohne dass es jemandem aufgefallen wäre: pruef-modi-wortleck seit dem 22.09. — der verborgene Rollenname stand offen im Netz pruef-zuteilung stürzte ab und prüfte danach gar nichts mehr pruef-push-ziel meldete einen Befund, der in Wahrheit eine erfüllte Bestellung war Alle drei habe ich durch ZUFALL gefunden — weil sie neben dem lagen, woran ich gerade gebaut habe. Prüfungen laufen nur, wenn jemand sie startet, und man startet die, an denen man arbeitet. --------------------------------------------------------------------- WOHIN DAS ERGEBNIS GEHT — und wohin ausdrücklich NICHT In eine Notiz im Vault. NICHT in die laufende Anwendung. Das ist keine Bequemlichkeit, sondern die Lehre vom 04.09.2026: Ein Prüflauf ist kein harmloser Lesevorgang, sein Ergebnis wird VERÖFFENTLICHT. Damals hat ein Netzproblem bei npm einen nächtlichen Selbsttest rot gemacht, und ab da stand VanVan in roter Schrift auf dem Startbildschirm, die Buchführung sei womöglich verletzt. An der Buchführung war nichts. Wer einen Prüflauf anstößt, muss vorher überlegen, was der SCHLECHTESTE Ausgang auf dem Bildschirm einer Nutzerin anrichtet. Hier richtet er nichts an: Er schreibt eine Notiz, die Filipe und ich lesen. Die Community sieht davon nichts. --------------------------------------------------------------------- DREI AUSGÄNGE, NICHT ZWEI in Ordnung alles grün nicht in Ordnung mindestens eine Datei rot KONNTE NICHT NACHSEHEN der Lauf hat gar nicht stattgefunden Der dritte ist der wichtige. Wenn der Rechner nachts aus war, gibt es kein Ergebnis — und ein FEHLENDES Ergebnis sieht sonst genauso aus wie ein altes gutes. Die Notiz sagt deshalb immer, WANN zuletzt wirklich gemessen wurde, und ab zwei Tagen ohne Lauf steht das ganz oben. --------------------------------------------------------------------- DIE ZAHL WIRD MIT GESTERN VERGLICHEN Ein grüner Lauf ist kein Beweis, solange nicht auch die ANZAHL stimmt (28.08.2026, RunOne: 789 statt 804 Prüfungen, weil acht je Gerät stillschweigend weggefallen waren). Diese Datei merkt sich deshalb den letzten Stand und meldet jeden Rückgang — auch wenn alles grün ist. AUFRUF: node tools/nachtlauf.mjs normal node tools/nachtlauf.mjs --jetzt auch wenn gerade gearbeitet wird ===================================================================== */ import { spawn } from "node:child_process"; import { writeFileSync, readFileSync, existsSync, mkdirSync, unlinkSync, statSync, } from "node:fs"; import { join, dirname } from "node:path"; import { fileURLToPath } from "node:url"; import { notizSchreiben, zeitWort } from "./nachtlauf-notiz.mjs"; const HIER = dirname(fileURLToPath(import.meta.url)); const WURZEL = join(HIER, ".."); /* Der Vault -- dort liest Filipe. Absichtlich fest und nicht geraten: Wenn der Ordner umzieht, soll das auffallen und nicht still in einen neuen Ordner schreiben, den niemand aufmacht. */ const VAULT = "C:/Users/qciga/Documents/Obelix/DogFather"; const NOTIZ = join(VAULT, "02 Projekte", "Pruefstand.md"); const ZUSTAND = join(WURZEL, "tools", ".nachtlauf-stand.json"); const SCHLOSS = join(WURZEL, "tools", ".nachtlauf-laeuft"); /* ZWEI LÄUFE GLEICHZEITIG SIND KEIN LAUF, SONDERN ZWEI KAPUTTE (06.09.2026, RunOne). Beide belegen dieselben Ports und legen dieselben Testdaten an; heraus kommen Fehler, die es nicht gibt -- und wer sie für echt hält, sucht stundenlang an Stellen, an denen nichts kaputt ist. DREI STUNDEN, dann gilt das Schloss als vergessen. Ein Schloss, das nie verfällt, blockiert beim nächsten Stromausfall für immer -- und was blockiert, wird abgeschafft. */ const SCHLOSS_FRIST_MS = 3 * 60 * 60 * 1000; /* `zeitWort` kommt aus nachtlauf-notiz.mjs -- zwei Kopien derselben Datumsschreibweise waeren zwei Staende, die auseinanderlaufen. */ function schlossNehmen() { if (existsSync(SCHLOSS)) { let alter = Infinity; try { alter = Date.now() - statSync(SCHLOSS).mtimeMs; } catch { /* egal */ } if (alter < SCHLOSS_FRIST_MS) { let wer = ""; try { wer = readFileSync(SCHLOSS, "utf8").trim(); } catch { /* egal */ } return { ok: false, grund: `Es läuft schon einer (seit ${Math.round(alter / 60000)} min, ${wer}).` }; } /* Älter als die Frist: Der gehört niemandem mehr. */ try { unlinkSync(SCHLOSS); } catch { /* egal */ } } try { writeFileSync(SCHLOSS, `PID ${process.pid}, gestartet ${zeitWort()}\n`, { flag: "wx" }); return { ok: true }; } catch { return { ok: false, grund: "Das Schloss ließ sich nicht setzen." }; } } function schlossAbgeben() { try { unlinkSync(SCHLOSS); } catch { /* egal */ } } function standLesen() { try { return JSON.parse(readFileSync(ZUSTAND, "utf8")); } catch { return null; } } /* --------------------------------------------------------------------- Der Lauf selbst -- alles-pruefen.mjs macht die eigentliche Arbeit. KEIN ZWEITER LÄUFER: Dort stecken die Frist je Datei, das Zählen der Einzelpunkte und die Regel "null Prüfungen ist ein Fehler". Das hier noch einmal zu bauen hiesse, zwei Rechnungen über dieselbe Frage zu haben -- und eine davon wäre irgendwann anders. --------------------------------------------------------------------- */ function laufen() { return new Promise((fertig) => { const start = Date.now(); const kind = spawn(process.execPath, [join("tools", "alles-pruefen.mjs")], { cwd: WURZEL, stdio: ["ignore", "pipe", "pipe"] }); let aus = ""; kind.stdout.on("data", (d) => { aus += d; }); kind.stderr.on("data", (d) => { aus += d; }); kind.on("error", (f) => fertig({ ging: false, grund: String(f?.message || f), aus })); kind.on("close", (code) => fertig({ ging: true, code, aus, minuten: Math.round((Date.now() - start) / 60000), })); }); } /** Aus der Ausgabe die Zahlen holen -- gelesen, nicht geschätzt. */ function auswerten(aus) { const dateien = aus.match(/Dateien:\s+(\d+) von (\d+)/); const punkte = aus.match(/Einzelpunkte:\s+(\d+) von (\d+)/); const rote = []; for (const treffer of aus.matchAll(/^### (pruef-[\w-]+\.mjs) \(Exitcode (-?\d+)\)$/gm)) { /* Die erste FEHL-Zeile darunter ist die Auskunft, die man braucht -- der Rest ist Zusammenhang. ZWEI FENSTER, NICHT EINS (25.09.2026): Bisher wurde nur in den ersten 900 Zeichen gesucht. Prüfungen mit viel Vorlauf (die browsergestützten vor allem) haben ihre FEHL-Zeile weiter hinten -- vier davon standen deshalb am 25.09. als „keine Fehlerzeile gefunden" in der Notiz, und man konnte ihnen nicht ansehen, ob sie kaputt waren oder nur lang. Jetzt wird zuerst eng gesucht (damit die erste, wichtigste Zeile gewinnt) und danach im ganzen Abschnitt. */ const ab = aus.indexOf(treffer[0]) + treffer[0].length; const bisNaechste = aus.indexOf("\n### pruef-", ab); const ganz = aus.slice(ab, bisNaechste === -1 ? ab + 20000 : bisNaechste); const suchen = (text) => (text.split("\n") .find((z) => /FEHL|Error|error:/.test(z)) || "").trim(); let erste = suchen(ganz.slice(0, 900)) || suchen(ganz); /* UND WENN GAR NICHTS DASTEHT, IST DAS AUCH EINE AUSKUNFT. Dann sind die letzten Zeilen das Beste, was es gibt -- zusammen mit dem Exitcode. Eine Meldung „kaputt, weiss nicht warum" ist ehrlich; „keine Fehlerzeile gefunden" klingt nach einer Kleinigkeit und ist doch dasselbe. */ let ohneGrund = false; if (!erste) { ohneGrund = true; const letzte = ganz.split("\n").map((z) => z.trim()) .filter(Boolean).slice(-3).join(" / "); erste = letzte || "(die Prüfung hat gar nichts ausgegeben)"; } /* DIE HAEUFIGSTE URSACHE HAT EINEN NAMEN -- und sie steht in der Uebersichtszeile ganz oben, nicht im Fehlerabschnitt. Am 25.09.2026 waren acht der 37 roten Dateien von dieser Sorte: fehlerfrei durchgelaufen, Exitcode 0, aber der Zaehler hat ihre Punkte nicht erkannt (sie schreiben „OK" statt „ok"). „Null Pruefungen ist ein Fehler" ist dann richtig UND irrefuehrend -- es klingt nach einer Pruefung, die nichts tut, und war eine, die niemand zaehlt. */ const uebersicht = new RegExp( `^\\s*FEHL\\s+${treffer[1].replace(/[.*+?^$()|[\]\\]/g, "\\$&")}\\s.*$`, "m"); const zeile = (aus.match(uebersicht) || [""])[0]; const nullPunkte = /KEINE PRUEFUNG GELAUFEN/.test(zeile); rote.push({ datei: treffer[1], code: Number(treffer[2]), erste: erste.slice(0, 220), ohneGrund, nullPunkte, }); } return { dateienOk: dateien ? Number(dateien[1]) : null, dateien: dateien ? Number(dateien[2]) : null, punkteOk: punkte ? Number(punkte[1]) : null, punkte: punkte ? Number(punkte[2]) : null, rote, }; } /* --------------------------------------------------------------------- Die Notiz --------------------------------------------------------------------- */ /* --------------------------------------------------------------------- Los --------------------------------------------------------------------- */ const vorher = standLesen(); const erzwingen = process.argv.includes("--jetzt"); const schloss = erzwingen ? { ok: true } : schlossNehmen(); if (!schloss.ok) { /* DER DRITTE AUSGANG. Kein Fehler -- nur: hier war nichts zu messen. */ mkdirSync(dirname(NOTIZ), { recursive: true }); writeFileSync(NOTIZ, notizSchreiben({ vorher, konnteNicht: schloss.grund }, NOTIZ), "utf8"); console.log("Konnte nicht nachsehen: " + schloss.grund); process.exit(0); } let ergebnis; try { console.log("Nachtlauf gestartet — das dauert. " + zeitWort()); ergebnis = await laufen(); } finally { if (!erzwingen) schlossAbgeben(); } if (!ergebnis.ging) { mkdirSync(dirname(NOTIZ), { recursive: true }); writeFileSync(NOTIZ, notizSchreiben({ vorher, konnteNicht: `Der Läufer ließ sich nicht starten: ${ergebnis.grund}`, }, NOTIZ), "utf8"); console.log("Konnte nicht nachsehen: " + ergebnis.grund); process.exit(0); } const lage = auswerten(ergebnis.aus); /* KONNTE DER LAUF ÜBERHAUPT ETWAS MESSEN? Steht keine Zahl in der Ausgabe, ist etwas anderes schiefgegangen als eine rote Prüfung -- und "0 von 0 in Ordnung" wäre die beruhigendste Lüge von allen. */ if (lage.dateien == null || lage.punkte == null || lage.punkte === 0) { mkdirSync(dirname(NOTIZ), { recursive: true }); writeFileSync(NOTIZ, notizSchreiben({ vorher, konnteNicht: "Der Lauf hat keine einzige Zahl geliefert — vermutlich ist er" + " abgebrochen, bevor er anfangen konnte.\n\nLetzte Ausgabe:\n\n```\n" + ergebnis.aus.slice(-700) + "\n```", }, NOTIZ), "utf8"); console.log("Konnte nicht nachsehen: keine Zahlen in der Ausgabe."); process.exit(0); } mkdirSync(dirname(NOTIZ), { recursive: true }); writeFileSync(NOTIZ, notizSchreiben({ lage, vorher, minuten: ergebnis.minuten }, NOTIZ), "utf8"); /* Der Stand für den nächsten Vergleich -- erst NACH der Notiz, damit ein Absturz beim Schreiben nicht den alten Vergleichswert wegnimmt. */ writeFileSync(ZUSTAND, JSON.stringify({ wann: zeitWort(), zeit: Date.now(), dateien: lage.dateien, dateienOk: lage.dateienOk, punkte: lage.punkte, punkteOk: lage.punkteOk, rote: lage.rote.map((r) => r.datei), }, null, 1), "utf8"); /* Die ganze Ausgabe daneben -- für den Fall, dass die Notiz nicht reicht. Sie wird jedes Mal überschrieben; zwei Läufe zu vergleichen ist Sache der Zahlen oben, nicht eines wachsenden Protokolls. */ writeFileSync(join(WURZEL, "tools", ".nachtlauf-letzte-ausgabe.txt"), ergebnis.aus, "utf8"); console.log(`Fertig nach ${ergebnis.minuten} min: ` + `${lage.dateienOk} von ${lage.dateien} Dateien, ` + `${lage.punkteOk} von ${lage.punkte} Einzelprüfungen.`); console.log(`Ergebnis steht in: ${NOTIZ}`); process.exit(lage.rote.length ? 1 : 0);