DogFatherGit/dogfather-universe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bei dir klingelt nichts -- und 49 Pruefungen, die blind waren

Browse Source 
1. SIEBEN VON ELF HATTEN KEIN GERAET ANGEMELDET.

Gemessen am echten Server, nicht geschaetzt (die Notiz von heute Nacht
sagte acht -- Tamy hat inzwischen eins). Bei ihnen kommt nichts an,
solange die Seite zu ist: keine Aufgabe, kein Termin, kein Anruf.

Die Glocke sagt das seit jeher korrekt und kennt sogar den
iPhone-Sonderfall ("erst zum Home-Bildschirm"). Nur tippt sie niemand
an -- sie ist ein stiller Schalter in einer Leiste.

Jetzt steht es dort, wo man hinsieht: als Hinweis in "Was ist dran?",
mit Weg auf anruf-probe.html. Als OFFENER PUNKT, nicht als Warnung --
eine Warnung, die bei sieben von elf Leuten dauerhaft oben steht, ist
nach einer Woche unsichtbar, und mit ihr die echten daneben. Er
verschwindet von selbst, sobald ein Geraet da ist (Gegenprobe in
pruef-glocke).

Und ohne die "1" davor: Er zaehlt nichts, er beschreibt einen Zustand.

FUENF DER SIEBEN DURFTEN DIE SEITE GAR NICHT OEFFNEN. anruf-probe.html
stand nur Leitung und Modis offen. Das war die falsche Einschraenkung:
Die Seite prueft die ganze Kette bis zur Geraete-Kennung, und die
traegt auch jede Aufgaben- und Terminerinnerung. Jetzt alle Team-Rollen,
ohne "gast" (die Community bekommt keine Erinnerungen).

2. 49 PRUEFUNGEN KONNTEN "BELEGT" NICHT VON "KAPUTT" UNTERSCHEIDEN.

Aufgefallen beim Nachsehen, warum ein Lauf rot war: Es war mein eigener,
haengengebliebener Lauf, der den Port hielt. Kein Befund.

Dabei gemessen: Von 130 Pruefungen hatten 49 keinen Portwaechter, und
SIEBEN Portnummern sind doppelt vergeben (4186, 4188, 4189, 4193, 4198,
4321, 4345). Bei belegtem Port startet der eigene Server STILL nicht --
und alles Weitere misst gegen einen fremden Stand. Das hat in diesem
Haus schon zweimal Stunden gekostet (27.08. und 05.09.).

Der Waechter existierte seit dem 05.09., er war nur nie ausgerollt.
Jetzt haben ihn alle 130. Gegenprobe gemacht: Port belegt ->
Rueckgabewert 3 mit Begruendung statt stillem Messen.

pruef-content bekommt BEIDE Ports -- sie startet zwei Server, und der
zweite gehoert zur Gegenprobe. Nur den ersten zu schuetzen hiesse,
ausgerechnet den Teil ungeschuetzt zu lassen, dem man glaubt.

Die sieben doppelten Nummern bleiben vorerst. Mit dem Waechter ist eine
Kollision jetzt laut statt still; Umnummerieren ist ein eigener Schritt.

3. pruef-rollen IST ABGESTUERZT, SEIT WANN WEISS NIEMAND.

"Target crashed" bei der fuenften Rolle, nach 234 gruenen Pruefungen.
Kein Fehlschlag -- ein toter Browser.

NACHGEMESSEN GEGEN DEN STAND VOR HEUTE (0b73fbb): dort genauso, an
derselben Stelle. Es lag also nicht an den Aenderungen dieses Tages.
Aufgefallen ist es nie, weil ein abgestuerzter Browser von aussen wie
ein Programmfehler aussieht und die 234 gruenen Zeilen davor sich wie
ein fast bestandener Lauf lesen.

Ursache ist die Menge: fuenf Rollen mal sechzehn Seiten in EINEM
Browserprozess. Die Kontexte wurden je Rolle geschlossen, der Prozess
darunter lief durch. Jetzt bekommt jede Rolle ihren eigenen Browser,
und ein Absturz meldet sich selbst statt als Zeitueberschreitung
irgendwo weiter unten aufzuschlagen.

Ergebnis: 321 Pruefungen, alles in Ordnung -- statt Absturz bei 234.

4. DAS SYMBOL FUER TIKTOK.

assets/img/app-symbole/workspace-1024.png, frisch gerendert statt
hochskaliert (das Huskygesicht lebt von harten Kanten) und als VOLLES
Quadrat ohne Rundung: Die Aufnahme hat keinen Alphakanal, die Ecken
waeren sonst weiss. App-Portale wollen ohnehin das volle Quadrat, die
Rundung macht das Betriebssystem.

Die sechs vorhandenen Groessen sind dabei bitgleich geblieben --
gepruefte Nebenwirkung, nicht gehofft.

GEMESSEN: pruef-glocke 31/0 (neu: 5 zum Hinweis), pruef-rollen 321/0
(vorher Absturz), pruef-rechtetafel 19/0, pruef-struktur 0 Fehler,
pruef-betreuung und pruef-werdegang gruen.

Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
DogFatherGit
2026-09-19 11:14:18 +02:00
co-authored by Claude Opus 5
parent 6c10ef0600
commit 790b77a73d
92 changed files with 976 additions and 456 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/pruef-ampel.mjs
+7
View File
@@ -11,6 +11,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-ampel-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4206, "pruef-ampel");
process.env.PORT = "4206";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -20,6 +26,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-aufgaben-vorlagen.mjs
+7
View File
@@ -20,6 +20,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-aufv-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4211, "pruef-aufgaben-vorlagen");
process.env.PORT = "4211";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -29,6 +35,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(240_000, "pruef-aufgaben-vorlagen");
await new Promise((r) => setTimeout(r, 700));
server/pruef-aufgabenbrett.mjs
+7
View File
@@ -35,6 +35,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-brett-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4216, "pruef-aufgabenbrett");
process.env.PORT = "4216";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -44,6 +50,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-bereiche-lesend.mjs
+7
View File
@@ -13,9 +13,16 @@
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { portMussFreiSein } from "./helfer-port.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-bereiche-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4183, "pruef-bereiche-lesend");
process.env.PORT = "4183";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
server/pruef-betreuung.mjs
+7
View File
@@ -12,9 +12,16 @@
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { portMussFreiSein } from "./helfer-port.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-betreuung-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4189, "pruef-betreuung");
process.env.PORT = "4189";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
server/pruef-buehne.mjs
+7
View File
@@ -100,6 +100,12 @@ console.log(`Zeitrahmen: ${Math.round((100_000 + SEITEN_ZEIT) / 1000)} s.`);
const ordner = mkdtempSync(join(tmpdir(), "ws-buehne-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4193, "pruef-buehne");
process.env.PORT = "4193";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -110,6 +116,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-checkliste.mjs
+7
View File
@@ -19,6 +19,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-check-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4207, "pruef-checkliste");
process.env.PORT = "4207";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -28,6 +34,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-code.mjs
+7
View File
@@ -25,6 +25,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-code-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4195, "pruef-code");
process.env.PORT = "4195";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -35,6 +41,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-content-ansicht.mjs
+7
View File
@@ -6,6 +6,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-content-b-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4185, "pruef-content-ansicht");
process.env.PORT = "4185";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -16,6 +22,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-content.mjs
+8
View File
@@ -5,9 +5,17 @@
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { portMussFreiSein } from "./helfer-port.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-content-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* BEIDE PORTS, nicht nur einer (nachgeruestet 19.09.2026). Diese
Datei startet ZWEI Server nacheinander -- 4184 fuer den Hauptlauf,
4194 fuer die Gegenprobe. Nur den ersten zu pruefen hiesse, die
Gegenprobe ungeschuetzt zu lassen, und die ist der Teil, dem man
glaubt. */
await portMussFreiSein(4184, "pruef-content");
await portMussFreiSein(4194, "pruef-content (Gegenprobe)");
process.env.PORT = "4184";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
server/pruef-crew-adresse.mjs
+7
View File
@@ -29,6 +29,12 @@ import { request } from "node:http";
const ordner = mkdtempSync(join(tmpdir(), "ws-crew-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4371, "pruef-crew-adresse");
process.env.PORT = "4371";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -38,6 +44,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-crew-adresse");
await new Promise((r) => setTimeout(r, 700));
server/pruef-crew-wand-bild.mjs
+7
View File
@@ -27,12 +27,19 @@ import { fileURLToPath } from "node:url";
const ordner = mkdtempSync(join(tmpdir(), "ws-crewbild-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4373, "pruef-crew-wand-bild");
process.env.PORT = "4373";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-crew-wand-bild");
await new Promise((r) => setTimeout(r, 700));
server/pruef-formulare.mjs
+7
View File
@@ -21,6 +21,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-form-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4203, "pruef-formulare");
process.env.PORT = "4203";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -30,6 +36,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-freie-namen.mjs
+7
View File
@@ -26,6 +26,12 @@ import { heuteLokal, tagLokal } from "./helfer-zeit.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-frei-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4192, "pruef-freie-namen");
process.env.PORT = "4192";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -36,6 +42,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-glocke.mjs
+50
View File
@@ -391,11 +391,61 @@ melde("\n=== Anmelden und wieder abmelden ===");
const zahl = () => p.prepare("SELECT COUNT(*) AS n FROM push_anmeldungen").get().n;
ok(zahl() === 0, `vorher ${zahl()} Anmeldungen in der Datenbank`);
/* ==== "BEI DIR KLINGELT NICHTS" (19.09.2026) ======================
Gemessen an diesem Tag auf dem echten Server: Von elf Zugaengen
hatten SIEBEN kein einziges Geraet angemeldet. Bei ihnen kommt
nichts an, solange die Seite zu ist -- keine Aufgabe, kein Termin,
kein Anruf.
Die Glocke sagt das seit jeher korrekt. Nur tippt sie niemand an:
Sie ist ein stiller Schalter in einer Leiste. Deshalb steht es
jetzt auch dort, wo man hinsieht -- in "Was ist dran?".
DIE GEGENPROBE IST DER EIGENTLICHE PUNKT: Der Hinweis muss
VERSCHWINDEN, sobald ein Geraet da ist. Eine Warnung, die immer
kommt, ist keine Warnung mehr -- und bei sieben von elf Leuten
stuende sie sonst dauerhaft ueber den echten. */
const hinweise = async () => (await seite.evaluate(async () => {
const a = await fetch("/workspace/api/hinweise", { credentials: "same-origin" });
return a.json();
})).hinweise || [];
{
const vorher = await hinweise();
const h = vorher.find((x) => x.art === "kein_geraet");
ok(!!h, "ohne Geraet steht der Hinweis in „Was ist dran?“");
ok(h?.ziel === "anruf-probe.html",
`und er fuehrt auf die Seite, die sagt warum (${h?.ziel})`);
ok(h?.stufe === "offen",
`als offener Punkt, nicht als Warnung (${h?.stufe}) — sonst stuende er `
+ "dauerhaft ueber den echten Warnungen");
/* Und auf dem Bildschirm steht er ohne die "1" davor: Er zaehlt
nichts, er beschreibt einen Zustand. */
const sichtbar = await seite.evaluate(() =>
[...document.querySelectorAll(".dran__punkt")]
.map((li) => li.textContent.trim()).find((t) => /klingelt nichts/.test(t)) || "");
ok(/klingelt nichts/.test(sichtbar) && !/^\s*1/.test(sichtbar),
`auf der Seite steht er ohne Zahl davor: „${sichtbar.replace(/\s+/g, " ").slice(0, 60)}“`);
}
await seite.click("#glocke");
await seite.waitForTimeout(1200);
ok(zahl() === 1, `nach dem Klick: ${zahl()} Anmeldung`);
/* GEGENPROBE: Jetzt muss der Hinweis weg sein. */
{
/* OHNE NEULADEN. Der erste Anlauf lud die Seite neu -- danach war
das Test-Doppel fuer den Push-Dienst weg, der Glockenknopf stand
wieder auf "aus", und die drei folgenden Pruefungen meldeten
Fehler, die es nicht gab. Die Schnittstelle antwortet ohnehin
live; eine neue Seite braucht es dafuer nicht. */
const nachher = await hinweise();
ok(!nachher.some((x) => x.art === "kein_geraet"),
"mit einem angemeldeten Geraet ist der Hinweis weg — nichts zu quittieren");
}
const eintrag = p.prepare("SELECT * FROM push_anmeldungen").get();
ok(eintrag?.person_id === idDogi && /^https:\/\//.test(eintrag?.endpunkt || ""),
`sie gehört der richtigen Person und hat eine https-Adresse`);
server/pruef-grosscheck.mjs
+7
View File
@@ -44,6 +44,12 @@ const REPO = join(dirname(fileURLToPath(import.meta.url)), "..");
const ordner = mkdtempSync(join(tmpdir(), "ws-gross-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4218, "pruef-grosscheck");
process.env.PORT = "4218";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -54,6 +60,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-handy.mjs
+7
View File
@@ -28,6 +28,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-handy-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4198, "pruef-handy");
process.env.PORT = "4198";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -37,6 +43,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-kalender.mjs
+7
View File
@@ -13,6 +13,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-kal-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4188, "pruef-kalender");
process.env.PORT = "4188";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -23,6 +29,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-kopf-messen.mjs
+7
View File
@@ -26,6 +26,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-messen-"));
process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4179, "pruef-kopf-messen");
process.env.PORT = "4179";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -36,6 +42,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-lesbarkeit.mjs
+7
View File
@@ -28,6 +28,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-lese-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4214, "pruef-lesbarkeit");
process.env.PORT = "4214";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -37,6 +43,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-manager-sicht.mjs
+7
View File
@@ -38,6 +38,12 @@ import { heuteLokal, tagLokal } from "./helfer-zeit.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-msicht-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4199, "pruef-manager-sicht");
process.env.PORT = "4199";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -48,6 +54,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-modi-checkliste.mjs
+7
View File
@@ -26,6 +26,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-mcheck-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4369, "pruef-modi-checkliste");
process.env.PORT = "4369";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -35,6 +41,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-modi-checkliste");
await new Promise((r) => setTimeout(r, 800));
server/pruef-modi-ideen.mjs
+7
View File
@@ -31,6 +31,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-ideen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4365, "pruef-modi-ideen");
process.env.PORT = "4365";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -96,6 +102,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-modi-ideen");
await new Promise((r) => setTimeout(r, 900));
server/pruef-modi-katalog.mjs
+7
View File
@@ -22,6 +22,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-kat2-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4363, "pruef-modi-katalog");
process.env.PORT = "4363";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -33,6 +39,7 @@ express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(
import { notbremse } from "./helfer-notbremse.mjs";
import { ersatzschreibungen } from "./helfer-deutsch.mjs";
import { fileURLToPath } from "node:url";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-modi-katalog");
await new Promise((r) => setTimeout(r, 700));
server/pruef-modi-kategorien.mjs
+7
View File
@@ -23,6 +23,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-kat-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4361, "pruef-modi-kategorien");
process.env.PORT = "4361";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -32,6 +38,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-modi-kategorien");
await new Promise((r) => setTimeout(r, 700));
server/pruef-modi-livecheck.mjs
+7
View File
@@ -27,6 +27,12 @@ import { tagLokal } from "./helfer-tag.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-live-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4367, "pruef-modi-livecheck");
process.env.PORT = "4367";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -36,6 +42,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-modi-livecheck");
await new Promise((r) => setTimeout(r, 800));
server/pruef-modi-verborgen.mjs
+7
View File
@@ -23,6 +23,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-modi-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4359, "pruef-modi-verborgen");
process.env.PORT = "4359";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -32,6 +38,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* NACH index.js: Der Server haengt dort zwei Auffangnetze ein, die
einen Absturz nur protokollieren. Fuer den Betrieb richtig, fuer eine
server/pruef-personen-formular.mjs
+7
View File
@@ -24,6 +24,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-pform-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4198, "pruef-personen-formular");
process.env.PORT = "4198";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -34,6 +40,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-personen-liste.mjs
+7
View File
@@ -18,6 +18,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-personen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4187, "pruef-personen-liste");
process.env.PORT = "4187";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -28,6 +34,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-personen-loeschen.mjs
+7
View File
@@ -8,9 +8,16 @@
import { mkdtempSync, rmSync, readdirSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { portMussFreiSein } from "./helfer-port.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-loeschen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4188, "pruef-personen-loeschen");
process.env.PORT = "4188";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
server/pruef-protokoll-klappe.mjs
+7
View File
@@ -10,6 +10,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-klappe-"));
process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4180, "pruef-protokoll-klappe");
process.env.PORT = "4180";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -20,6 +26,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-protokoll-loeschen.mjs
+7
View File
@@ -31,6 +31,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-prot-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4197, "pruef-protokoll-loeschen");
process.env.PORT = "4197";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -41,6 +47,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-rollen.mjs
+43 -3
View File
@@ -33,6 +33,12 @@ import { heuteLokal, tagLokal } from "./helfer-zeit.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-rollen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4193, "pruef-rollen");
process.env.PORT = "4193";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -43,6 +49,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
@@ -194,7 +201,31 @@ const ROLLEN = [
const { chromium } = await import(
"file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
const browser = await chromium.launch();
/* ==== EIN BROWSER JE ROLLE, NICHT EINER FUER ALLE (19.09.2026) ========
DER BEFUND: Dieser Lauf ist bei der fuenften Rolle abgestuerzt --
"Target crashed", nach 234 gruenen Pruefungen. Kein Fehlschlag,
sondern ein toter Browser: Der Renderer-Prozess wird vom System
beendet, wenn ihm der Speicher ausgeht.
Nachgemessen gegen den Stand VOR den Aenderungen dieses Tages
(Commit 0b73fbb) -- dort stuerzt er genauso ab, an derselben Stelle.
Er war also schon vorher rot, und zwar ohne dass es jemandem
aufgefallen ist: Von aussen sieht ein abgestuerzter Browser aus wie
ein Programmfehler, und die 234 gruenen Zeilen davor lesen sich wie
ein fast bestandener Lauf.
DIE URSACHE IST DIE MENGE: fuenf Rollen mal sechzehn Seiten, jede
mit Hintergrundbild, Schriften und Skripten -- rund achtzig
Seitenaufbauten in EINEM Browserprozess. Die Kontexte wurden zwar
je Rolle geschlossen (`kontext.close()`), der Prozess darunter lief
aber durch und gab den Speicher nicht zurueck.
Ein Prueflauf, der abstuerzt, beweist nichts -- er ist schlimmer als
einer, der scheitert, weil das Ergebnis nach Programmfehler aussieht.
Deshalb bekommt jede Rolle ihren eigenen Browser, und der wird am
Ende der Runde beendet. Kostet ein paar Sekunden je Rolle. */
/* Fehler, die nichts mit uns zu tun haben. Bewusst kurz gehalten: Jede
Ausnahme hier ist eine Stelle, an der eine echte Panne durchrutschen
@@ -208,9 +239,19 @@ const istEgal = (t) => EGAL.some((r) => r.test(t));
const berichte = [];
for (const r of ROLLEN) {
const browser = await chromium.launch();
const kontext = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
const seite = await kontext.newPage();
/* EIN ABGESTUERZTER BROWSER MUSS SICH MELDEN, nicht schweigen.
Ohne diesen Zuhoerer faellt der Absturz erst beim naechsten
Zugriff auf -- als Zeitueberschreitung irgendwo weiter unten,
Hunderte Zeilen von der Ursache entfernt. */
seite.on("crash", () => {
console.error(` ABSTURZ: Der Browser ist bei "${r.name}" gestorben.`);
console.error(" Das ist kein Befund am Code -- meist fehlender Speicher.");
});
const konsole = [];
const schlechteAntworten = [];
seite.on("console", (m) => { if (m.type() === "error" && !istEgal(m.text())) konsole.push(m.text()); });
@@ -324,10 +365,9 @@ for (const r of ROLLEN) {
await seite.screenshot({ path: `pruef-rollen-${r.rolle}.png`, fullPage: false });
await kontext.close();
await browser.close();
}
await browser.close();
/* ---------- Abschluss --------------------------------------------------- */
console.log("");
server/pruef-schulung.mjs
+7
View File
@@ -18,6 +18,12 @@ import { createHash } from "node:crypto";
const ordner = mkdtempSync(join(tmpdir(), "ws-schul-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4205, "pruef-schulung");
process.env.PORT = "4205";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -27,6 +33,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-scout-zuteilung.mjs
+7
View File
@@ -26,6 +26,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-zut-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4217, "pruef-scout-zuteilung");
process.env.PORT = "4217";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -35,6 +41,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-serien.mjs
+7
View File
@@ -29,6 +29,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-serien-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4189, "pruef-serien");
process.env.PORT = "4189";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -39,6 +45,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-sicherung.mjs
+7
View File
@@ -15,9 +15,16 @@ import { tmpdir } from "node:os";
import { join } from "node:path";
import { createRequire } from "node:module";
import { pathToFileURL } from "node:url";
import { portMussFreiSein } from "./helfer-port.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-sicherung-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4181, "pruef-sicherung");
process.env.PORT = "4181";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
server/pruef-sicht.mjs
+7
View File
@@ -26,6 +26,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-sicht-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4215, "pruef-sicht");
process.env.PORT = "4215";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -35,6 +41,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-sprung.mjs
+7
View File
@@ -32,6 +32,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-sprung-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4212, "pruef-sprung");
process.env.PORT = "4212";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -41,6 +47,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-start-ansicht.mjs
+7
View File
@@ -6,6 +6,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-start-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4186, "pruef-start-ansicht");
process.env.PORT = "4186";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -16,6 +22,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-steckbrief.mjs
+7
View File
@@ -11,6 +11,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-sb-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4196, "pruef-steckbrief");
process.env.PORT = "4196";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -20,6 +26,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-tagesruf.mjs
+7
View File
@@ -39,6 +39,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-start-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4186, "pruef-tagesruf");
process.env.PORT = "4186";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -49,6 +55,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-team-ampel.mjs
+7
View File
@@ -31,6 +31,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-ampel-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4385, "pruef-team-ampel");
process.env.PORT = "4385";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
@@ -39,6 +45,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-team-ampel");
await new Promise((r) => setTimeout(r, 700));
server/pruef-team-stufen.mjs
+7
View File
@@ -27,6 +27,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-stufen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4375, "pruef-team-stufen");
process.env.PORT = "4375";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
@@ -35,6 +41,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
notbremse(180_000, "pruef-team-stufen");
await new Promise((r) => setTimeout(r, 700));
server/pruef-uebersicht-browser.mjs
+7
View File
@@ -12,6 +12,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-uebersicht-b-"));
process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4177, "pruef-uebersicht-browser");
process.env.PORT = "4177";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -24,6 +30,7 @@ express.response.cookie = function (name, wert, opt) {
return echteCookie.call(this, name, wert, { ...(opt || {}), secure: false });
};
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-uebersicht.mjs
+7
View File
@@ -10,9 +10,16 @@
import { mkdtempSync, rmSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { portMussFreiSein } from "./helfer-port.mjs";
const ordner = mkdtempSync(join(tmpdir(), "ws-uebersicht-"));
process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4176, "pruef-uebersicht");
process.env.PORT = "4176";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
server/pruef-verborgen.mjs
+7
View File
@@ -6,6 +6,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-start-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4186, "pruef-verborgen");
process.env.PORT = "4186";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -16,6 +22,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-wissen-neu.mjs
+7
View File
@@ -15,6 +15,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-wissen-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4201, "pruef-wissen-neu");
process.env.PORT = "4201";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -24,6 +30,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-workspace-seiten.mjs
+7
View File
@@ -7,6 +7,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-kopf-"));
process.env.WORKSPACE_DB = join(ordner, "pruef.sqlite");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4178, "pruef-workspace-seiten");
process.env.PORT = "4178";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -19,6 +25,7 @@ express.response.cookie = function (n, w, o) {
return echteCookie.call(this, n, w, { ...(o || {}), secure: false });
};
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/pruef-zustand-ansicht.mjs
+7
View File
@@ -8,6 +8,12 @@ import { join } from "node:path";
const ordner = mkdtempSync(join(tmpdir(), "ws-zustand-"));
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
/* DER PORT MUSS MEINER SEIN (nachgeruestet 19.09.2026).
Ohne diese Zeile startet der eigene Server bei belegtem Port
STILL nicht -- und alles Folgende misst gegen einen fremden
Stand. Das ist der dritte Ausgang: belegt ist etwas anderes
als kaputt. */
await portMussFreiSein(4182, "pruef-zustand-ansicht");
process.env.PORT = "4182";
process.env.SITE_ACCESS_SECRET = "lokaler-test";
process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
@@ -18,6 +24,7 @@ const express = (await import("express")).default;
const ec = express.response.cookie;
express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
import { notbremse } from "./helfer-notbremse.mjs";
import { portMussFreiSein } from "./helfer-port.mjs";
await import("./index.js");
/* DIE NOTBREMSE. Muss NACH index.js stehen: Der Server haengt dort
zwei Auffangnetze ein, die einen Absturz nur protokollieren --
server/rechte.js
+18 -3
View File
@@ -298,9 +298,24 @@ export const SEITEN = {
/* DIE ANRUF-PROBE (19.09.2026). Sie sagt einem Menschen in seinem
eigenen Browser, warum es nicht klingelt -- die Frage, die sich
von aussen nicht beantworten laesst. Sie ruft niemanden an und
zeigt nichts ueber andere; deshalb steht sie allen offen, die
ueberhaupt telefonieren koennen. */
"/workspace/anruf-probe.html": ["admin", "hand", "modi"],
zeigt nichts ueber andere.
ERWEITERT AM 19.09.2026, nachmittags, nach einer Messung: Von
elf Zugaengen hatten SIEBEN kein einziges Geraet angemeldet -- bei
ihnen klingelt nichts und es kommt keine Erinnerung an, solange
die Seite zu ist. Fuenf der sieben sind Creator, Scout oder Spicy
Media und durften diese Seite gar nicht oeffnen.
Das war die falsche Einschraenkung: Die Seite prueft nicht nur
Anrufe, sondern die ganze Kette bis zur angemeldeten Geraete-Kennung
-- und die traegt auch jede Aufgaben- und Terminerinnerung. Wer
Erinnerungen bekommen kann, muss nachsehen koennen, warum sie
ausbleiben.
OHNE "gast". Die Community bekommt keine Erinnerungen, und eine
Seite mit sieben Prueftpunkten ueber etwas, das es fuer sie nicht
gibt, waere nur Verwirrung. */
"/workspace/anruf-probe.html": [...ALLE],
/* DIE ANFRAGE FUER MODI (17.09.2026).
server/workspace-hinweise.js
+38
View File
@@ -336,6 +336,44 @@ hinweisRouter.get("/workspace/api/hinweise", (req, res) => {
"neue Anfrage für Modi", "bewerbungen.html",
zaehle("SELECT COUNT(*) n FROM bewerbungen WHERE zustand = 'neu'", []));
/* ==== BEI DIR KLINGELT NICHTS (19.09.2026) =======================
Gemessen an diesem Tag: Von elf Zugaengen hatten SIEBEN kein
einziges Geraet angemeldet. Bei ihnen kommt keine einzige
Erinnerung an, solange die Seite zu ist -- keine Aufgabe, kein
Termin, kein Anruf.
Die Glocke oben rechts sagt das seit jeher korrekt ("Benach-
richtigungen aus") und kennt sogar den iPhone-Sonderfall. Nur
tippt sie niemand an: Sie ist ein stiller Schalter in einer
Leiste, kein Hinweis. Deshalb steht es jetzt dort, wo man
hinsieht.
DIESER HINWEIS GEHT NUR AN DIE PERSON SELBST, nicht an die
Sicht. `req.person` und nicht `person`: Wenn DogFather die Lage
eines Scouts ansieht, waere "bei DIR klingelt nichts" eine
Aussage ueber den falschen Menschen -- und eine, die er nicht
loesen kann.
STUFE "offen", NICHT "warnung". Es ist kein Ausfall, sondern
etwas, das man einmal einrichtet. Ein rotes Warnzeichen, das
bei sieben von elf Leuten dauerhaft oben steht, waere nach
einer Woche unsichtbar -- und mit ihm die echten Warnungen
daneben.
ER VERSCHWINDET VON SELBST, sobald ein Geraet angemeldet ist.
Nichts zu quittieren, nichts, was veralten kann -- Regel 1
dieser Datei. */
if (req.person?.id) {
const geraete = zaehle(
"SELECT COUNT(*) n FROM push_anmeldungen WHERE person_id = ?", [req.person.id]);
if (!geraete) {
dazu("kein_geraet", "offen",
"Bei dir klingelt nichts – kein Gerät angemeldet",
"anruf-probe.html", 1);
}
}
hinweise.sort((x, y) => (RANG[x.stufe] - RANG[y.stufe]) || (y.anzahl - x.anzahl));
res.json({ hinweise, stand: new Date().toISOString() });
} catch (fehler) {