Note the 1.36.1 release in the status

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.claude/launch.json

@@ -228,6 +228,12 @@
         "$env:APP_ENV='prod'; $env:APP_DEBUG='0'; $env:DATABASE_URL='sqlite:///C:/Django Project/KantSites/var/ebi-immobilien.db'; $env:MEDIA_DIRECTORY='C:/Django Project/KantSites/var/ebi-immobilien-media'; $env:SITE_ORIGIN='http://127.0.0.1:8107'; & C:/php84/php.exe -d upload_max_filesize=8M -d post_max_size=10M -d memory_limit=256M -S 127.0.0.1:8107 -t public bin/dev-router.php"
       ],
       "port": 8107
+    },
+    {
+      "name": "zentrale",
+      "runtimeExecutable": "C:/php84/php.exe",
+      "runtimeArgs": ["-d", "curl.cainfo=C:/Program Files/Git/mingw64/etc/ssl/certs/ca-bundle.crt", "-S", "127.0.0.1:8115", "-t", "zentrale/public", "zentrale/public/index.php"],
+      "port": 8115
     }
   ]
 }

.env.example

@@ -15,3 +15,6 @@ MAILER_DSN=sendmail://default
 # Die Adresse der Verwaltung. Ohne Eintrag: /admin. Aenderbar mit
 # `php bin/console cms:admin:path <neu>` - der Befehl schreibt sie nach .env.
 #ADMIN_PATH=admin
+# Die Zentrale, bei der sich diese Installation mit Adresse und Fassung meldet und von der sie
+# Updates annimmt. Ohne Eintrag: https://sites.kant-it.de. Abschalten mit ZENTRALE_URL=aus.
+#ZENTRALE_URL=https://sites.kant-it.de

.gitignore

@@ -18,3 +18,8 @@
 # damit auf einem frischen Server nichts fehlt und nichts von Google geladen wird. Andere
 # Installationen holen ihre eigenen mit `cms:fonts:fetch` - deren Dateien gehoeren nicht hierher.
 /public/assets/build/
+
+# Zentrale (sites.kant-it.de): Konfiguration und Daten gehoeren dem Server.
+/zentrale/config.php
+/zentrale/var/*
+!/zentrale/var/.htaccess

README.md

@@ -310,6 +310,8 @@ Ein JSON-Dokument lässt sich zusätzlich lokal über `php bin/console cms:save-
 
 Sicherung, geplante Veröffentlichung, Statistik verdichten, Updateprüfung und Aufräumen laufen über einen eingebauten Plan. Auf geteiltem Hosting gibt es oft keinen Cronjob – deshalb stößt hier **die Anfrage** die Arbeit an, nach der ausgelieferten Antwort (`kernel.terminate`), sodass kein Besucher darauf wartet. Der Bildschirm **Verwaltung → Aufgaben** zeigt Plan, letztes Ergebnis und Protokoll und schaltet jede Aufgabe einzeln.
 
+Die Aufgabe „Bei der Zentrale melden“ schickt alle 15 Minuten Adresse und Fassung an `https://sites.kant-it.de` und holt dort angestoßene Updates ab (ADR 123, `zentrale/README.md`). Abschalten mit `ZENTRALE_URL=aus` in `.env`; Installationen mit lokalem `SITE_ORIGIN` melden nie. Protokollprüfung: `php scripts/zentrale-check.php`.
+
 Vier Auslöser, in aufsteigender Verlässlichkeit:
 
 1. **Besuch** – jeder Seitenaufruf prüft, ob etwas fällig ist. Der Normalfall kostet eine gelesene Datei (`var/scheduler.json`) und keine Datenbankabfrage. Standardmäßig an.

VERSION

@@ -1 +1 @@
-1.35.1
+1.36.1

config/services.yaml

@@ -14,6 +14,9 @@ parameters:
     kant.mailer_dsn: 'sendmail://default'
     # Die Einstellung, die die Verwaltung anzeigt und ausprobiert; Tests setzen sie fest.
     kant.mail_dsn: '%env(default:kant.mailer_dsn:MAILER_DSN)%'
+    # Die Zentrale, bei der sich jede Installation meldet (ADR 123). ZENTRALE_URL=aus schaltet ab.
+    kant.zentrale_default: 'https://sites.kant-it.de'
+    kant.zentrale_url: '%env(default:kant.zentrale_default:ZENTRALE_URL)%'
 
 services:
     _defaults:
@@ -150,6 +153,21 @@ services:
         arguments:
             $tasks: !tagged_iterator kant.task
             $projectDir: '%kernel.project_dir%'
+    App\Ops\Zentrale:
+        arguments:
+            $root: '%kernel.project_dir%'
+            $url: '%kant.zentrale_url%'
+            $siteOrigin: '%env(SITE_ORIGIN)%'
+            $databaseUrl: '%env(DATABASE_URL)%'
+            $senden: null
+    App\Ops\Tasks\ZentraleTask:
+        arguments:
+            $siteOrigin: '%env(SITE_ORIGIN)%'
+            $projectDir: '%kernel.project_dir%'
+            $anstossen: null
+    App\EventSubscriber\RemoteUpdateFinishSubscriber:
+        arguments:
+            $projectDir: '%kernel.project_dir%'
     App\Ops\Tasks\CleanupTask:
         arguments:
             $projectDir: '%kernel.project_dir%'

docs/ARCHITECTURE.md

@@ -1,6 +1,24 @@
 # Architekturentscheidungen
 
-Stand: 12.10.2026. Arbeitstitel KantSites; Produktname offen.
+Stand: 14.10.2026. Arbeitstitel KantSites; Produktname offen.
+
+## ADR 123 – Zentrale auf sites.kant-it.de: Meldung, Übersicht, Update aus der Ferne (14.10.2026)
+
+Anlass: Umut: „Alle KantSites melden sich bei meiner Hauptplattform an … ich kann sehen, welche Domains welche Versionen nutzen, und kann von remote Aktualisierung anstoßen.“ Entschieden: `sites.kant-it.de`, ohne Lizenzschlüssel, Updates einzeln und für alle.
+
+**Meldung (CMS).** Neue Aufgabe `zentrale` (`App\Ops\Tasks\ZentraleTask`, alle 15 Minuten) ruft `App\Ops\Zentrale::melden()` auf: `POST https://sites.kant-it.de/api/melden` mit Kennung, Adresse (`SITE_ORIGIN`), Fassung, PHP-Version, Datenbankart, Git/Archiv, Wartungszustand und Updatestand. Keine Inhalte, keine Besucherdaten, keine Zugangsdaten. Kennung und Schlüssel (32 bzw. 64 Hexzeichen, zufällig) liegen in `var/zentrale.json` und bleiben bei Updates erhalten. Abschalten mit `ZENTRALE_URL=aus`; Installationen mit lokalem `SITE_ORIGIN` (localhost, 127.0.0.1, `*.test`, `*.localhost`, `*.invalid`) melden nie.
+
+**Echtheit ohne Lizenzschlüssel.** Beim ersten Kontakt schickt die Installation ihren Schlüssel über HTTPS mit (Vertrauen beim ersten Kontakt). Danach ist jede Meldung mit HMAC-SHA256 über den Rohtext unterschrieben (`X-KantSites-Signatur`), jede Antwort der Zentrale ebenso; die Installation verwirft Antworten ohne gültige Unterschrift. Eine bekannte Kennung mit fremdem Schlüssel weist die Zentrale ab (403). Kennt die Zentrale eine Kennung nicht mehr (409), meldet sich die Installation einmal mit Schlüssel neu an. Ein Auftrag kann nur „Update auf eine höhere Fassung der Form 1.2.3“ sein und läuft über `ArchiveUpdate` mit Prüfsumme der Releaseseite – mehr kann auch eine kompromittierte Zentrale nicht auslösen.
+
+**Pull statt Push.** Die Zentrale verbindet sich nie mit einer Website. Sie merkt sich den Auftrag; die Website holt ihn mit ihrer nächsten Meldung ab. Keine Installation braucht dafür eine von außen erreichbare Steuerschnittstelle, und es geht auch hinter Firewalls.
+
+**Update aus der Ferne.** `ZentraleTask` führt `ArchiveUpdate::run()` aus (Sicherung, Archiv, Prüfsumme, Dateitausch, Wartung an) und markiert den offenen zweiten Schritt mit `fern` (`ArchiveUpdate::markiereFern()`). Den zweiten Schritt erledigt die nächste Anfrage mit dem neuen Code: `RemoteUpdateFinishSubscriber` (kernel.request, Priorität 48, also vor der Wartungsseite) nimmt die Updatesperre, führt `finish()` mit der Funktionsprüfung aus und gibt die Website frei oder schaltet zurück. Damit das nicht auf den nächsten Besucher wartet, ruft die Aufgabe die eigene Startseite einmal auf (bis 300 s). Das Ergebnis geht mit der nächsten Meldung an die Zentrale und wird nach der Quittung aus `var/zentrale.json` gelöscht. Git-Arbeitskopien lehnen Aufträge ab. Die Funktionsprüfung nach den Migrationen ist dafür aus `SystemController` in `App\Ops\Funktionspruefung` gewandert; die Verwaltung nutzt denselben Dienst.
+
+**Zentrale.** Eigener Ordner `zentrale/` im Repository, nicht Teil des Releasearchivs (`scripts/build-release.php` nimmt nur die aufgezählten Einträge). Reines PHP ab 8.1 mit SQLite (`var/zentrale.db`), ohne Framework und Composer, damit sie per FTP auf jedes Hosting passt. Anmeldung mit `password_hash`, Sitzungscookie `__Host-` mit SameSite=Strict, CSRF-Token auf jedem Formular, fünf Fehlversuche je IP in 15 Minuten, strenge CSP ohne Skripte, `noindex`. Das erste Konto legt an, wer den `einrichtungscode` aus `config.php` kennt. Die Übersicht zeigt Domain, Kunde, Fassung, letzte Meldung und Auftragsstand, zählt aktuelle, veraltete, verstummte (über 48 h) und nicht zugeordnete Installationen und bietet „Auf x.y.z“ je Zeile und „Alle aktualisieren“ mit Bestätigung (ohne verstummte, wartende und Git-Installationen). Die neueste Fassung kommt von derselben Releaseseite wie bei den Installationen, 30 Minuten zwischengespeichert. Fremde Nutzung erkennt man an „Unbekannt“ (kein Kunde zugeordnet) und am Hinweis „vorher …“ bei einer Kennung, die sich unter neuer Domain meldet.
+
+**Grenzen.** Wer den Code verändert und die Meldung ausbaut, bleibt unsichtbar; ohne Lizenzschlüssel ist das kein Schutz, nur eine Übersicht. Installationen vor 1.36.0 erscheinen erst nach einem Update von Hand. Erreicht eine Website sich selbst nicht, steht die Wartungsseite bis zum nächsten Besuch oder Cron-Aufruf. Die Zentrale speichert die IP-Adresse der letzten Meldung; das gehört in die Datenschutzerklärung beziehungsweise Auftragsverarbeitung mit den Kunden.
+
+**Folgen.** Keine Migration im CMS: `var/zentrale.json` entsteht beim ersten Lauf, die Aufgabe trägt sich über ihr Etikett selbst in `scheduled_task` ein. Das Schema der Zentrale migriert sich über `PRAGMA user_version` (`zentrale/app/Datenbank.php`). Protokollprüfung ohne Netz: `php scripts/zentrale-check.php`; der Ablauf mit Dateitausch und Abschluss steht in `tests/ArchiveUpdateTest.php`.
 
 ## ADR 122 – E-Mail-Versand als eigene Seite, Probe nicht mehr unter /.well-known (12.10.2026)
 

docs/STATUS.md

@@ -1,5 +1,43 @@
 # Projektstatus
 
+## Symfony-Patchupdate, Release 1.36.1 (14.10.2026)
+
+**Anlass:** Monatlicher Sicherheitscheck (`reports/sicherheit-2026-10.md`, nicht in Git): keine Sicherheitslücken, aber Patch-Rückstand bei Symfony. Umut: „dann mach neueste symfony version dann kann ich den updater mal testen“.
+
+**Erledigt:** `composer update "symfony/*" --with-all-dependencies`: Symfony 7.4.15–7.4.18 → 7.4.19–7.4.21 (framework-bundle, http-kernel, security-*, twig-bundle, console, yaml u. a.), Polyfills 1.43.0, twig/twig 3.28 → 3.30, doctrine/lexer 3.0.3. Bewusst bei der LTS-Linie 7.4 geblieben (Sicherheitssupport bis 11/2029); 8.x wäre ein Major-Sprung mit PHP-8.4-Pflicht. `composer.json` unverändert, Plattform weiter PHP 8.2.12. Kein eigener Code geändert, keine Migration.
+
+**Geprüft:** `composer audit` ohne Befund. PHPUnit 685 Tests grün unter PHP 8.4 und 8.2; unter 8.2 eine Warnung in `UpdaterTest::testTrackedEnvironmentFromAnOlderTagCannotReplaceInstallationSettings` (`file_get_contents` auf eine von `git checkout` entfernte `.env`, `Updater.php:468`), die mit der alten `composer.lock` genauso auftritt – vorbestehend. php-cs-fixer ohne Befund, `npm test` 41/41, `test:editor` grün (erster Lauf hing einmal beim Warten auf „Veröffentlicht“, zweiter Lauf vollständig grün), `test:browser` gegen 8080 grün (zwei Kontrastbefunde aus im Editor gesetzten Farben auf `/grundlagen`, Inhalt, nicht Code).
+
+**Release:** Tag `v1.36.1`, Releaseeintrag mit Zip, `.sha256` und `install.php`; anonymer Download stimmt mit der Prüfsumme überein (fe286f49…), `releases/latest` meldet v1.36.1.
+
+**Nächster Schritt:** Umut testet den Updater: eine Installation auf 1.36.0 per „System“ oder über die Zentrale auf 1.36.1 heben. Weitere Punkte aus dem Sicherheitscheck: HSTS auf den Kundenseiten einschalten (System → HSTS), PHP-Mindestfassung vor dem 31.12.2026 (Ende PHP 8.2) anheben.
+
+## Zentrale: Suche, Filter und Seiten (14.10.2026)
+
+**Anlass:** Umut: „Kannst du Suche und Pagination dort einbauen bei Zentrale“.
+
+**Erledigt:** Übersicht in `zentrale/` mit Suche (Domain, frühere Domain, Kunde/Notiz, Fassung, IP), Zählerkacheln als Filter (mit Markierung und `aria-current`), Seiten zu je 25 Einträgen mit Zurück/Weiter und Auslassungen, Trefferzeile als Statusmeldung, eigener Leerzustand „Nichts gefunden“. Domains natürlich sortiert, „www.“ zählt nicht. „Alle aktualisieren“ nennt höchstens acht Domains und „und N weitere“. Kein Eingriff ins CMS, keine Schemaänderung.
+
+**Geprüft:** Lokal mit 63 Demo-Installationen im Browser: Seite 2 von 3, Suche + Filter kombiniert (8 Treffer), kein Treffer, Seitenzahl außerhalb des Bereichs wird begrenzt, 375 px ohne Querscrollen. `php scripts/zentrale-check.php` grün.
+
+**Nachtrag, gleicher Tag – Live-Suche:** Umut: „Suche sollte Ajax-Livesearch sein, nicht Enter-Suche“. `zentrale/public/app.js` lädt beim Tippen (250 ms Pause) nur die Liste nach (`/?…&teil=liste`, Vorlage `_liste.php`), ebenso bei Klick auf Kacheln und Seitenzahlen; Adresse per `history`, Zurück-Taste funktioniert, Trefferzeile bleibt Statusmeldung für Screenreader, abgelaufene Sitzung fällt auf normales Laden zurück. Der Suchen-Knopf verschwindet mit JavaScript. CSP erlaubt jetzt `script-src 'self'` und `connect-src 'self'`. Nebenbei behoben: `.knopf` überschrieb das `hidden`-Attribut. Geprüft im Browser mit 57 Demo-Installationen: Tippen ohne Neuladen, Filter + Suche, Zurücksetzen, Seite 2, Zurück-Taste, 375 px, keine Konsolenfehler. Die lokale Demo-Datenbank ist wieder gelöscht.
+
+**Nächster Schritt:** Umut lädt `zentrale/app/` und `zentrale/public/` neu hoch (Paket `var/zentrale-upload.zip`); `config.php` und `var/` auf dem Server bleiben unangetastet.
+
+## Zentrale sites.kant-it.de: Meldung und Update aus der Ferne (14.10.2026)
+
+**Anlass:** Umut: Alle KantSites sollen sich bei einer Hauptplattform melden; dort Domains und Fassungen sehen und Updates anstoßen. Entschieden: `sites.kant-it.de`, ohne Lizenzschlüssel, Updates einzeln und für alle; Umut lädt die Plattform selbst hoch.
+
+**Erledigt:** CMS: Aufgabe „Bei der Zentrale melden“ (`zentrale`, 15 min) mit `App\Ops\Zentrale` (HMAC-signierte Meldung, Schlüssel beim ersten Kontakt, Antwort wird geprüft), Auftrag „Update“ über `ArchiveUpdate`, Abschluss durch die nächste Anfrage (`RemoteUpdateFinishSubscriber`), Funktionsprüfung als Dienst `Funktionspruefung`. `ZENTRALE_URL` (Standard `https://sites.kant-it.de`, `aus` schaltet ab), lokale Adressen melden nie. Plattform in `zentrale/` (PHP 8.1+, SQLite, ohne Composer): Einrichten mit Code aus `config.php`, Anmeldung mit Sperre nach Fehlversuchen, Übersicht mit Zählern, „Unbekannt“ für Installationen ohne Kunde, Domainwechsel sichtbar, Update je Zeile und „Alle aktualisieren“ mit Bestätigung, Detailseite mit Stand, Kunde/Notiz, Auftragsverlauf, Zurückziehen und Entfernen. Anleitung: `zentrale/README.md`. ADR 123.
+
+**Geprüft:** PHPUnit `ArchiveUpdateTest` (16 Tests, darunter der ganze Fernablauf mit Dateitausch, Abschluss durch die Folgeanfrage und Ergebnis an die Zentrale; gefälschte Antwort; lokale Installationen melden nicht), `TaskScreenTest`, `SchedulerTest`, `SystemScreenTest` grün. `php scripts/zentrale-check.php`: 14/14 (CMS-Klasse gegen echte API: Anmeldung, Auftrag abholen, nicht doppelt, Ergebnis, 403 bei falscher Unterschrift und fremdem Schlüssel, Neuanmeldung, Domainwechsel). Plattform lokal im Browser (Port 8115, Demodaten): Einrichten, Anmelden, Übersicht mit echter neuester Fassung 1.35.1 von git.kant-it.de, Einzelauftrag, Zurückziehen, „Alle aktualisieren“, Detailseite, 375 px ohne Querscrollen, keine Konsolenfehler, CSP und Cookie-Flags. Nicht geprüft: echter Lauf über das Internet gegen sites.kant-it.de (gibt es noch nicht), Selbstaufruf auf einem echten Hosting, Lighthouse der Plattform (interne Seite, `noindex`). Volle PHPUnit-Kette: 685 Tests grün (ein Fund unterwegs: `zentrale` musste in die Ausschlussliste von `build-release.php`), php-cs-fixer ohne Befund.
+
+**Bekannte Lücken:** Installationen vor 1.36.0 melden sich erst nach einem Update von Hand. Ohne Lizenzschlüssel bleibt unsichtbar, wer die Meldung ausbaut. Die IP-Adresse der letzten Meldung wird gespeichert – Hinweis in Datenschutz/AV-Vertrag nötig. Lokal fehlt PHP 8.4 ein Zertifikatsspeicher; die Launch-Konfiguration `zentrale` setzt dafür `curl.cainfo` auf das Bündel von Git.
+
+**Release:** sites.kant-it.de ist online (Umut; `/api/melden` antwortet, `config.php` nicht abrufbar). Fassung 1.36.0 am 14.10.2026 veröffentlicht: Tag `v1.36.0`, Releaseeintrag mit Zip, `.sha256` und `install.php`; anonymer Download stimmt mit der Prüfsumme überein (688a0689…), `releases/latest` meldet v1.36.0.
+
+**Nächster Schritt:** kant-it.de und die übrigen Live-Installationen unter „System“ auf 1.36.0 heben, erste Meldung in der Zentrale prüfen, das erste Fern-Update mit der nächsten Fassung ausprobieren.
+
 ## Redesign-Entwurf EBI Immobilien, Karlsruhe (13.10.2026)
 
 **Anlass:** Umut: „einfacher Rebuild und Redesign von ebi-immobilien.de, soll vollendet aussehen, aber nicht übertrieben clean“.

docs/UPDATE.md

@@ -97,6 +97,10 @@ Der Weg für den einen Fall, in dem die Karte im Bildschirm „System" noch nich
 
 Das ist einmalig: Ab 1.4.3 kennt jede Installation den Weg über das Archiv, und dann entfällt das alles. Dann steht im selben Bildschirm die Karte „Update aus dem Releasearchiv", und die Schritte 2 bis 8 erledigt sie selbst.
 
+## Der vierte Weg: aus der Zentrale
+
+Ab 1.36.0 meldet sich jede Installation bei `sites.kant-it.de` und holt dort angestoßene Updates ab. Es läuft derselbe Archivweg wie über den Knopf: Sicherung, Archiv mit Prüfsumme, Dateitausch, Migrationen mit dem neuen Code, Prüfung der Startseite, sonst Zurückschalten. Den zweiten Schritt erledigt die nächste Anfrage an die Website; die Aufgabe ruft dafür die eigene Startseite einmal auf. Git-Arbeitskopien lehnen Aufträge ab. Einzelheiten: ADR 123, `zentrale/README.md`.
+
 ## Ein Release veröffentlichen
 
 `php scripts/build-release.php` baut auf einem Rechner mit Composer das Archiv – Anwendung plus `vendor/` ohne Entwicklungspakete – und schreibt die SHA-256-Summe in eine Kopie von `install.php`. Beides gehört anschließend an das Git-Release des passenden Tags:

scripts/build-release.php

@@ -68,7 +68,7 @@ echo "Fassung {$version}\n";
 // Einrichten keine Migrationsliste und bricht mit "configuration file does not exist" ab - genau
 // dort, wo eine frische Installation ihre Tabellen anlegen will.
 $include = ['bin', 'config', 'migrations', 'plugins', 'public', 'src', 'templates', 'composer.json', 'composer.lock', 'migrations.php', 'cli-config.php', 'VERSION', 'README.md', '.env.example', '.htaccess'];
-$skip = ['.git', '.github', '.claude', '.gitattributes', '.gitignore', '.env.lock', '.php-cs-fixer.cache', 'node_modules', 'var', 'tests', 'scripts', 'reports', 'phpunit.xml.dist', '.php-cs-fixer.dist.php', 'package.json', 'package-lock.json', 'AGENTS.md', 'ENTWICKLUNGSPLAN.md', 'docs', 'composer.phar', '.venv', 'vendor', 'phpunit.cache', 'migrations.php.bak'];
+$skip = ['.git', '.github', '.claude', '.gitattributes', '.gitignore', '.env.lock', '.php-cs-fixer.cache', 'node_modules', 'var', 'tests', 'scripts', 'reports', 'phpunit.xml.dist', '.php-cs-fixer.dist.php', 'package.json', 'package-lock.json', 'AGENTS.md', 'ENTWICKLUNGSPLAN.md', 'docs', 'composer.phar', '.venv', 'vendor', 'phpunit.cache', 'migrations.php.bak', 'zentrale'];
 
 $copy = static function (string $from, string $to) use (&$copy, $skip): int {
     $count = 0;

scripts/zentrale-check.php

@@ -0,0 +1,109 @@
+<?php
+
+/**
+ * Prüft, ob CMS und Zentrale dieselbe Sprache sprechen (ADR 123).
+ *
+ * Die Meldung kommt aus App\Ops\Zentrale, die Antwort aus Zentrale\Api - beide echt, nur ohne
+ * Netz dazwischen: Registrierung mit Schlüssel, unterschriebene Folgemeldung, Auftrag abholen,
+ * Ergebnis zurückmelden, fremde Unterschrift abweisen, zweite Installation mit fremder Kennung.
+ *
+ * Aufruf: php scripts/zentrale-check.php
+ */
+
+declare(strict_types=1);
+
+use App\Ops\ArchiveUpdate;
+use App\Ops\Backup;
+use App\Ops\CommandRunner;
+use App\Ops\Download;
+use App\Ops\Updater;
+use App\Ops\Zentrale as CmsZentrale;
+use Doctrine\DBAL\DriverManager;
+
+require dirname(__DIR__).'/vendor/autoload.php';
+spl_autoload_register(static function (string $klasse): void {
+    if (str_starts_with($klasse, 'Zentrale\\')) {
+        require dirname(__DIR__).'/zentrale/app/'.substr($klasse, 9).'.php';
+    }
+});
+
+$tmp = str_replace('\\', '/', sys_get_temp_dir()).'/zentrale-check-'.bin2hex(random_bytes(4));
+mkdir($tmp.'/site/var', 0o775, true);
+file_put_contents($tmp.'/site/VERSION', "1.35.1\n");
+$pdo = Zentrale\Datenbank::oeffnen($tmp.'/zentrale.db');
+$api = new Zentrale\Api($pdo);
+
+$fehler = 0;
+$pruefe = static function (bool $ok, string $was) use (&$fehler): void {
+    echo ($ok ? 'ok     ' : 'FEHLER ').$was."\n";
+    $fehler += $ok ? 0 : 1;
+};
+
+$ueberApi = static function (string $url, string $body, array $kopf) use ($api): array {
+    $antwort = $api->melden($body, $kopf['X-KantSites-Signatur'] ?? '', '203.0.113.7');
+
+    return ['status' => $antwort['status'], 'body' => $antwort['body'], 'signatur' => (string) $antwort['signatur']];
+};
+
+$installation = static function (string $wurzel, string $adresse, \Closure $senden): CmsZentrale {
+    $db = DriverManager::getConnection(['driver' => 'pdo_sqlite', 'memory' => true]);
+    $updater = new Updater($wurzel, 'sqlite:///:memory:', new CommandRunner(), $db);
+
+    return new CmsZentrale($wurzel, $updater, new ArchiveUpdate($wurzel, $updater, new Backup($wurzel, 'sqlite:///:memory:', $wurzel.'/var/media', $db, new CommandRunner()), new Download()), 'https://sites.example', $adresse, 'sqlite:///x', $senden);
+};
+
+$site = $installation($tmp.'/site', 'https://kunde-eins.de', $ueberApi);
+$erste = $site->melden();
+$pruefe(null === $erste['auftrag'], 'Erste Meldung wird angenommen, kein Auftrag');
+$zeile = $pdo->query('SELECT * FROM installation')->fetch();
+$pruefe('kunde-eins.de' === ($zeile['domain'] ?? null) && '1.35.1' === $zeile['fassung'], 'Domain und Fassung stehen in der Zentrale');
+$ich = json_decode((string) file_get_contents($tmp.'/site/var/zentrale.json'), true);
+$pruefe(true === $ich['registriert'], 'Installation gilt danach als angemeldet');
+
+$bestand = new Zentrale\Bestand($pdo);
+$pruefe(null === $bestand->beauftragen($zeile['id'], '1.36.0'), 'Update auf 1.36.0 lässt sich beauftragen');
+$zweite = $site->melden();
+$pruefe('1.36.0' === ($zweite['auftrag']['fassung'] ?? null) && 'update' === $zweite['auftrag']['aktion'], 'Folgemeldung holt den Auftrag ab');
+$pruefe(null === $site->melden()['auftrag'], 'Ein abgeholter Auftrag kommt nicht zweimal');
+$pruefe(null !== $bestand->beauftragen($zeile['id'], '1.36.0'), 'Während ein Auftrag läuft, gibt es keinen zweiten');
+
+$site->auftragAngenommen($zweite['auftrag']['id'], '1.36.0');
+file_put_contents($tmp.'/site/VERSION', "1.36.0\n");
+$site->auftragErledigt(true, 'Fassung 1.36.0 läuft.');
+$site->melden();
+$auftrag = $pdo->query('SELECT * FROM auftrag')->fetch();
+$pruefe(1 === (int) $auftrag['ok'] && null !== $auftrag['erledigt'], 'Ergebnis kommt in der Zentrale an');
+$pruefe('1.36.0' === $pdo->query('SELECT fassung FROM installation')->fetchColumn(), 'Neue Fassung ist gemeldet');
+$pruefe(null === $site->offenerAuftrag(), 'Die Installation vergisst den quittierten Auftrag');
+
+// Eine fremde Antwort: anderer Schlüssel unterschreibt.
+$gefaelscht = $installation($tmp.'/site', 'https://kunde-eins.de', static function (string $url, string $body) use ($ueberApi): array {
+    $echt = $ueberApi($url, $body, []);
+
+    return [...$echt, 'signatur' => hash_hmac('sha256', $echt['body'], str_repeat('b', 64))];
+});
+try {
+    $gefaelscht->melden();
+    $pruefe(false, 'Unsignierte Meldung wird abgewiesen');
+} catch (\RuntimeException $e) {
+    $pruefe(str_contains($e->getMessage(), '403'), 'Meldung ohne gültige Unterschrift weist die Zentrale mit 403 ab');
+}
+
+// Jemand übernimmt die Kennung mit eigenem Schlüssel.
+$body = json_encode(['id' => $zeile['id'], 'adresse' => 'https://fremd.de', 'fassung' => '1.36.0', 'schluessel' => str_repeat('c', 64)]);
+$fremd = $api->melden($body, hash_hmac('sha256', $body, str_repeat('c', 64)), '198.51.100.1');
+$pruefe(403 === $fremd['status'], 'Fremder Schlüssel für eine bekannte Kennung wird abgewiesen');
+
+// Die Zentrale hat die Installation vergessen: Sie meldet sich mit Schlüssel neu an.
+$pdo->exec('DELETE FROM installation');
+$site->melden();
+$pruefe(1 === (int) $pdo->query('SELECT COUNT(*) FROM installation')->fetchColumn(), 'Nach Verlust in der Zentrale meldet sich die Installation neu an');
+
+// Umzug: dieselbe Kennung, andere Domain.
+$umzug = $installation($tmp.'/site', 'https://www.kunde-zwei.de', $ueberApi);
+$umzug->melden();
+$neu = $pdo->query('SELECT domain, domain_vorher FROM installation')->fetch();
+$pruefe('www.kunde-zwei.de' === $neu['domain'] && 'kunde-eins.de' === $neu['domain_vorher'], 'Domainwechsel ist sichtbar');
+
+echo $fehler > 0 ? "\n{$fehler} Prüfung(en) fehlgeschlagen.\n" : "\nAlle Prüfungen bestanden.\n";
+exit($fehler > 0 ? 1 : 0);

src/Controller/SystemController.php

@@ -3,12 +3,11 @@
 namespace App\Controller;
 
 use App\Command\SiteOriginCommand;
-use App\Content\PageRepository;
-use App\Content\SiteSettings;
 use App\Domain\InvalidPage;
 use App\Ops\ArchiveUpdate;
 use App\Ops\Backup;
 use App\Ops\Environment;
+use App\Ops\Funktionspruefung;
 use App\Ops\HttpsRedirect;
 use App\Ops\Installation;
 use App\Ops\OriginCheck;
@@ -18,7 +17,6 @@ use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
 use Symfony\Component\HttpFoundation\JsonResponse;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\Response;
-use Symfony\Component\HttpKernel\HttpKernelInterface;
 use Symfony\Component\Routing\Attribute\Route;
 
 /**
@@ -30,7 +28,7 @@ use Symfony\Component\Routing\Attribute\Route;
  */
 final class SystemController extends AbstractController
 {
-    public function __construct(private Updater $updater, private Backup $backup, private ArchiveUpdate $archive, private Installation $installation, private string $adminPath, private string $databaseUrl, private string $mediaDirectory, private string $projectDir, private string $siteOrigin, private OriginCheck $originCheck, private HttpKernelInterface $kernel, private PageRepository $pages, private SiteSettings $settings, private SitePackage $packages, private HttpsRedirect $https)
+    public function __construct(private Updater $updater, private Backup $backup, private ArchiveUpdate $archive, private Installation $installation, private string $adminPath, private string $databaseUrl, private string $mediaDirectory, private string $projectDir, private string $siteOrigin, private OriginCheck $originCheck, private Funktionspruefung $pruefung, private SitePackage $packages, private HttpsRedirect $https)
     {
     }
 
@@ -272,28 +270,10 @@ final class SystemController extends AbstractController
             return new JsonResponse(['ok' => false, 'meldung' => 'Dieser Abschluss gehört zu keinem offenen Update.'], 403);
         }
         @set_time_limit(0);
-        $ergebnis = $this->archive->finish($this->installation, $this->pruefen(...));
+        $ergebnis = $this->archive->finish($this->installation, $this->pruefung);
         $this->sendJsonAndStop(['ok' => $ergebnis['ok'], 'status' => $this->archive->status()]);
     }
 
-    /**
-     * Läuft die neue Fassung wirklich? Datenbank, Startseite in der Datenbank und die Startseite
-     * als Seite - als Unteranfrage, die an der Wartungsseite vorbeigeht. null heißt: alles gut.
-     */
-    private function pruefen(): ?string
-    {
-        $home = $this->settings->homePath();
-        if (null === $this->pages->findPublished($home)) {
-            return sprintf('Die Startseite /%s ist nicht lesbar.', $home);
-        }
-        $antwort = $this->kernel->handle(Request::create('/'), HttpKernelInterface::SUB_REQUEST, false);
-        if ($antwort->getStatusCode() >= 400) {
-            return sprintf('Die Startseite antwortet mit %d.', $antwort->getStatusCode());
-        }
-
-        return null;
-    }
-
     /** Wie sendAndStop, nur als JSON für die Systemseite. */
     private function sendJsonAndStop(array $daten): never
     {

src/EventSubscriber/RemoteUpdateFinishSubscriber.php

@@ -0,0 +1,73 @@
+<?php
+
+namespace App\EventSubscriber;
+
+use App\Ops\ArchiveUpdate;
+use App\Ops\Funktionspruefung;
+use App\Ops\Installation;
+use App\Ops\Updater;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\HttpKernel\Event\RequestEvent;
+use Symfony\Component\HttpKernel\KernelEvents;
+
+/**
+ * Schließt ein Update ab, das die Zentrale angestoßen hat (ADR 123).
+ *
+ * Aus der Verwaltung ruft die Systemseite den zweiten Schritt selbst auf. Bei einem Auftrag der
+ * Zentrale sitzt niemand davor. Dann übernimmt die nächste Anfrage: Sie startet mit dem neuen
+ * Code - genau das, was die Migrationen brauchen -, führt sie aus, prüft die Startseite und gibt
+ * die Website frei oder schaltet zurück. Der Besucher, der sie auslöst, wartet so lange und
+ * bekommt danach die Seite in der neuen Fassung.
+ *
+ * Vor der Wartungsseite (Priorität 40), weil die sonst jede Anfrage mit 503 beendet. Nur bei
+ * einer Marke mit `fern`: Ein Update aus der Verwaltung schließt die Verwaltung ab.
+ *
+ * Der Prozess, der die Dateien getauscht hat, kommt hier nicht mehr vorbei: Seine Anfrage ist zu
+ * dem Zeitpunkt längst über diesen Punkt hinaus.
+ */
+final class RemoteUpdateFinishSubscriber implements EventSubscriberInterface
+{
+    public function __construct(
+        private ArchiveUpdate $archive,
+        private Installation $installation,
+        private Updater $updater,
+        private Funktionspruefung $pruefung,
+        private string $projectDir,
+    ) {
+    }
+
+    public static function getSubscribedEvents(): array
+    {
+        return [KernelEvents::REQUEST => ['onRequest', 48]];
+    }
+
+    public function onRequest(RequestEvent $event): void
+    {
+        // Der übliche Fall kostet eine Dateiprüfung.
+        if (!$event->isMainRequest() || !is_file($this->projectDir.'/'.ArchiveUpdate::MARKE)) {
+            return;
+        }
+        $offen = $this->archive->pending();
+        if (true !== ($offen['fern'] ?? null)) {
+            return;
+        }
+        // Gleichzeitige Anfragen: Eine schließt ab, die anderen sehen die Wartungsseite.
+        $sperre = $this->updater->lock();
+        if (null === $sperre) {
+            return;
+        }
+        try {
+            if (true !== ($this->archive->pending()['fern'] ?? null)) {
+                return;
+            }
+            @ignore_user_abort(true);
+            @set_time_limit(0);
+            $this->archive->finish($this->installation, $this->pruefung);
+        } catch (\Throwable) {
+            // Was schiefging, steht im Updateprotokoll; die Wartungsseite bleibt dann an.
+        } finally {
+            flock($sperre, LOCK_UN);
+            fclose($sperre);
+        }
+    }
+}

src/Ops/ArchiveUpdate.php

@@ -315,6 +315,21 @@ final class ArchiveUpdate
         return ['ok' => true, 'steps' => $schritte, 'migrate' => true, 'token' => $token, 'fassung' => $ziel];
     }
 
+    /**
+     * Kennzeichnet den offenen zweiten Schritt als von der Zentrale angestoßen (ADR 123).
+     *
+     * Dann wartet niemand in der Verwaltung, der ihn aufruft; die nächste Anfrage mit dem neuen
+     * Code schließt ihn ab (@see RemoteUpdateFinishSubscriber).
+     */
+    public function markiereFern(): void
+    {
+        $offen = $this->pending();
+        if (null === $offen) {
+            return;
+        }
+        @file_put_contents($this->root.'/'.self::MARKE, json_encode([...$offen, 'fern' => true], JSON_UNESCAPED_SLASHES));
+    }
+
     /**
      * Steht ein zweiter Schritt aus? Gibt Fassung und Zeitpunkt zurück, sonst null.
      *

src/Ops/Funktionspruefung.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Ops;
+
+use App\Content\PageRepository;
+use App\Content\SiteSettings;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+
+/**
+ * Läuft die neue Fassung wirklich? Datenbank, Startseite in der Datenbank und die Startseite als
+ * Seite - als Unteranfrage, die an der Wartungsseite vorbeigeht.
+ *
+ * Der Abschluss eines Updates ruft sie nach den Migrationen auf, aus der Verwaltung und nach
+ * einem Auftrag der Zentrale. Sie braucht eine laufende Hauptanfrage: Die Unteranfrage hängt sich
+ * an deren Request-Stack.
+ */
+class Funktionspruefung
+{
+    public function __construct(private PageRepository $pages, private SiteSettings $settings, private HttpKernelInterface $kernel)
+    {
+    }
+
+    /** null heißt: alles gut. Sonst der Grund, warum die Fassung nicht läuft. */
+    public function __invoke(): ?string
+    {
+        $home = $this->settings->homePath();
+        if (null === $this->pages->findPublished($home)) {
+            return sprintf('Die Startseite /%s ist nicht lesbar.', $home);
+        }
+        $antwort = $this->kernel->handle(Request::create('/'), HttpKernelInterface::SUB_REQUEST, false);
+        if ($antwort->getStatusCode() >= 400) {
+            return sprintf('Die Startseite antwortet mit %d.', $antwort->getStatusCode());
+        }
+
+        return null;
+    }
+}

src/Ops/Tasks/ZentraleTask.php

@@ -0,0 +1,173 @@
+<?php
+
+namespace App\Ops\Tasks;
+
+use App\Ops\ArchiveUpdate;
+use App\Ops\Updater;
+use App\Ops\Zentrale;
+
+/**
+ * Meldet sich bei der Zentrale und führt einen dort angestoßenen Auftrag aus (ADR 123).
+ *
+ * Der einzige Auftrag ist „Update auf Fassung X“. Er läuft über denselben Weg wie der Knopf in
+ * der Verwaltung: Sicherung, Archiv mit Prüfsumme, Dateien tauschen. Den zweiten Schritt - die
+ * Migrationen mit dem neuen Code - erledigt die nächste Anfrage (@see RemoteUpdateFinishSubscriber);
+ * diese Aufgabe stößt sie gleich selbst an, damit die Wartungsseite nicht bis zum nächsten
+ * Besucher stehen bleibt.
+ */
+final class ZentraleTask implements Task
+{
+    /** Zeitgrenze für den Anstoß des zweiten Schritts; die Migrationen laufen in dieser Anfrage. */
+    private const ABSCHLUSS_SEKUNDEN = 300;
+
+    /** @param (\Closure(string): void)|null $anstossen ruft die Website einmal auf; Tests setzen ihn */
+    public function __construct(
+        private Zentrale $zentrale,
+        private ArchiveUpdate $archive,
+        private Updater $updater,
+        private string $siteOrigin,
+        private string $projectDir,
+        private ?\Closure $anstossen = null,
+    ) {
+    }
+
+    public function name(): string
+    {
+        return 'zentrale';
+    }
+
+    public function label(): string
+    {
+        return 'Bei der Zentrale melden';
+    }
+
+    public function explanation(): string
+    {
+        return 'Meldet Adresse und Fassung an sites.kant-it.de und holt dort angestoßene Updates ab. Ohne sie fehlt die Website in der Übersicht, und ein Update aus der Ferne kommt nicht an.';
+    }
+
+    public function interval(): int
+    {
+        return 900;
+    }
+
+    public function run(): string
+    {
+        $grund = $this->zentrale->grundInaktiv();
+        if (null !== $grund) {
+            return $grund;
+        }
+        $this->ergebnisNachtragen();
+        $antwort = $this->zentrale->melden();
+        $auftrag = $antwort['auftrag'];
+        if (null === $auftrag) {
+            return sprintf('Gemeldet: Fassung %s.', $this->updater->version());
+        }
+
+        return $this->ausfuehren($auftrag['id'], $auftrag['aktion'], $auftrag['fassung']);
+    }
+
+    /**
+     * Ein Auftrag, dessen zweiter Schritt in einer anderen Anfrage lief: Was ist daraus geworden?
+     * Steht nichts mehr aus, verrät es der Fortschritt des Updates.
+     */
+    private function ergebnisNachtragen(): void
+    {
+        $auftrag = $this->zentrale->offenerAuftrag();
+        if (null === $auftrag || array_key_exists('ok', $auftrag) || null !== $this->archive->pending()) {
+            return;
+        }
+        $status = $this->archive->status() ?? [];
+        if ($status['laeuft'] ?? false) {
+            return;
+        }
+        $phase = (string) ($status['phase'] ?? '');
+        $fassung = (string) ($auftrag['fassung'] ?? '');
+        $ok = 'fertig' === $phase || version_compare($this->updater->version(), $fassung, '>=');
+        $this->zentrale->auftragErledigt($ok, (string) ($status['meldung'] ?? ($ok ? 'Fassung '.$this->updater->version().' läuft.' : 'Ohne Ergebnis beendet.')));
+    }
+
+    private function ausfuehren(int $id, string $aktion, string $fassung): string
+    {
+        $this->zentrale->auftragAngenommen($id, $fassung);
+        $ablehnen = function (string $grund): string {
+            $this->zentrale->auftragErledigt(false, $grund);
+            $this->zentrale->melden();
+
+            return 'Auftrag abgelehnt: '.$grund;
+        };
+        if ('update' !== $aktion) {
+            return $ablehnen(sprintf('Unbekannter Auftrag „%s“.', $aktion));
+        }
+        if (1 !== preg_match('/^\d{1,4}\.\d{1,5}\.\d{1,6}$/D', $fassung)) {
+            return $ablehnen('Die Fassung hat nicht die Form 1.2.3.');
+        }
+        if (version_compare($fassung, $this->updater->version(), '<=')) {
+            $this->zentrale->auftragErledigt(true, sprintf('Bereits auf Fassung %s.', $this->updater->version()));
+            $this->zentrale->melden();
+
+            return 'Auftrag erledigt: Diese Installation ist schon auf dem Stand.';
+        }
+        if (is_dir($this->projectDir.'/.git')) {
+            return $ablehnen('Diese Installation ist eine Git-Arbeitskopie; sie wird über Git aktualisiert, nicht aus der Ferne.');
+        }
+        if (null !== $this->archive->pending() || is_file($this->projectDir.'/'.Updater::MAINTENANCE_FILE)) {
+            return $ablehnen('Hier läuft gerade ein Update oder die Wartungsseite ist an.');
+        }
+
+        // Ein Update dauert länger als eine gewöhnliche Aufgabe. Die Antwort an den Besucher ist
+        // da schon unterwegs; abbrechen darf der Lauf jetzt nicht mehr.
+        @ignore_user_abort(true);
+        @set_time_limit(0);
+        $ergebnis = $this->archive->run($fassung);
+        if (!($ergebnis['migrate'] ?? false)) {
+            $letzter = end($ergebnis['steps']) ?: ['detail' => ''];
+            $this->zentrale->auftragErledigt($ergebnis['ok'], (string) $letzter['detail']);
+            $this->zentrale->melden();
+
+            return ($ergebnis['ok'] ? 'Auftrag erledigt: ' : 'Update gescheitert: ').$letzter['detail'];
+        }
+
+        // Die neuen Dateien liegen; die Migrationen gehören in eine Anfrage mit dem neuen Code.
+        $this->archive->markiereFern();
+        $this->anstossen();
+        $this->ergebnisNachtragen();
+        try {
+            $this->zentrale->melden();
+        } catch (\Throwable) {
+            // Das Ergebnis bleibt in var/zentrale.json und geht mit der nächsten Meldung raus.
+        }
+
+        return null === $this->archive->pending()
+            ? sprintf('Update auf %s aus der Ferne ausgeführt.', $fassung)
+            : sprintf('Dateien für %s getauscht; die Migrationen laufen mit der nächsten Anfrage.', $fassung);
+    }
+
+    /** Ruft die Website einmal auf. Gelingt das nicht, schließt der nächste Besucher ab. */
+    private function anstossen(): void
+    {
+        $adresse = rtrim($this->siteOrigin, '/').'/';
+        if (null !== $this->anstossen) {
+            ($this->anstossen)($adresse);
+
+            return;
+        }
+        if (function_exists('curl_init')) {
+            $curl = curl_init($adresse);
+            curl_setopt_array($curl, [
+                CURLOPT_RETURNTRANSFER => true,
+                CURLOPT_FOLLOWLOCATION => true,
+                CURLOPT_MAXREDIRS => 2,
+                CURLOPT_CONNECTTIMEOUT => 10,
+                CURLOPT_TIMEOUT => self::ABSCHLUSS_SEKUNDEN,
+                CURLOPT_USERAGENT => 'KantSites-Abschluss',
+            ]);
+            curl_exec($curl);
+            curl_close($curl);
+
+            return;
+        }
+        $kontext = stream_context_create(['http' => ['timeout' => self::ABSCHLUSS_SEKUNDEN, 'ignore_errors' => true, 'header' => "User-Agent: KantSites-Abschluss\r\n"]]);
+        @file_get_contents($adresse, false, $kontext);
+    }
+}

src/Ops/Zentrale.php

@@ -0,0 +1,287 @@
+<?php
+
+namespace App\Ops;
+
+/**
+ * Die Meldung an die Zentrale (ADR 123): welche Domain, welche Fassung - und ob ein Auftrag wartet.
+ *
+ * Jede Installation meldet sich regelmäßig bei sites.kant-it.de. Dort steht die Liste aller
+ * Installationen; dort lässt sich ein Update anstoßen. Die Zentrale verbindet sich nie selbst mit
+ * einer Website: Sie merkt sich den Auftrag, und die Website holt ihn mit der nächsten Meldung ab.
+ * Damit braucht keine Installation eine Tür, die sich von außen öffnen lässt.
+ *
+ * Was gemeldet wird, steht in payload(): Adresse, Fassung, PHP, Datenbankart, Updatestand. Keine
+ * Inhalte, keine Besucher, keine Zugangsdaten.
+ *
+ * Die Echtheit: Beim ersten Kontakt schickt die Installation einen zufälligen Schlüssel mit (über
+ * HTTPS). Danach trägt jede Meldung eine HMAC-Unterschrift damit, und jede Antwort der Zentrale
+ * ebenso. Wer die Kennung einer Installation kennt, kann ohne den Schlüssel weder für sie melden
+ * noch ihr einen Auftrag unterschieben. Ein Auftrag kann ohnehin nur eine veröffentlichte Fassung
+ * mit passender Prüfsumme einspielen (@see ArchiveUpdate).
+ */
+class Zentrale
+{
+    /** Kennung, Schlüssel und offener Auftrag dieser Installation. Bleibt bei Updates erhalten. */
+    public const DATEI = 'var/zentrale.json';
+
+    private const PFAD = '/api/melden';
+
+    /** @var (\Closure(string, string, array<string, string>): array{status: int, body: string, signatur: string})|null */
+    private ?\Closure $senden;
+
+    public function __construct(
+        private string $root,
+        private Updater $updater,
+        private ArchiveUpdate $archive,
+        private string $url,
+        private string $siteOrigin,
+        private string $databaseUrl,
+        ?\Closure $senden = null,
+    ) {
+        $this->senden = $senden;
+    }
+
+    /**
+     * Meldet diese Installation? Nein, wenn die Zentrale abgeschaltet ist (ZENTRALE_URL=aus) oder
+     * die Website nur auf diesem Rechner läuft - Entwicklungs- und Messinstallationen gehören
+     * nicht in die Liste.
+     */
+    public function aktiv(): bool
+    {
+        return null === $this->grundInaktiv();
+    }
+
+    public function grundInaktiv(): ?string
+    {
+        if (!str_starts_with($this->url, 'https://')) {
+            return 'Abgeschaltet (ZENTRALE_URL ist nicht gesetzt oder keine HTTPS-Adresse).';
+        }
+        $host = strtolower((string) parse_url($this->siteOrigin, PHP_URL_HOST));
+        if ('' === $host || in_array($host, ['localhost', '127.0.0.1', '[::1]', '::1'], true) || str_ends_with($host, '.localhost') || str_ends_with($host, '.test') || str_ends_with($host, '.invalid')) {
+            return sprintf('Keine Meldung: Die Website läuft lokal (%s).', '' === $host ? 'ohne SITE_ORIGIN' : $host);
+        }
+
+        return null;
+    }
+
+    /**
+     * Schickt die Meldung und gibt den Auftrag zurück, falls einer wartet.
+     *
+     * @return array{auftrag: ?array{id: int, aktion: string, fassung: string}, registriert: bool}
+     *
+     * @throws \RuntimeException wenn die Zentrale nicht oder nicht echt antwortet
+     */
+    public function melden(): array
+    {
+        $ich = $this->identitaet();
+        $erneut = false;
+        while (true) {
+            $daten = $this->payload($ich);
+            $body = json_encode($daten, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_THROW_ON_ERROR);
+            $antwort = $this->post(rtrim($this->url, '/').self::PFAD, $body, [
+                'Content-Type' => 'application/json',
+                'X-KantSites-Signatur' => hash_hmac('sha256', $body, $ich['schluessel']),
+            ]);
+            // Die Zentrale kennt diese Kennung nicht (mehr) - etwa nach einem Neuaufsetzen dort.
+            // Dann einmal mit Schlüssel neu anmelden.
+            if (409 === $antwort['status'] && !$erneut) {
+                $ich['registriert'] = false;
+                $erneut = true;
+                continue;
+            }
+            break;
+        }
+        if (200 !== $antwort['status']) {
+            throw new \RuntimeException(sprintf('Die Zentrale antwortet mit %d. %s', $antwort['status'], $this->fehlertext($antwort['body'])));
+        }
+        if (!hash_equals(hash_hmac('sha256', $antwort['body'], $ich['schluessel']), $antwort['signatur'])) {
+            throw new \RuntimeException('Die Antwort der Zentrale trägt keine gültige Unterschrift und wird verworfen.');
+        }
+        $inhalt = json_decode($antwort['body'], true);
+        if (!is_array($inhalt) || true !== ($inhalt['ok'] ?? null)) {
+            throw new \RuntimeException('Die Antwort der Zentrale ist unverständlich.');
+        }
+
+        $ich['registriert'] = true;
+        $ich['gemeldet'] = gmdate('c');
+        // Ein gemeldetes Ergebnis ist angekommen; der Auftrag ist damit erledigt.
+        if (isset($daten['auftrag']['ok'])) {
+            unset($ich['auftrag']);
+        }
+        $this->speichern($ich);
+
+        $auftrag = $inhalt['auftrag'] ?? null;
+        if (!is_array($auftrag) || !is_int($auftrag['id'] ?? null) || !is_string($auftrag['aktion'] ?? null) || !is_string($auftrag['fassung'] ?? null)) {
+            $auftrag = null;
+        }
+
+        return ['auftrag' => null === $auftrag ? null : ['id' => $auftrag['id'], 'aktion' => $auftrag['aktion'], 'fassung' => $auftrag['fassung']], 'registriert' => true];
+    }
+
+    /** Merkt sich einen angenommenen Auftrag, bis sein Ergebnis gemeldet ist. */
+    public function auftragAngenommen(int $id, string $fassung): void
+    {
+        $ich = $this->identitaet();
+        $ich['auftrag'] = ['id' => $id, 'fassung' => $fassung, 'seit' => gmdate('c')];
+        $this->speichern($ich);
+    }
+
+    /** Hält das Ergebnis eines Auftrags fest; die nächste Meldung trägt es zur Zentrale. */
+    public function auftragErledigt(bool $ok, string $meldung): void
+    {
+        $ich = $this->identitaet();
+        if (!isset($ich['auftrag'])) {
+            return;
+        }
+        $ich['auftrag']['ok'] = $ok;
+        $ich['auftrag']['meldung'] = mb_substr($meldung, 0, 500);
+        $this->speichern($ich);
+    }
+
+    /** @return array{id?: int, fassung?: string, seit?: string, ok?: bool, meldung?: string}|null */
+    public function offenerAuftrag(): ?array
+    {
+        return $this->identitaet()['auftrag'] ?? null;
+    }
+
+    /**
+     * Was gemeldet wird.
+     *
+     * @param array<string, mixed> $ich
+     *
+     * @return array<string, mixed>
+     */
+    private function payload(array $ich): array
+    {
+        $status = $this->archive->status();
+        $daten = [
+            'id' => $ich['id'],
+            'adresse' => rtrim($this->siteOrigin, '/'),
+            'fassung' => $this->updater->version(),
+            'php' => PHP_VERSION,
+            'datenbank' => strtolower((string) strtok($this->databaseUrl, ':')),
+            // Über Git aktualisierte Installationen nimmt die Zentrale nicht in Auftrag.
+            'art' => is_dir($this->root.'/.git') ? 'git' : 'archiv',
+            'wartung' => is_file($this->root.'/'.Updater::MAINTENANCE_FILE),
+            'update' => null === $status ? null : [
+                'phase' => (string) ($status['phase'] ?? ''),
+                'meldung' => mb_substr((string) ($status['meldung'] ?? ''), 0, 300),
+                'zeit' => (string) ($status['aktualisiert'] ?? ''),
+            ],
+        ];
+        if (!($ich['registriert'] ?? false)) {
+            $daten['schluessel'] = $ich['schluessel'];
+        }
+        $auftrag = $ich['auftrag'] ?? null;
+        if (is_array($auftrag)) {
+            $daten['auftrag'] = array_key_exists('ok', $auftrag)
+                ? ['id' => $auftrag['id'], 'ok' => $auftrag['ok'], 'meldung' => $auftrag['meldung'] ?? '']
+                : ['id' => $auftrag['id']];
+        }
+
+        return $daten;
+    }
+
+    /** @return array<string, mixed> */
+    private function identitaet(): array
+    {
+        $daten = json_decode((string) @file_get_contents($this->root.'/'.self::DATEI), true);
+        if (is_array($daten) && is_string($daten['id'] ?? null) && is_string($daten['schluessel'] ?? null)) {
+            return $daten;
+        }
+        $daten = ['id' => bin2hex(random_bytes(16)), 'schluessel' => bin2hex(random_bytes(32)), 'registriert' => false];
+        $this->speichern($daten);
+
+        return $daten;
+    }
+
+    /** @param array<string, mixed> $daten */
+    private function speichern(array $daten): void
+    {
+        $datei = $this->root.'/'.self::DATEI;
+        @mkdir(dirname($datei), 0o775, true);
+        $zwischen = $datei.'.'.bin2hex(random_bytes(4)).'.tmp';
+        if (false === @file_put_contents($zwischen, json_encode($daten, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_PRETTY_PRINT)) || !@rename($zwischen, $datei)) {
+            @unlink($zwischen);
+            throw new \RuntimeException(self::DATEI.' ist nicht schreibbar.');
+        }
+    }
+
+    private function fehlertext(string $body): string
+    {
+        $daten = json_decode($body, true);
+
+        return is_array($daten) && is_string($daten['fehler'] ?? null) ? mb_substr($daten['fehler'], 0, 200) : '';
+    }
+
+    /**
+     * POST über HTTPS, ohne Weiterleitungen: Eine Meldung, die woanders hin umgelenkt wird, soll
+     * scheitern und nicht ankommen.
+     *
+     * @param array<string, string> $kopf
+     *
+     * @return array{status: int, body: string, signatur: string}
+     */
+    private function post(string $url, string $body, array $kopf): array
+    {
+        if (null !== $this->senden) {
+            return ($this->senden)($url, $body, $kopf);
+        }
+        $zeilen = ['User-Agent: KantSites/'.$this->updater->version()];
+        foreach ($kopf as $name => $wert) {
+            $zeilen[] = $name.': '.$wert;
+        }
+        $signatur = '';
+        if (function_exists('curl_init')) {
+            $curl = curl_init($url);
+            curl_setopt_array($curl, [
+                CURLOPT_POST => true,
+                CURLOPT_POSTFIELDS => $body,
+                CURLOPT_HTTPHEADER => $zeilen,
+                CURLOPT_RETURNTRANSFER => true,
+                CURLOPT_FOLLOWLOCATION => false,
+                CURLOPT_PROTOCOLS => CURLPROTO_HTTPS,
+                CURLOPT_SSL_VERIFYPEER => true,
+                CURLOPT_SSL_VERIFYHOST => 2,
+                CURLOPT_CONNECTTIMEOUT => 10,
+                CURLOPT_TIMEOUT => 20,
+                CURLOPT_HEADERFUNCTION => static function ($curl, string $zeile) use (&$signatur): int {
+                    if (1 === preg_match('/^X-KantSites-Signatur:\s*([a-f0-9]{64})\s*$/i', $zeile, $treffer)) {
+                        $signatur = strtolower($treffer[1]);
+                    }
+
+                    return strlen($zeile);
+                },
+            ]);
+            $antwort = curl_exec($curl);
+            $status = (int) curl_getinfo($curl, CURLINFO_RESPONSE_CODE);
+            $fehler = curl_error($curl);
+            curl_close($curl);
+            if (!is_string($antwort)) {
+                throw new \RuntimeException('Die Zentrale ist nicht erreichbar: '.$fehler);
+            }
+
+            return ['status' => $status, 'body' => $antwort, 'signatur' => $signatur];
+        }
+        if (!filter_var(ini_get('allow_url_fopen'), FILTER_VALIDATE_BOOL)) {
+            throw new \RuntimeException('Dieser Server darf keine Adressen abrufen: curl fehlt und allow_url_fopen ist abgeschaltet.');
+        }
+        $kontext = stream_context_create([
+            'http' => ['method' => 'POST', 'header' => implode("\r\n", $zeilen), 'content' => $body, 'timeout' => 20, 'follow_location' => 0, 'ignore_errors' => true],
+            'ssl' => ['verify_peer' => true, 'verify_peer_name' => true],
+        ]);
+        $antwort = @file_get_contents($url, false, $kontext);
+        $kopfzeilen = $http_response_header ?? [];
+        if (!is_string($antwort) || [] === $kopfzeilen) {
+            throw new \RuntimeException('Die Zentrale ist nicht erreichbar.');
+        }
+        preg_match('/^HTTP\/\S+\s+(\d{3})/', (string) $kopfzeilen[0], $treffer);
+        foreach ($kopfzeilen as $zeile) {
+            if (1 === preg_match('/^X-KantSites-Signatur:\s*([a-f0-9]{64})\s*$/i', $zeile, $s)) {
+                $signatur = strtolower($s[1]);
+            }
+        }
+
+        return ['status' => (int) ($treffer[1] ?? 0), 'body' => $antwort, 'signatur' => $signatur];
+    }
+}

tests/ArchiveUpdateTest.php

@@ -8,16 +8,23 @@ use App\Content\MenuRepository;
 use App\Content\PageRepository;
 use App\Content\PartialRepository;
 use App\Content\SiteSettings;
+use App\EventSubscriber\RemoteUpdateFinishSubscriber;
 use App\Infrastructure\ConnectionFactory;
 use App\Ops\ArchiveUpdate;
 use App\Ops\Backup;
 use App\Ops\CommandRunner;
 use App\Ops\Download;
+use App\Ops\Funktionspruefung;
 use App\Ops\Installation;
+use App\Ops\Tasks\ZentraleTask;
 use App\Ops\Updater;
+use App\Ops\Zentrale;
 use App\Security\CmsUser;
 use Doctrine\DBAL\Connection;
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Event\RequestEvent;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
 use Symfony\Component\PasswordHasher\Hasher\PasswordHasherFactory;
 use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasher;
 
@@ -337,6 +344,111 @@ final class ArchiveUpdateTest extends TestCase
         self::assertStringContainsString('Zurückgeschaltet auf 1.0.0', $status['meldung']);
     }
 
+    public function testARemoteOrderUpdatesTheSiteAndTheNextRequestFinishesIt(): void
+    {
+        // ADR 123: Die Zentrale merkt sich „Update auf 1.1.0“, die Website holt es mit ihrer
+        // Meldung ab, tauscht die Dateien, und die nächste Anfrage führt die Migrationen aus.
+        $this->releases->release(self::BASE, self::API, '1.1.0', $this->archive('1.1.0'));
+        $server = $this->zentraleServer(['id' => 7, 'aktion' => 'update', 'fassung' => '1.1.0']);
+        $zentrale = $this->zentrale($server['senden']);
+        $task = new ZentraleTask($zentrale, $this->updater(), new Updater($this->root, 'sqlite:///'.$this->root.'/var/cms.db', new CommandRunner(), $this->db), 'https://kunde.example.de', $this->root, function (string $adresse): void {
+            self::assertSame('https://kunde.example.de/', $adresse);
+            $this->naechsteAnfrage();
+        });
+
+        $meldung = $task->run();
+
+        self::assertSame('1.1.0', trim((string) file_get_contents($this->root.'/VERSION')), $meldung);
+        self::assertFileDoesNotExist($this->root.'/'.Updater::MAINTENANCE_FILE, 'Die nächste Anfrage hat abgeschlossen und die Website freigegeben.');
+        self::assertNull($this->updater()->pending());
+        $meldungen = $server['meldungen']();
+        self::assertArrayHasKey('schluessel', $meldungen[0], 'Beim ersten Kontakt geht der Schlüssel mit.');
+        self::assertArrayNotHasKey('schluessel', $meldungen[1], 'Danach nur noch die Unterschrift.');
+        self::assertSame('1.0.0', $meldungen[0]['fassung']);
+        $letzte = end($meldungen);
+        self::assertSame('1.1.0', $letzte['fassung']);
+        self::assertSame(['id' => 7, 'ok' => true], array_intersect_key($letzte['auftrag'] ?? [], ['id' => 1, 'ok' => 1]), 'Das Ergebnis geht an die Zentrale zurück.');
+        self::assertNull($zentrale->offenerAuftrag(), 'Nach der Quittung ist der Auftrag erledigt.');
+    }
+
+    public function testAnAnswerWithoutAValidSignatureChangesNothing(): void
+    {
+        $this->releases->release(self::BASE, self::API, '1.1.0', $this->archive('1.1.0'));
+        $zentrale = $this->zentrale(static fn (): array => [
+            'status' => 200,
+            'body' => '{"ok":true,"auftrag":{"id":1,"aktion":"update","fassung":"1.1.0"}}',
+            'signatur' => str_repeat('0', 64),
+        ]);
+
+        try {
+            $zentrale->melden();
+            self::fail('Eine Antwort ohne gültige Unterschrift wurde angenommen.');
+        } catch (\RuntimeException $fehler) {
+            self::assertStringContainsString('Unterschrift', $fehler->getMessage());
+        }
+        self::assertSame('1.0.0', trim((string) file_get_contents($this->root.'/VERSION')));
+    }
+
+    public function testALocalInstallationDoesNotReport(): void
+    {
+        $gesendet = false;
+        $senden = static function () use (&$gesendet): array {
+            $gesendet = true;
+
+            return ['status' => 500, 'body' => '', 'signatur' => ''];
+        };
+        foreach (['http://127.0.0.1:8106', 'http://localhost', 'https://kunde.test'] as $adresse) {
+            $zentrale = new Zentrale($this->root, new Updater($this->root, 'sqlite:///x', new CommandRunner(), $this->db), $this->updater(), 'https://sites.example.invalid', $adresse, 'sqlite:///x', $senden);
+            self::assertFalse($zentrale->aktiv(), $adresse);
+        }
+        self::assertFalse($this->zentrale(null, 'aus')->aktiv(), 'ZENTRALE_URL=aus schaltet ab.');
+        self::assertFalse($gesendet);
+    }
+
+    /** Die Anfrage nach dem Tausch: startet mit dem neuen Code und schließt ab. */
+    private function naechsteAnfrage(): void
+    {
+        $pruefung = $this->createStub(Funktionspruefung::class);
+        $pruefung->method('__invoke')->willReturn(null);
+        $runner = new CommandRunner();
+        $subscriber = new RemoteUpdateFinishSubscriber($this->updater(), $this->installation(), new Updater($this->root, 'sqlite:///'.$this->root.'/var/cms.db', $runner, $this->db), $pruefung, $this->root);
+        $subscriber->onRequest(new RequestEvent($this->createStub(HttpKernelInterface::class), Request::create('/'), HttpKernelInterface::MAIN_REQUEST));
+    }
+
+    private function zentrale(?\Closure $senden, string $url = 'https://sites.example.invalid'): Zentrale
+    {
+        $url_db = 'sqlite:///'.$this->root.'/var/cms.db';
+
+        return new Zentrale($this->root, new Updater($this->root, $url_db, new CommandRunner(), $this->db), $this->updater(), $url, 'https://kunde.example.de', $url_db, $senden);
+    }
+
+    /**
+     * Eine Zentrale im Speicher: lernt den Schlüssel beim ersten Kontakt, prüft danach jede
+     * Unterschrift, gibt den Auftrag einmal heraus und unterschreibt jede Antwort.
+     *
+     * @return array{senden: \Closure, meldungen: \Closure}
+     */
+    private function zentraleServer(?array $auftrag): array
+    {
+        $schluessel = null;
+        $meldungen = [];
+        $senden = function (string $url, string $body, array $kopf) use (&$schluessel, &$meldungen, &$auftrag): array {
+            $daten = json_decode($body, true);
+            $meldungen[] = $daten;
+            $schluessel ??= $daten['schluessel'] ?? null;
+            self::assertIsString($schluessel);
+            self::assertTrue(hash_equals(hash_hmac('sha256', $body, $schluessel), $kopf['X-KantSites-Signatur']), 'Jede Meldung ist unterschrieben.');
+            $antwort = json_encode(['ok' => true, 'auftrag' => $auftrag]);
+            $auftrag = null;
+
+            return ['status' => 200, 'body' => $antwort, 'signatur' => hash_hmac('sha256', $antwort, $schluessel)];
+        };
+
+        return ['senden' => $senden, 'meldungen' => static function () use (&$meldungen): array {
+            return $meldungen;
+        }];
+    }
+
     private function installation(): Installation
     {
         $settings = new SiteSettings($this->db, new MediaLibrary($this->db, $this->root.'/var/media'));

tests/TaskScreenTest.php

@@ -70,7 +70,7 @@ final class TaskScreenTest extends WebTestCase
         self::assertSame(200, $client->getResponse()->getStatusCode());
         $html = (string) $client->getResponse()->getContent();
 
-        foreach (['publish-due', 'stats-prune', 'backup', 'update-check', 'cleanup'] as $task) {
+        foreach (['publish-due', 'stats-prune', 'backup', 'update-check', 'cleanup', 'zentrale'] as $task) {
             self::assertStringContainsString($task, $html);
         }
         // Die Einschränkung gehört auf den Bildschirm und nicht in die Dokumentation: wer sie
@@ -78,7 +78,7 @@ final class TaskScreenTest extends WebTestCase
         self::assertStringContainsString('Ohne Besuch und ohne geöffnete Verwaltung passiert nichts.', $html);
         self::assertStringContainsString('/cms-cron/'.Scheduler::cronToken(self::SECRET), $html);
         // Und der Plan steht danach in der Datenbank - eine Zeile je Aufgabe, nicht mehr.
-        self::assertSame(5, (int) $this->db->fetchOne('SELECT COUNT(*) FROM scheduled_task'));
+        self::assertSame(6, (int) $this->db->fetchOne('SELECT COUNT(*) FROM scheduled_task'));
     }
 
     public function testStartingWorkNeedsAnAdministratorAndAValidForm(): void

zentrale/.htaccess

@@ -0,0 +1,15 @@
+# Für den Fall, dass die Subdomain auf diesen Ordner zeigt statt auf public/:
+# app/, var/ und config.php bleiben verschlossen, alles andere geht nach public/.
+Options -Indexes
+
+<IfModule mod_rewrite.c>
+    RewriteEngine On
+    RewriteRule ^(app|var)(/|$) - [F,L]
+    RewriteRule ^(config\.php|config\.example\.php|README\.md)$ - [F,L]
+    RewriteCond %{REQUEST_URI} !^/public/
+    RewriteRule ^(.*)$ public/$1 [L]
+</IfModule>
+
+<IfModule !mod_rewrite.c>
+    Require all denied
+</IfModule>

zentrale/README.md

@@ -0,0 +1,86 @@
+# KantSites Zentrale (sites.kant-it.de)
+
+Die Übersicht aller KantSites-Installationen: welche Domain, welche Fassung, wann zuletzt
+gemeldet, und ein Knopf für Updates – einzeln oder für alle. Entscheidung und Protokoll:
+ADR 123 in `docs/ARCHITECTURE.md`.
+
+Reines PHP (ab 8.1) mit SQLite, ohne Composer und ohne Framework. Nötig sind die Erweiterungen
+`pdo_sqlite` und `curl` (oder `allow_url_fopen`) – beides ist auf üblichem Webhosting da.
+
+## Hochladen
+
+1. Den Ordner `zentrale/` komplett per FTP hochladen, zum Beispiel nach `/sites.kant-it.de/`.
+2. Die Subdomain `sites.kant-it.de` auf den Unterordner **`public/`** zeigen lassen.
+   Geht das beim Hoster nicht, auf den Ordner selbst – die `.htaccess` dort leitet nach `public/`
+   und sperrt `app/`, `var/` und `config.php`.
+3. HTTPS (Let's Encrypt) für die Subdomain einschalten. Die Installationen melden nur über HTTPS.
+4. `config.example.php` als `config.php` kopieren und einen zufälligen `einrichtungscode`
+   (mindestens 16 Zeichen) eintragen.
+5. `var/` muss für PHP beschreibbar sein (dort liegen `zentrale.db` und der Fassungs-Cache).
+6. `https://sites.kant-it.de` aufrufen, mit dem Einrichtungscode das erste Konto anlegen und
+   anmelden. Danach wird der Code nicht mehr gebraucht.
+
+Prüfen: `https://sites.kant-it.de/api/melden` im Browser antwortet mit
+`{"ok":false,"fehler":"Nur POST."}` – dann ist die Schnittstelle erreichbar.
+
+## Wie die Installationen sich melden
+
+Ab KantSites **1.36.0** meldet sich jede Installation alle 15 Minuten über die Aufgabe
+„Bei der Zentrale melden“ (Verwaltung → Aufgaben). Sie läuft wie alle Aufgaben beim Besuch,
+in der Verwaltung oder über den URL-Cronjob. Ältere Installationen erscheinen erst nach dem Update
+auf 1.36.0 – das letzte Mal von Hand über „System“.
+
+Nicht gemeldet wird von Installationen, deren `SITE_ORIGIN` auf `localhost`, `127.0.0.1`,
+`*.test` oder `*.localhost` zeigt. Abschalten pro Installation: `ZENTRALE_URL=aus` in `.env`.
+
+Übertragen werden: Adresse, Fassung, PHP-Version, Datenbankart (sqlite/mysql), Git oder
+Archiv, Wartungszustand, Stand des letzten Updates. Keine Inhalte, keine Besucher, keine
+Zugangsdaten. Die Zentrale speichert zusätzlich die IP-Adresse der letzten Meldung.
+
+## Übersicht
+
+Die Zählerkacheln oben sind zugleich Filter (aktuell, veraltet, verstummt, ohne Kunde). Die Suche
+findet Domain, frühere Domain, Kunde/Notiz, Fassung und IP-Adresse; Suche und Filter lassen sich
+kombinieren. Die Suche filtert schon beim Tippen; Kacheln und Seitenzahlen wechseln nur die
+Liste (`public/app.js`, ohne JavaScript funktioniert alles als normales Formular). 25 Installationen
+je Seite, Domains natürlich sortiert und ohne „www.“.
+
+## Update aus der Ferne
+
+1. In der Übersicht „Auf x.y.z“ (oder „Alle aktualisieren“ mit Bestätigung) drücken.
+2. Die Installation holt den Auftrag mit ihrer nächsten Meldung ab, legt eine Sicherung an,
+   lädt das Release mit Prüfsumme, tauscht die Dateien und ruft sich selbst einmal auf. Diese
+   Anfrage führt mit dem neuen Code die Migrationen aus, prüft die Startseite und gibt die
+   Website frei – oder schaltet auf die alte Fassung zurück.
+3. Das Ergebnis erscheint mit der nächsten Meldung in der Zentrale.
+
+Einschränkungen:
+
+- Git-Arbeitskopien werden nicht aus der Ferne aktualisiert.
+- Erreicht sich eine Website nicht selbst (manche Hoster sperren das), schließt der nächste
+  Besucher oder Cron-Aufruf das Update ab. So lange zeigt sie die Wartungsseite.
+- Ein abgeholter Auftrag ohne Ergebnis nach 2 Stunden erscheint als „keine Rückmeldung“.
+
+## Fremde Installationen erkennen
+
+Jede Installation, der in der Detailansicht kein Kunde zugeordnet ist, steht als
+**Unbekannt** in der Liste. Meldet sich eine bekannte Kennung unter einer anderen Domain, zeigt die
+Liste „vorher …“. Wer KantSites verändert und die Meldung ausbaut, taucht nicht auf – einen
+vollständigen Schutz gibt es ohne Lizenzschlüssel nicht.
+
+## Lokal ausprobieren
+
+```bash
+php -S 127.0.0.1:8115 -t zentrale/public zentrale/public/index.php
+```
+
+Protokollprüfung zwischen CMS und Zentrale (ohne Netz):
+
+```bash
+php scripts/zentrale-check.php
+```
+
+## Sicherung
+
+Alles Wichtige steht in `var/zentrale.db`. Geht sie verloren, melden sich die Installationen bei
+ihrer nächsten Meldung neu an; Kundenzuordnungen und Auftragsverlauf sind dann weg.

zentrale/app/.htaccess

@@ -0,0 +1 @@
+Require all denied

zentrale/app/Ansicht.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Zentrale;
+
+/**
+ * Vorlagen als PHP-Dateien. Alles, was ausgegeben wird, geht durch e().
+ */
+final class Ansicht
+{
+    public function __construct(private string $csrf)
+    {
+    }
+
+    /** @param array<string, mixed> $daten */
+    public function vorlage(string $datei, array $daten): string
+    {
+        $v = $this;
+        extract($daten, EXTR_SKIP);
+        ob_start();
+        require $datei;
+
+        return (string) ob_get_clean();
+    }
+
+    public function e(mixed $wert): string
+    {
+        return htmlspecialchars((string) $wert, ENT_QUOTES | ENT_SUBSTITUTE, 'UTF-8');
+    }
+
+    public function csrf(): string
+    {
+        return '<input type="hidden" name="_csrf" value="'.$this->e($this->csrf).'">';
+    }
+
+    /**
+     * Eine Adresse der Übersicht; leere Werte und Seite 1 fallen weg.
+     *
+     * @param array<string, mixed> $werte
+     */
+    public function adresse(array $werte): string
+    {
+        $werte = array_filter($werte, static fn (mixed $wert): bool => null !== $wert && '' !== $wert && 1 !== $wert);
+
+        return '/'.([] === $werte ? '' : '?'.http_build_query($werte));
+    }
+
+    /** Ein Zeitpunkt in deutscher Ortszeit. */
+    public function zeit(?string $iso): string
+    {
+        if (null === $iso || '' === $iso || false === strtotime($iso)) {
+            return '–';
+        }
+
+        return (new \DateTimeImmutable($iso))->setTimezone(new \DateTimeZone('Europe/Berlin'))->format('d.m.Y, H:i');
+    }
+
+    /** „vor 5 Minuten“ - für die letzte Meldung. */
+    public function vor(int $sekunden): string
+    {
+        return match (true) {
+            $sekunden < 90 => 'gerade eben',
+            $sekunden < 5400 => sprintf('vor %d Minuten', (int) round($sekunden / 60)),
+            $sekunden < 129600 => sprintf('vor %d Stunden', (int) round($sekunden / 3600)),
+            default => sprintf('vor %d Tagen', (int) round($sekunden / 86400)),
+        };
+    }
+}

zentrale/app/Anwendung.php

@@ -0,0 +1,391 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Zentrale;
+
+/**
+ * Die Weiche: Adresse und Methode zu einer Aktion. Kein Framework - die Plattform hat sieben
+ * Seiten und eine Schnittstelle, und sie soll sich per FTP auf jedes Hosting mit PHP legen lassen.
+ */
+final class Anwendung
+{
+    /** Zeilen je Seite in der Übersicht. */
+    private const PRO_SEITE = 25;
+
+    private \PDO $db;
+
+    /** @param array<string, mixed> $config */
+    public function __construct(private array $config, private string $wurzel)
+    {
+    }
+
+    public function bearbeiten(): void
+    {
+        $pfad = '/'.trim((string) parse_url((string) ($_SERVER['REQUEST_URI'] ?? '/'), PHP_URL_PATH), '/');
+        $methode = (string) ($_SERVER['REQUEST_METHOD'] ?? 'GET');
+        $this->kopfzeilen();
+
+        try {
+            $this->db = Datenbank::oeffnen($this->wurzel.'/var/zentrale.db');
+        } catch (\Throwable $fehler) {
+            http_response_code(500);
+            header('Content-Type: text/plain; charset=UTF-8');
+            echo "Die Datenbank lässt sich nicht öffnen. Ist var/ beschreibbar?\n";
+            error_log('Zentrale: '.$fehler->getMessage());
+
+            return;
+        }
+
+        if ('/api/melden' === $pfad) {
+            $this->api($methode);
+
+            return;
+        }
+        if ('/robots.txt' === $pfad) {
+            header('Content-Type: text/plain; charset=UTF-8');
+            echo "User-agent: *\nDisallow: /\n";
+
+            return;
+        }
+
+        $this->sitzung();
+        $konten = new Konten($this->db);
+        if (!$konten->gibtEs()) {
+            $this->einrichten($konten, $methode);
+
+            return;
+        }
+        if ('/anmelden' === $pfad) {
+            $this->anmelden($konten, $methode);
+
+            return;
+        }
+        if (!isset($_SESSION['konto'])) {
+            $this->weiter('/anmelden');
+
+            return;
+        }
+        if ('POST' === $methode && !$this->csrfGueltig()) {
+            $this->hinweis('Die Sitzung ist abgelaufen. Bitte noch einmal.', 'fehler');
+            $this->weiter('/' === $pfad ? '/' : $pfad);
+
+            return;
+        }
+
+        $fassungen = new Fassungen((string) ($this->config['releases_api'] ?? ''), $this->wurzel.'/var/neueste.json');
+        $bestand = new Bestand($this->db);
+
+        match (true) {
+            '/' === $pfad && 'GET' === $methode => $this->uebersicht($bestand, $fassungen),
+            '/installation' === $pfad && 'GET' === $methode => $this->detail($bestand, $fassungen),
+            '/auftrag' === $pfad && 'POST' === $methode => $this->auftrag($bestand, $fassungen),
+            '/auftrag/alle' === $pfad && 'POST' === $methode => $this->alleAuftraege($bestand, $fassungen),
+            '/auftrag/zurueckziehen' === $pfad && 'POST' === $methode => $this->zurueckziehen($bestand),
+            '/notiz' === $pfad && 'POST' === $methode => $this->notiz($bestand),
+            '/entfernen' === $pfad && 'POST' === $methode => $this->entfernen($bestand),
+            '/fassung' === $pfad && 'POST' === $methode => $this->fassungNeu($fassungen),
+            '/abmelden' === $pfad && 'POST' === $methode => $this->abmelden(),
+            default => $this->nichtGefunden(),
+        };
+    }
+
+    private function api(string $methode): void
+    {
+        header('Content-Type: application/json; charset=UTF-8');
+        if ('POST' !== $methode) {
+            http_response_code(405);
+            header('Allow: POST');
+            echo '{"ok":false,"fehler":"Nur POST."}';
+
+            return;
+        }
+        $antwort = (new Api($this->db))->melden(
+            (string) file_get_contents('php://input', false, null, 0, 16385),
+            (string) ($_SERVER['HTTP_X_KANTSITES_SIGNATUR'] ?? ''),
+            (string) ($_SERVER['REMOTE_ADDR'] ?? ''),
+        );
+        http_response_code($antwort['status']);
+        if (null !== $antwort['signatur']) {
+            header('X-KantSites-Signatur: '.$antwort['signatur']);
+        }
+        echo $antwort['body'];
+    }
+
+    private function uebersicht(Bestand $bestand, Fassungen $fassungen): void
+    {
+        $neueste = $fassungen->neueste();
+        $alle = $bestand->alle($neueste['version'] ?? null);
+
+        // Die Zähler oben sind zugleich die Filter; sie zählen immer den ganzen Bestand.
+        $filter = [
+            'aktuell' => static fn (array $i): bool => null !== $neueste && !$i['veraltet'] && 'unbekannt' !== $i['fassung'],
+            'veraltet' => static fn (array $i): bool => $i['veraltet'],
+            'still' => static fn (array $i): bool => $i['still'],
+            'unbekannt' => static fn (array $i): bool => $i['unbekannt'],
+        ];
+        $zahlen = ['alle' => count($alle)];
+        foreach ($filter as $name => $passt) {
+            $zahlen[$name] = count(array_filter($alle, $passt));
+        }
+        if (null === $neueste) {
+            $zahlen['aktuell'] = null;
+        }
+
+        $suche = mb_substr(trim((string) ($_GET['q'] ?? '')), 0, 100);
+        $gewaehlt = is_string($_GET['filter'] ?? null) && isset($filter[$_GET['filter']]) ? $_GET['filter'] : null;
+        $treffer = array_values(array_filter($alle, static function (array $i) use ($suche, $gewaehlt, $filter): bool {
+            if (null !== $gewaehlt && !$filter[$gewaehlt]($i)) {
+                return false;
+            }
+            if ('' === $suche) {
+                return true;
+            }
+            foreach (['domain', 'domain_vorher', 'adresse', 'notiz', 'fassung', 'ip'] as $feld) {
+                if (null !== $i[$feld] && false !== mb_stripos((string) $i[$feld], $suche)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }));
+
+        $proSeite = self::PRO_SEITE;
+        $seiten = max(1, (int) ceil(count($treffer) / $proSeite));
+        $seite = min($seiten, max(1, (int) ($_GET['seite'] ?? 1)));
+
+        $namen = ['aktuell' => 'aktuell', 'veraltet' => 'veraltet', 'still' => 'ohne Meldung seit 48 h', 'unbekannt' => 'ohne Kundenzuordnung'];
+        $von = [] === $treffer ? 0 : ($seite - 1) * $proSeite + 1;
+        $bis = min(count($treffer), $seite * $proSeite);
+        $trefferText = [] === $treffer ? 'Keine Treffer.' : sprintf('%d–%d von %d %s', $von, $bis, count($treffer), 1 === count($treffer) ? 'Installation' : 'Installationen')
+            .(null !== $gewaehlt ? ' · Filter: '.$namen[$gewaehlt] : '')
+            .('' !== $suche ? ' · Suche: „'.$suche.'“' : '');
+
+        // Die Live-Suche holt nur die Liste; ohne JavaScript kommt die ganze Seite.
+        $teil = 'liste' === ($_GET['teil'] ?? null);
+        $this->zeigen($teil ? '_liste' : 'uebersicht', [
+            'titel' => 'Installationen',
+            'trefferText' => $trefferText,
+            'neueste' => $neueste,
+            'installationen' => array_slice($treffer, ($seite - 1) * $proSeite, $proSeite),
+            'treffer' => count($treffer),
+            'suche' => $suche,
+            'filter' => $gewaehlt,
+            'seite' => $seite,
+            'seiten' => $seiten,
+            'zahlen' => $zahlen,
+            // Verstummte bleiben außen vor: Sie holen den Auftrag womöglich nie ab. Wartende haben schon einen.
+            'aktualisierbar' => array_values(array_filter($alle, static fn (array $i): bool => $i['kann_update'] && !$i['still'] && 'wartet' !== ($i['auftrag_zustand']['art'] ?? null))),
+        ], true, $teil);
+    }
+
+    private function detail(Bestand $bestand, Fassungen $fassungen): void
+    {
+        $neueste = $fassungen->neueste();
+        $eine = $bestand->eine((string) ($_GET['id'] ?? ''), $neueste['version'] ?? null);
+        if (null === $eine) {
+            $this->nichtGefunden();
+
+            return;
+        }
+        $this->zeigen('installation', ['titel' => $eine['domain'], 'i' => $eine, 'neueste' => $neueste]);
+    }
+
+    private function auftrag(Bestand $bestand, Fassungen $fassungen): void
+    {
+        $id = (string) ($_POST['id'] ?? '');
+        $neueste = $fassungen->neueste()['version'] ?? null;
+        $grund = null === $neueste ? 'Die neueste Fassung ist gerade nicht bekannt.' : $bestand->beauftragen($id, $neueste);
+        $this->hinweis(null === $grund ? sprintf('Update auf %s beauftragt. Die Website holt es mit ihrer nächsten Meldung ab (meist innerhalb von 15 Minuten).', $neueste) : $grund, null === $grund ? 'ok' : 'fehler');
+        $this->weiter('detail' === ($_POST['zurueck'] ?? '') ? '/installation?id='.rawurlencode($id) : '/');
+    }
+
+    private function alleAuftraege(Bestand $bestand, Fassungen $fassungen): void
+    {
+        $neueste = $fassungen->neueste()['version'] ?? null;
+        if ('ja' !== ($_POST['bestaetigt'] ?? '') || null === $neueste) {
+            $this->hinweis(null === $neueste ? 'Die neueste Fassung ist gerade nicht bekannt.' : 'Bitte zuerst bestätigen, dass alle veralteten Installationen aktualisiert werden sollen.', 'fehler');
+            $this->weiter('/');
+
+            return;
+        }
+        $anzahl = 0;
+        foreach ($bestand->alle($neueste) as $installation) {
+            if ($installation['kann_update'] && !$installation['still'] && null === $bestand->beauftragen((string) $installation['id'], $neueste)) {
+                ++$anzahl;
+            }
+        }
+        $this->hinweis(sprintf('%d Update(s) auf %s beauftragt.', $anzahl, $neueste), 'ok');
+        $this->weiter('/');
+    }
+
+    private function zurueckziehen(Bestand $bestand): void
+    {
+        $id = (string) ($_POST['id'] ?? '');
+        $this->hinweis($bestand->zurueckziehen($id) ? 'Auftrag zurückgezogen.' : 'Der Auftrag war schon abgeholt und lässt sich nicht mehr zurückziehen.', 'ok');
+        $this->weiter('/installation?id='.rawurlencode($id));
+    }
+
+    private function notiz(Bestand $bestand): void
+    {
+        $id = (string) ($_POST['id'] ?? '');
+        $bestand->notiz($id, (string) ($_POST['notiz'] ?? ''));
+        $this->hinweis('Gespeichert.', 'ok');
+        $this->weiter('/installation?id='.rawurlencode($id));
+    }
+
+    private function entfernen(Bestand $bestand): void
+    {
+        $id = (string) ($_POST['id'] ?? '');
+        if ('ja' !== ($_POST['bestaetigt'] ?? '')) {
+            $this->hinweis('Bitte bestätigen, dass der Eintrag entfernt werden soll.', 'fehler');
+            $this->weiter('/installation?id='.rawurlencode($id));
+
+            return;
+        }
+        $bestand->entfernen($id);
+        $this->hinweis('Eintrag entfernt. Meldet sich die Installation wieder, erscheint sie neu.', 'ok');
+        $this->weiter('/');
+    }
+
+    private function fassungNeu(Fassungen $fassungen): void
+    {
+        $neu = $fassungen->neueste(true);
+        $this->hinweis(null === $neu ? 'Die Releaseseite antwortet nicht.' : sprintf('Neueste Fassung: %s.', $neu['version']), null === $neu ? 'fehler' : 'ok');
+        $this->weiter('/');
+    }
+
+    private function einrichten(Konten $konten, string $methode): void
+    {
+        $code = (string) ($this->config['einrichtungscode'] ?? '');
+        $fehler = null;
+        if (strlen($code) < 16) {
+            $fehler = 'In config.php fehlt ein einrichtungscode mit mindestens 16 Zeichen. Erst danach lässt sich das erste Konto anlegen.';
+        } elseif ('POST' === $methode) {
+            $name = trim((string) ($_POST['name'] ?? ''));
+            $passwort = (string) ($_POST['passwort'] ?? '');
+            $ip = (string) ($_SERVER['REMOTE_ADDR'] ?? '');
+            $fehler = match (true) {
+                !$this->csrfGueltig() => 'Die Sitzung ist abgelaufen. Bitte noch einmal.',
+                $konten->gesperrt($ip) => 'Zu viele Fehlversuche. Bitte in 15 Minuten noch einmal.',
+                !hash_equals($code, (string) ($_POST['code'] ?? '')) => 'Der Einrichtungscode stimmt nicht.',
+                1 !== preg_match('/^[\p{L}\p{N}._@-]{3,60}$/uD', $name) => 'Der Name braucht 3 bis 60 Zeichen (Buchstaben, Ziffern, . _ @ -).',
+                mb_strlen($passwort) < 12 => 'Das Passwort braucht mindestens 12 Zeichen.',
+                $passwort !== (string) ($_POST['passwort2'] ?? '') => 'Die beiden Passwörter stimmen nicht überein.',
+                default => null,
+            };
+            if (null !== $fehler && str_starts_with($fehler, 'Der Einrichtungscode')) {
+                $konten->fehlversuch($ip);
+            }
+            if (null === $fehler) {
+                $konten->anlegen($name, $passwort);
+                $this->hinweis('Konto angelegt. Bitte jetzt anmelden.', 'ok');
+                $this->weiter('/anmelden');
+
+                return;
+            }
+        }
+        $this->zeigen('einrichten', ['titel' => 'Einrichten', 'fehler' => $fehler, 'name' => (string) ($_POST['name'] ?? '')], false);
+    }
+
+    private function anmelden(Konten $konten, string $methode): void
+    {
+        if (isset($_SESSION['konto'])) {
+            $this->weiter('/');
+
+            return;
+        }
+        $fehler = null;
+        $ip = (string) ($_SERVER['REMOTE_ADDR'] ?? '');
+        if ('POST' === $methode) {
+            if (!$this->csrfGueltig()) {
+                $fehler = 'Die Sitzung ist abgelaufen. Bitte noch einmal.';
+            } elseif ($konten->gesperrt($ip)) {
+                $fehler = 'Zu viele Fehlversuche. Bitte in 15 Minuten noch einmal.';
+            } else {
+                $konto = $konten->pruefen(trim((string) ($_POST['name'] ?? '')), (string) ($_POST['passwort'] ?? ''), $ip);
+                if (null !== $konto) {
+                    session_regenerate_id(true);
+                    $_SESSION['konto'] = $konto;
+                    $_SESSION['csrf'] = bin2hex(random_bytes(32));
+                    $this->weiter('/');
+
+                    return;
+                }
+                $fehler = 'Name oder Passwort stimmen nicht.';
+            }
+            http_response_code(422);
+        }
+        $this->zeigen('anmelden', ['titel' => 'Anmelden', 'fehler' => $fehler, 'name' => (string) ($_POST['name'] ?? '')], false);
+    }
+
+    private function abmelden(): void
+    {
+        $_SESSION = [];
+        session_regenerate_id(true);
+        $this->weiter('/anmelden');
+    }
+
+    private function nichtGefunden(): void
+    {
+        http_response_code(404);
+        $this->zeigen('fehlt', ['titel' => 'Nicht gefunden'], isset($_SESSION['konto']));
+    }
+
+    private function sitzung(): void
+    {
+        $https = 'on' === strtolower((string) ($_SERVER['HTTPS'] ?? '')) || '443' === (string) ($_SERVER['SERVER_PORT'] ?? '');
+        session_name($https ? '__Host-zentrale' : 'zentrale');
+        session_set_cookie_params(['lifetime' => 0, 'path' => '/', 'secure' => $https, 'httponly' => true, 'samesite' => 'Strict']);
+        ini_set('session.use_strict_mode', '1');
+        ini_set('session.gc_maxlifetime', '28800');
+        session_start();
+        $_SESSION['csrf'] ??= bin2hex(random_bytes(32));
+    }
+
+    private function csrfGueltig(): bool
+    {
+        return is_string($_POST['_csrf'] ?? null) && hash_equals((string) ($_SESSION['csrf'] ?? ''), $_POST['_csrf']);
+    }
+
+    private function hinweis(string $text, string $art): void
+    {
+        $_SESSION['hinweis'] = ['text' => $text, 'art' => $art];
+    }
+
+    private function weiter(string $ziel): void
+    {
+        http_response_code(303);
+        header('Location: '.$ziel);
+    }
+
+    private function kopfzeilen(): void
+    {
+        header("Content-Security-Policy: default-src 'none'; script-src 'self'; connect-src 'self'; style-src 'self'; img-src 'self' data:; form-action 'self'; frame-ancestors 'none'; base-uri 'none'");
+        header('X-Content-Type-Options: nosniff');
+        header('Referrer-Policy: no-referrer');
+        header('X-Robots-Tag: noindex, nofollow');
+        header('Cache-Control: no-store');
+    }
+
+    /** @param array<string, mixed> $daten */
+    private function zeigen(string $vorlage, array $daten, bool $angemeldet = true, bool $ohneRahmen = false): void
+    {
+        header('Content-Type: text/html; charset=UTF-8');
+        if ($ohneRahmen) {
+            echo (new Ansicht((string) ($_SESSION['csrf'] ?? '')))->vorlage($this->wurzel.'/app/vorlagen/'.$vorlage.'.php', $daten);
+
+            return;
+        }
+        $hinweis = $_SESSION['hinweis'] ?? null;
+        unset($_SESSION['hinweis']);
+        $v = new Ansicht((string) ($_SESSION['csrf'] ?? ''));
+        $inhalt = $v->vorlage($this->wurzel.'/app/vorlagen/'.$vorlage.'.php', $daten);
+        echo $v->vorlage($this->wurzel.'/app/vorlagen/rahmen.php', [
+            'titel' => $daten['titel'] ?? 'Zentrale',
+            'inhalt' => $inhalt,
+            'hinweis' => $hinweis,
+            'konto' => $angemeldet ? ($_SESSION['konto'] ?? null) : null,
+        ]);
+    }
+}

zentrale/app/Api.php

@@ -0,0 +1,142 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Zentrale;
+
+/**
+ * POST /api/melden - die Meldung einer KantSites-Installation.
+ *
+ * Gegenstück zu App\Ops\Zentrale im CMS. Beim ersten Kontakt bringt die Installation ihren
+ * Schlüssel mit; danach muss jede Meldung damit unterschrieben sein (HMAC-SHA256 über den
+ * Rohtext, Kopfzeile X-KantSites-Signatur). Jede Antwort ist ebenso unterschrieben, damit die
+ * Installation nur Aufträge von hier annimmt.
+ */
+final class Api
+{
+    private const GROESSTE_MELDUNG = 16384;
+
+    public function __construct(private \PDO $db)
+    {
+    }
+
+    /**
+     * @return array{status: int, body: string, signatur: ?string}
+     */
+    public function melden(string $body, string $signatur, string $ip): array
+    {
+        if (strlen($body) > self::GROESSTE_MELDUNG) {
+            return $this->fehler(413, 'Die Meldung ist zu groß.');
+        }
+        $daten = json_decode($body, true);
+        if (!is_array($daten)) {
+            return $this->fehler(400, 'Die Meldung ist kein JSON.');
+        }
+        $pruef = $this->pruefen($daten);
+        if (is_string($pruef)) {
+            return $this->fehler(400, $pruef);
+        }
+        $signatur = strtolower(trim($signatur));
+
+        $gespeichert = $this->db->prepare('SELECT * FROM installation WHERE id = ?');
+        $gespeichert->execute([$daten['id']]);
+        $installation = $gespeichert->fetch() ?: null;
+        $mitgebracht = is_string($daten['schluessel'] ?? null) && 1 === preg_match('/^[a-f0-9]{64}$/D', $daten['schluessel']) ? $daten['schluessel'] : null;
+
+        if (null === $installation) {
+            if (null === $mitgebracht) {
+                // Die Installation hält sich für angemeldet, hier ist sie unbekannt: Sie schickt
+                // daraufhin ihren Schlüssel noch einmal.
+                return $this->fehler(409, 'Diese Installation ist hier nicht bekannt.');
+            }
+            $schluessel = $mitgebracht;
+        } else {
+            $schluessel = (string) $installation['schluessel'];
+            if (null !== $mitgebracht && !hash_equals($schluessel, $mitgebracht)) {
+                return $this->fehler(403, 'Diese Kennung gehört zu einer anderen Installation.');
+            }
+        }
+        if (!hash_equals(hash_hmac('sha256', $body, $schluessel), $signatur)) {
+            return $this->fehler(403, 'Die Unterschrift stimmt nicht.');
+        }
+
+        $jetzt = Datenbank::jetzt();
+        $domain = strtolower((string) parse_url($daten['adresse'], PHP_URL_HOST));
+        $update = is_array($daten['update'] ?? null) ? $daten['update'] : [];
+        $werte = [
+            'adresse' => $daten['adresse'],
+            'domain' => $domain,
+            'fassung' => $daten['fassung'],
+            'php' => mb_substr((string) ($daten['php'] ?? ''), 0, 20),
+            'datenbank' => mb_substr((string) ($daten['datenbank'] ?? ''), 0, 20),
+            'art' => 'git' === ($daten['art'] ?? '') ? 'git' : 'archiv',
+            'wartung' => true === ($daten['wartung'] ?? false) ? 1 : 0,
+            'update_phase' => isset($update['phase']) ? mb_substr((string) $update['phase'], 0, 30) : null,
+            'update_meldung' => isset($update['meldung']) ? mb_substr((string) $update['meldung'], 0, 300) : null,
+            'update_zeit' => isset($update['zeit']) ? mb_substr((string) $update['zeit'], 0, 40) : null,
+            'ip' => mb_substr($ip, 0, 45),
+            'letzte_meldung' => $jetzt,
+        ];
+
+        $this->db->beginTransaction();
+        try {
+            if (null === $installation) {
+                $sql = 'INSERT INTO installation (id, schluessel, erste_meldung, '.implode(', ', array_keys($werte)).') VALUES (?, ?, ?, '.implode(', ', array_fill(0, count($werte), '?')).')';
+                $this->db->prepare($sql)->execute([$daten['id'], $schluessel, $jetzt, ...array_values($werte)]);
+            } else {
+                // Meldet sich dieselbe Kennung unter einer anderen Domain, wurde die Installation
+                // kopiert oder umgezogen. Beides will man sehen.
+                if ($installation['domain'] !== $domain) {
+                    $werte['domain_vorher'] = $installation['domain'];
+                }
+                $sql = 'UPDATE installation SET '.implode(', ', array_map(static fn (string $spalte): string => $spalte.' = ?', array_keys($werte))).' WHERE id = ?';
+                $this->db->prepare($sql)->execute([...array_values($werte), $daten['id']]);
+            }
+
+            $ergebnis = $daten['auftrag'] ?? null;
+            if (is_array($ergebnis) && is_int($ergebnis['id'] ?? null) && is_bool($ergebnis['ok'] ?? null)) {
+                $this->db->prepare('UPDATE auftrag SET erledigt = ?, ok = ?, meldung = ?, abgeholt = COALESCE(abgeholt, ?) WHERE id = ? AND installation = ? AND erledigt IS NULL')
+                    ->execute([$jetzt, $ergebnis['ok'] ? 1 : 0, mb_substr((string) ($ergebnis['meldung'] ?? ''), 0, 500), $jetzt, $ergebnis['id'], $daten['id']]);
+            }
+
+            $offen = $this->db->prepare('SELECT id, aktion, fassung FROM auftrag WHERE installation = ? AND abgeholt IS NULL AND erledigt IS NULL ORDER BY id DESC LIMIT 1');
+            $offen->execute([$daten['id']]);
+            $auftrag = $offen->fetch() ?: null;
+            if (null !== $auftrag) {
+                $this->db->prepare('UPDATE auftrag SET abgeholt = ? WHERE id = ?')->execute([$jetzt, $auftrag['id']]);
+                $auftrag = ['id' => (int) $auftrag['id'], 'aktion' => (string) $auftrag['aktion'], 'fassung' => (string) $auftrag['fassung']];
+            }
+            $this->db->commit();
+        } catch (\Throwable $fehler) {
+            $this->db->rollBack();
+            throw $fehler;
+        }
+
+        $antwort = json_encode(['ok' => true, 'auftrag' => $auftrag], JSON_UNESCAPED_SLASHES | JSON_THROW_ON_ERROR);
+
+        return ['status' => 200, 'body' => $antwort, 'signatur' => hash_hmac('sha256', $antwort, $schluessel)];
+    }
+
+    /** @param array<string, mixed> $daten */
+    private function pruefen(array $daten): ?string
+    {
+        if (!is_string($daten['id'] ?? null) || 1 !== preg_match('/^[a-f0-9]{32}$/D', $daten['id'])) {
+            return 'Die Kennung fehlt oder hat die falsche Form.';
+        }
+        $adresse = $daten['adresse'] ?? null;
+        if (!is_string($adresse) || strlen($adresse) > 200 || 1 !== preg_match('#^https?://[a-z0-9.-]+(:\d{1,5})?(/[^\s]*)?$#iD', $adresse)) {
+            return 'Die Adresse fehlt oder ist keine Webadresse.';
+        }
+        if (!is_string($daten['fassung'] ?? null) || 1 !== preg_match('/^(\d{1,4}\.\d{1,5}\.\d{1,6}|unbekannt)$/D', $daten['fassung'])) {
+            return 'Die Fassung hat nicht die Form 1.2.3.';
+        }
+
+        return null;
+    }
+
+    /** @return array{status: int, body: string, signatur: null} */
+    private function fehler(int $status, string $text): array
+    {
+        return ['status' => $status, 'body' => (string) json_encode(['ok' => false, 'fehler' => $text], JSON_UNESCAPED_UNICODE), 'signatur' => null];
+    }
+}

zentrale/app/Bestand.php

@@ -0,0 +1,153 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Zentrale;
+
+/**
+ * Die Installationen und ihre Aufträge - was die Übersicht zeigt und was ihre Knöpfe tun.
+ */
+final class Bestand
+{
+    /** Ohne Meldung seit so vielen Stunden gilt eine Installation als verstummt. */
+    public const STILL_STUNDEN = 48;
+
+    /** Ein abgeholter Auftrag ohne Ergebnis nach so vielen Stunden: keine Rückmeldung. */
+    public const AUFTRAG_STUNDEN = 2;
+
+    public function __construct(private \PDO $db)
+    {
+    }
+
+    /** @return list<array<string, mixed>> */
+    public function alle(?string $neueste): array
+    {
+        $zeilen = $this->db->query('SELECT * FROM installation ORDER BY domain, erste_meldung')->fetchAll();
+        // Natürlich sortiert und ohne www: kunde-2 vor kunde-10, www.ebsolar.de bei e.
+        usort($zeilen, static fn (array $a, array $b): int => strnatcasecmp(preg_replace('/^www\./', '', (string) $a['domain']), preg_replace('/^www\./', '', (string) $b['domain'])));
+        $auftraege = [];
+        foreach ($this->db->query('SELECT a.* FROM auftrag a JOIN (SELECT installation, MAX(id) AS id FROM auftrag GROUP BY installation) j ON j.id = a.id')->fetchAll() as $auftrag) {
+            $auftraege[$auftrag['installation']] = $auftrag;
+        }
+
+        return array_map(fn (array $zeile): array => $this->anreichern($zeile, $auftraege[$zeile['id']] ?? null, $neueste), $zeilen);
+    }
+
+    /** @return array<string, mixed>|null */
+    public function eine(string $id, ?string $neueste): ?array
+    {
+        $abfrage = $this->db->prepare('SELECT * FROM installation WHERE id = ?');
+        $abfrage->execute([$id]);
+        $zeile = $abfrage->fetch() ?: null;
+        if (null === $zeile) {
+            return null;
+        }
+        $verlauf = $this->db->prepare('SELECT * FROM auftrag WHERE installation = ? ORDER BY id DESC LIMIT 30');
+        $verlauf->execute([$id]);
+        $auftraege = $verlauf->fetchAll();
+        $eine = $this->anreichern($zeile, $auftraege[0] ?? null, $neueste);
+        $eine['verlauf'] = array_map(fn (array $a): array => [...$a, 'zustand' => $this->auftragZustand($a)], $auftraege);
+
+        return $eine;
+    }
+
+    /**
+     * Ein Update in Auftrag geben. Gibt null zurück oder den Grund, warum nicht.
+     */
+    public function beauftragen(string $id, string $fassung): ?string
+    {
+        $eine = $this->eine($id, $fassung);
+        if (null === $eine) {
+            return 'Diese Installation gibt es nicht.';
+        }
+        if (!$eine['kann_update']) {
+            return $eine['kein_update_grund'];
+        }
+        $offen = $eine['auftrag'];
+        if (null !== $offen && null === $offen['abgeholt'] && null === $offen['erledigt']) {
+            $this->db->prepare('UPDATE auftrag SET fassung = ?, erstellt = ? WHERE id = ?')->execute([$fassung, Datenbank::jetzt(), $offen['id']]);
+
+            return null;
+        }
+        $this->db->prepare('INSERT INTO auftrag (installation, aktion, fassung, erstellt) VALUES (?, ?, ?, ?)')
+            ->execute([$id, 'update', $fassung, Datenbank::jetzt()]);
+
+        return null;
+    }
+
+    /** Einen noch nicht abgeholten Auftrag zurückziehen. */
+    public function zurueckziehen(string $id): bool
+    {
+        $abfrage = $this->db->prepare('DELETE FROM auftrag WHERE installation = ? AND abgeholt IS NULL AND erledigt IS NULL');
+        $abfrage->execute([$id]);
+
+        return $abfrage->rowCount() > 0;
+    }
+
+    public function notiz(string $id, string $notiz): void
+    {
+        $this->db->prepare('UPDATE installation SET notiz = ? WHERE id = ?')->execute([mb_substr(trim($notiz), 0, 200), $id]);
+    }
+
+    public function entfernen(string $id): void
+    {
+        $this->db->prepare('DELETE FROM installation WHERE id = ?')->execute([$id]);
+    }
+
+    /**
+     * @param array<string, mixed>      $zeile
+     * @param array<string, mixed>|null $auftrag
+     *
+     * @return array<string, mixed>
+     */
+    private function anreichern(array $zeile, ?array $auftrag, ?string $neueste): array
+    {
+        $alter = time() - (int) strtotime((string) $zeile['letzte_meldung']);
+        $veraltet = null !== $neueste && 'unbekannt' !== $zeile['fassung'] && version_compare((string) $zeile['fassung'], $neueste, '<');
+        $zustand = null === $auftrag ? null : $this->auftragZustand($auftrag);
+        // Ein wartender Auftrag lässt sich noch ändern; ein abgeholter läuft.
+        $laeuft = 'laeuft' === ($zustand['art'] ?? null);
+
+        $grund = match (true) {
+            null === $neueste => 'Die neueste Fassung ist gerade nicht bekannt.',
+            !$veraltet => 'Diese Installation ist auf dem neuesten Stand.',
+            'git' === $zeile['art'] => 'Eine Git-Arbeitskopie wird über Git aktualisiert, nicht aus der Ferne.',
+            $laeuft => 'Ein Update läuft gerade.',
+            default => '',
+        };
+
+        return [
+            ...$zeile,
+            'alter' => $alter,
+            'still' => $alter > self::STILL_STUNDEN * 3600,
+            'veraltet' => $veraltet,
+            'unbekannt' => '' === trim((string) $zeile['notiz']),
+            'auftrag' => $auftrag,
+            'auftrag_zustand' => $zustand,
+            'kann_update' => '' === $grund,
+            'kein_update_grund' => $grund,
+        ];
+    }
+
+    /**
+     * @param array<string, mixed> $auftrag
+     *
+     * @return array{art: string, text: string}
+     */
+    private function auftragZustand(array $auftrag): array
+    {
+        if (null !== $auftrag['erledigt']) {
+            return (int) $auftrag['ok'] === 1
+                ? ['art' => 'ok', 'text' => sprintf('Update auf %s erledigt', $auftrag['fassung'])]
+                : ['art' => 'fehler', 'text' => sprintf('Update auf %s gescheitert', $auftrag['fassung'])];
+        }
+        if (null === $auftrag['abgeholt']) {
+            return ['art' => 'wartet', 'text' => sprintf('Update auf %s wartet auf die nächste Meldung', $auftrag['fassung'])];
+        }
+        if ((int) strtotime((string) $auftrag['abgeholt']) < time() - self::AUFTRAG_STUNDEN * 3600) {
+            return ['art' => 'fehler', 'text' => sprintf('Update auf %s: keine Rückmeldung', $auftrag['fassung'])];
+        }
+
+        return ['art' => 'laeuft', 'text' => sprintf('Update auf %s läuft', $auftrag['fassung'])];
+    }
+}

zentrale/app/Datenbank.php

@@ -0,0 +1,97 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Zentrale;
+
+/**
+ * SQLite in var/zentrale.db. Das Schema legt sich beim ersten Aufruf selbst an; spätere
+ * Änderungen kommen als nummerierte Schritte in MIGRATIONEN dazu, nie als Änderung eines alten.
+ */
+final class Datenbank
+{
+    private const MIGRATIONEN = [
+        1 => [
+            'CREATE TABLE konto (id INTEGER PRIMARY KEY, name TEXT NOT NULL UNIQUE, passwort TEXT NOT NULL, erstellt TEXT NOT NULL)',
+            'CREATE TABLE anmeldeversuch (ip TEXT NOT NULL, zeit TEXT NOT NULL)',
+            'CREATE INDEX anmeldeversuch_ip ON anmeldeversuch (ip, zeit)',
+            'CREATE TABLE installation (
+                id TEXT PRIMARY KEY,
+                schluessel TEXT NOT NULL,
+                adresse TEXT NOT NULL,
+                domain TEXT NOT NULL,
+                domain_vorher TEXT,
+                fassung TEXT NOT NULL,
+                php TEXT NOT NULL DEFAULT \'\',
+                datenbank TEXT NOT NULL DEFAULT \'\',
+                art TEXT NOT NULL DEFAULT \'archiv\',
+                wartung INTEGER NOT NULL DEFAULT 0,
+                update_phase TEXT,
+                update_meldung TEXT,
+                update_zeit TEXT,
+                notiz TEXT NOT NULL DEFAULT \'\',
+                ip TEXT NOT NULL DEFAULT \'\',
+                erste_meldung TEXT NOT NULL,
+                letzte_meldung TEXT NOT NULL
+            )',
+            'CREATE TABLE auftrag (
+                id INTEGER PRIMARY KEY,
+                installation TEXT NOT NULL REFERENCES installation (id) ON DELETE CASCADE,
+                aktion TEXT NOT NULL,
+                fassung TEXT NOT NULL,
+                erstellt TEXT NOT NULL,
+                abgeholt TEXT,
+                erledigt TEXT,
+                ok INTEGER,
+                meldung TEXT
+            )',
+            'CREATE INDEX auftrag_installation ON auftrag (installation, id)',
+        ],
+    ];
+
+    public static function oeffnen(string $datei): \PDO
+    {
+        $neu = !is_file($datei);
+        if ($neu && !is_dir(dirname($datei)) && !@mkdir(dirname($datei), 0o775, true)) {
+            throw new \RuntimeException(dirname($datei).' lässt sich nicht anlegen.');
+        }
+        $pdo = new \PDO('sqlite:'.$datei, null, null, [
+            \PDO::ATTR_ERRMODE => \PDO::ERRMODE_EXCEPTION,
+            \PDO::ATTR_DEFAULT_FETCH_MODE => \PDO::FETCH_ASSOC,
+        ]);
+        $pdo->exec('PRAGMA foreign_keys = ON');
+        $pdo->exec('PRAGMA busy_timeout = 5000');
+        if ($neu) {
+            $pdo->exec('PRAGMA journal_mode = WAL');
+        }
+        self::migrieren($pdo);
+
+        return $pdo;
+    }
+
+    private static function migrieren(\PDO $pdo): void
+    {
+        $stand = (int) $pdo->query('PRAGMA user_version')->fetchColumn();
+        foreach (self::MIGRATIONEN as $nummer => $anweisungen) {
+            if ($nummer <= $stand) {
+                continue;
+            }
+            $pdo->beginTransaction();
+            try {
+                foreach ($anweisungen as $sql) {
+                    $pdo->exec($sql);
+                }
+                $pdo->exec('PRAGMA user_version = '.$nummer);
+                $pdo->commit();
+            } catch (\Throwable $fehler) {
+                $pdo->rollBack();
+                throw $fehler;
+            }
+        }
+    }
+
+    public static function jetzt(): string
+    {
+        return gmdate('Y-m-d\TH:i:s\Z');
+    }
+}

zentrale/app/Fassungen.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Zentrale;
+
+/**
+ * Die neueste veröffentlichte KantSites-Fassung - von derselben Releaseseite, die auch die
+ * Installationen fragen. Eine halbe Stunde zwischengespeichert; ist die Releaseseite nicht
+ * erreichbar, gilt der letzte bekannte Stand.
+ */
+final class Fassungen
+{
+    private const GUELTIG = 1800;
+
+    public function __construct(private string $api, private string $cache)
+    {
+    }
+
+    /** @return array{version: string, name: string, published: string}|null */
+    public function neueste(bool $frisch = false): ?array
+    {
+        $gespeichert = json_decode((string) @file_get_contents($this->cache), true);
+        $gespeichert = is_array($gespeichert) && is_string($gespeichert['version'] ?? null) ? $gespeichert : null;
+        if (!$frisch && null !== $gespeichert && (int) ($gespeichert['geholt'] ?? 0) > time() - self::GUELTIG) {
+            return $gespeichert;
+        }
+        $neu = $this->holen();
+        if (null === $neu) {
+            return $gespeichert;
+        }
+        @file_put_contents($this->cache, json_encode([...$neu, 'geholt' => time()]));
+
+        return $neu;
+    }
+
+    /** @return array{version: string, name: string, published: string}|null */
+    private function holen(): ?array
+    {
+        if (!str_starts_with($this->api, 'https://')) {
+            return null;
+        }
+        $kontext = stream_context_create([
+            'http' => ['timeout' => 8, 'ignore_errors' => true, 'header' => "User-Agent: KantSites-Zentrale\r\nAccept: application/json\r\n"],
+            'ssl' => ['verify_peer' => true, 'verify_peer_name' => true],
+        ]);
+        if (function_exists('curl_init')) {
+            $curl = curl_init(rtrim($this->api, '/').'/releases/latest');
+            curl_setopt_array($curl, [
+                CURLOPT_RETURNTRANSFER => true,
+                CURLOPT_PROTOCOLS => CURLPROTO_HTTPS,
+                CURLOPT_CONNECTTIMEOUT => 5,
+                CURLOPT_TIMEOUT => 8,
+                CURLOPT_USERAGENT => 'KantSites-Zentrale',
+            ]);
+            $antwort = curl_exec($curl);
+            $status = (int) curl_getinfo($curl, CURLINFO_RESPONSE_CODE);
+            curl_close($curl);
+            $antwort = 200 === $status ? $antwort : false;
+        } else {
+            $antwort = @file_get_contents(rtrim($this->api, '/').'/releases/latest', false, $kontext);
+        }
+        $daten = is_string($antwort) ? json_decode($antwort, true) : null;
+        if (!is_array($daten) || 1 !== preg_match('/^v(\d+\.\d+\.\d+)$/D', (string) ($daten['tag_name'] ?? ''), $treffer)) {
+            return null;
+        }
+
+        return ['version' => $treffer[1], 'name' => (string) ($daten['name'] ?? ''), 'published' => (string) ($daten['published_at'] ?? '')];
+    }
+}

zentrale/app/Konten.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Zentrale;
+
+/**
+ * Anmeldung: Name und Passwort, gehasht mit password_hash() (bcrypt/argon2 je nach PHP).
+ *
+ * Nach fünf Fehlversuchen in 15 Minuten nimmt diese IP-Adresse eine Viertelstunde lang keine
+ * Anmeldung mehr an.
+ */
+final class Konten
+{
+    private const VERSUCHE = 5;
+    private const SPERRE_SEKUNDEN = 900;
+
+    public function __construct(private \PDO $db)
+    {
+    }
+
+    public function gibtEs(): bool
+    {
+        return (int) $this->db->query('SELECT COUNT(*) FROM konto')->fetchColumn() > 0;
+    }
+
+    public function anlegen(string $name, string $passwort): void
+    {
+        $this->db->prepare('INSERT INTO konto (name, passwort, erstellt) VALUES (?, ?, ?)')
+            ->execute([$name, password_hash($passwort, PASSWORD_DEFAULT), Datenbank::jetzt()]);
+    }
+
+    public function gesperrt(string $ip): bool
+    {
+        $abfrage = $this->db->prepare('SELECT COUNT(*) FROM anmeldeversuch WHERE ip = ? AND zeit > ?');
+        $abfrage->execute([$ip, gmdate('Y-m-d\TH:i:s\Z', time() - self::SPERRE_SEKUNDEN)]);
+
+        return (int) $abfrage->fetchColumn() >= self::VERSUCHE;
+    }
+
+    /** @return array{id: int, name: string}|null */
+    public function pruefen(string $name, string $passwort, string $ip): ?array
+    {
+        $abfrage = $this->db->prepare('SELECT id, name, passwort FROM konto WHERE name = ?');
+        $abfrage->execute([$name]);
+        $konto = $abfrage->fetch() ?: null;
+        // Auch ohne Konto einmal hashen: Die Antwortzeit verrät sonst, welche Namen es gibt.
+        $hash = null !== $konto ? (string) $konto['passwort'] : password_hash('attrappe', PASSWORD_DEFAULT);
+        if (!password_verify($passwort, $hash) || null === $konto) {
+            $this->fehlversuch($ip);
+
+            return null;
+        }
+        if (password_needs_rehash($hash, PASSWORD_DEFAULT)) {
+            $this->db->prepare('UPDATE konto SET passwort = ? WHERE id = ?')->execute([password_hash($passwort, PASSWORD_DEFAULT), $konto['id']]);
+        }
+        $this->db->prepare('DELETE FROM anmeldeversuch WHERE ip = ?')->execute([$ip]);
+
+        return ['id' => (int) $konto['id'], 'name' => (string) $konto['name']];
+    }
+
+    public function fehlversuch(string $ip): void
+    {
+        $this->db->prepare('INSERT INTO anmeldeversuch (ip, zeit) VALUES (?, ?)')->execute([$ip, Datenbank::jetzt()]);
+        $this->db->prepare('DELETE FROM anmeldeversuch WHERE zeit < ?')->execute([gmdate('Y-m-d\TH:i:s\Z', time() - 86400)]);
+    }
+}

zentrale/app/vorlagen/_liste.php

@@ -0,0 +1,66 @@
+<?php /** @var Zentrale\Ansicht $v */ ?>
+<div id="liste" tabindex="-1" data-treffer="<?= $v->e($trefferText) ?>">
+<?php if (0 === $zahlen['alle']) { ?>
+  <div class="karte leer">
+    <h2>Noch keine Meldung</h2>
+    <p>Sobald eine KantSites-Installation ab Fassung 1.36.0 läuft, meldet sie sich hier – spätestens 15 Minuten nach dem ersten Besuch oder Cron-Aufruf.</p>
+  </div>
+<?php } elseif (0 === $treffer) { ?>
+  <div class="karte leer">
+    <h2>Nichts gefunden</h2>
+    <p>Keine Installation passt zu Suche und Filter. <a href="/">Alle anzeigen</a></p>
+  </div>
+<?php } else { ?>
+  <div class="tabelle-rahmen">
+  <table class="tabelle">
+    <caption class="unsichtbar">Gemeldete Installationen, Seite <?= $seite ?> von <?= $seiten ?></caption>
+    <thead>
+      <tr><th scope="col">Domain</th><th scope="col">Kunde</th><th scope="col">Fassung</th><th scope="col">Letzte Meldung</th><th scope="col">Zustand</th><th scope="col"><span class="unsichtbar">Aktion</span></th></tr>
+    </thead>
+    <tbody>
+    <?php foreach ($installationen as $i) { ?>
+      <tr>
+        <th scope="row" data-label="Domain"><a href="/installation?id=<?= $v->e(rawurlencode($i['id'])) ?>"><?= $v->e($i['domain']) ?></a>
+          <?php if (null !== $i['domain_vorher']) { ?><span class="klein">vorher <?= $v->e($i['domain_vorher']) ?></span><?php } ?></th>
+        <td data-label="Kunde"><?= $i['unbekannt'] ? '<span class="marke-fremd">Unbekannt</span>' : $v->e($i['notiz']) ?></td>
+        <td data-label="Fassung"><span class="fassung <?= $i['veraltet'] ? 'f-alt' : 'f-ok' ?>"><?= $v->e($i['fassung']) ?></span><?php if ('git' === $i['art']) { ?> <span class="klein">Git</span><?php } ?></td>
+        <td data-label="Letzte Meldung"><span class="<?= $i['still'] ? 'still' : '' ?>"><?= $v->e($v->vor($i['alter'])) ?></span></td>
+        <td data-label="Zustand">
+          <?php if ($i['wartung']) { ?><span class="pille p-warn">Wartung</span> <?php } ?>
+          <?php if (null !== $i['auftrag_zustand']) { ?><span class="pille p-<?= $v->e($i['auftrag_zustand']['art']) ?>"><?= $v->e($i['auftrag_zustand']['text']) ?></span><?php } elseif (!$i['wartung']) { ?><span class="klein">–</span><?php } ?>
+        </td>
+        <td class="aktion">
+          <?php if ($i['kann_update'] && null !== $neueste && 'wartet' !== ($i['auftrag_zustand']['art'] ?? null)) { ?>
+            <form method="post" action="/auftrag">
+              <?= $v->csrf() ?>
+              <input type="hidden" name="id" value="<?= $v->e($i['id']) ?>">
+              <button type="submit" class="knopf knopf-klein">Auf <?= $v->e($neueste['version']) ?><span class="unsichtbar"> aktualisieren: <?= $v->e($i['domain']) ?></span></button>
+            </form>
+          <?php } ?>
+        </td>
+      </tr>
+    <?php } ?>
+    </tbody>
+  </table>
+  </div>
+  <?php if ($seiten > 1) { ?>
+    <nav class="seiten" aria-label="Seiten">
+      <?php $basis = ['q' => $suche, 'filter' => $filter]; ?>
+      <?php if ($seite > 1) { ?><a class="knopf knopf-leise" href="<?= $v->e($v->adresse([...$basis, 'seite' => $seite - 1])) ?>" rel="prev">← Zurück</a><?php } ?>
+      <ul>
+        <?php
+        // Erste, letzte und zwei um die aktuelle; dazwischen Auslassungen.
+        $zeigen = array_unique(array_filter([1, $seite - 2, $seite - 1, $seite, $seite + 1, $seite + 2, $seiten], static fn (int $n): bool => $n >= 1 && $n <= $seiten));
+        sort($zeigen);
+        $vorher = 0;
+        foreach ($zeigen as $n) {
+            if ($n > $vorher + 1) { ?><li aria-hidden="true">…</li><?php }
+            $vorher = $n; ?>
+          <li><?php if ($n === $seite) { ?><span aria-current="page"><span class="unsichtbar">Seite </span><?= $n ?></span><?php } else { ?><a href="<?= $v->e($v->adresse([...$basis, 'seite' => $n])) ?>"><span class="unsichtbar">Seite </span><?= $n ?></a><?php } ?></li>
+        <?php } ?>
+      </ul>
+      <?php if ($seite < $seiten) { ?><a class="knopf knopf-leise" href="<?= $v->e($v->adresse([...$basis, 'seite' => $seite + 1])) ?>" rel="next">Weiter →</a><?php } ?>
+    </nav>
+  <?php } ?>
+<?php } ?>
+</div>

zentrale/app/vorlagen/anmelden.php

@@ -0,0 +1,13 @@
+<?php /** @var Zentrale\Ansicht $v */ ?>
+<div class="schmal karte">
+  <h1>Anmelden</h1>
+  <?php if (null !== $fehler) { ?><p class="hinweis hinweis-fehler" role="alert" id="fehler"><?= $v->e($fehler) ?></p><?php } ?>
+  <form method="post" action="/anmelden">
+    <?= $v->csrf() ?>
+    <label for="name">Name</label>
+    <input id="name" name="name" type="text" autocomplete="username" required value="<?= $v->e($name) ?>" <?= null !== $fehler ? 'aria-describedby="fehler"' : '' ?>>
+    <label for="passwort">Passwort</label>
+    <input id="passwort" name="passwort" type="password" autocomplete="current-password" required>
+    <button type="submit" class="knopf abstand">Anmelden</button>
+  </form>
+</div>

zentrale/app/vorlagen/einrichten.php

@@ -0,0 +1,19 @@
+<?php /** @var Zentrale\Ansicht $v */ ?>
+<div class="schmal karte">
+  <h1>Zentrale einrichten</h1>
+  <p>Es gibt noch kein Konto. Lege das erste an – dafür brauchst du den Einrichtungscode aus <code>config.php</code>.</p>
+  <?php if (null !== $fehler) { ?><p class="hinweis hinweis-fehler" role="alert"><?= $v->e($fehler) ?></p><?php } ?>
+  <form method="post" action="/">
+    <?= $v->csrf() ?>
+    <label for="code">Einrichtungscode</label>
+    <input id="code" name="code" type="password" autocomplete="off" required>
+    <label for="name">Name</label>
+    <input id="name" name="name" type="text" autocomplete="username" required minlength="3" maxlength="60" value="<?= $v->e($name) ?>">
+    <label for="passwort">Passwort</label>
+    <p class="feldhilfe" id="pw-hilfe">Mindestens 12 Zeichen.</p>
+    <input id="passwort" name="passwort" type="password" autocomplete="new-password" required minlength="12" aria-describedby="pw-hilfe">
+    <label for="passwort2">Passwort wiederholen</label>
+    <input id="passwort2" name="passwort2" type="password" autocomplete="new-password" required minlength="12">
+    <button type="submit" class="knopf abstand">Konto anlegen</button>
+  </form>
+</div>

zentrale/app/vorlagen/fehlt.php

@@ -0,0 +1,5 @@
+<?php /** @var Zentrale\Ansicht $v */ ?>
+<div class="schmal karte">
+  <h1>Nicht gefunden</h1>
+  <p>Diese Seite gibt es nicht. <a href="/">Zur Übersicht</a></p>
+</div>

zentrale/app/vorlagen/installation.php

@@ -0,0 +1,100 @@
+<?php /** @var Zentrale\Ansicht $v */ ?>
+<p class="zurueck"><a href="/">← Alle Installationen</a></p>
+<div class="titelzeile">
+  <h1><?= $v->e($i['domain']) ?></h1>
+  <?php if ($i['unbekannt']) { ?><span class="marke-fremd">Unbekannt</span><?php } ?>
+</div>
+
+<div class="raster">
+  <section class="karte" aria-labelledby="t-stand">
+    <h2 id="t-stand">Stand</h2>
+    <dl class="fakten">
+      <dt>Adresse</dt><dd><a href="<?= $v->e($i['adresse']) ?>" rel="noopener noreferrer"><?= $v->e($i['adresse']) ?></a></dd>
+      <?php if (null !== $i['domain_vorher']) { ?><dt>Vorher gemeldet als</dt><dd><?= $v->e($i['domain_vorher']) ?></dd><?php } ?>
+      <dt>Fassung</dt><dd><span class="fassung <?= $i['veraltet'] ? 'f-alt' : 'f-ok' ?>"><?= $v->e($i['fassung']) ?></span><?= $i['veraltet'] && null !== $neueste ? ' – neueste ist '.$v->e($neueste['version']) : '' ?></dd>
+      <dt>Aktualisiert über</dt><dd><?= 'git' === $i['art'] ? 'Git-Arbeitskopie' : 'Releasearchiv' ?></dd>
+      <dt>PHP</dt><dd><?= $v->e($i['php'] ?: '–') ?></dd>
+      <dt>Datenbank</dt><dd><?= $v->e($i['datenbank'] ?: '–') ?></dd>
+      <dt>Wartungsseite</dt><dd><?= $i['wartung'] ? 'an' : 'aus' ?></dd>
+      <dt>Letzte Meldung</dt><dd><?= $v->e($v->zeit($i['letzte_meldung'])) ?> (<?= $v->e($v->vor($i['alter'])) ?>)<?= $i['still'] ? ' – <strong>seit über 48 Stunden still</strong>' : '' ?></dd>
+      <dt>Erste Meldung</dt><dd><?= $v->e($v->zeit($i['erste_meldung'])) ?></dd>
+      <dt>IP-Adresse</dt><dd><?= $v->e($i['ip'] ?: '–') ?></dd>
+      <?php if (null !== $i['update_phase']) { ?>
+        <dt>Letztes Update</dt><dd><?= $v->e($i['update_meldung']) ?> <span class="klein">(<?= $v->e($v->zeit($i['update_zeit'])) ?>)</span></dd>
+      <?php } ?>
+    </dl>
+  </section>
+
+  <section class="karte" aria-labelledby="t-update">
+    <h2 id="t-update">Update</h2>
+    <?php if (null !== $i['auftrag_zustand']) { ?>
+      <p><span class="pille p-<?= $v->e($i['auftrag_zustand']['art']) ?>"><?= $v->e($i['auftrag_zustand']['text']) ?></span></p>
+    <?php } ?>
+    <?php if ('wartet' === ($i['auftrag_zustand']['art'] ?? null)) { ?>
+      <p>Die Website holt den Auftrag mit ihrer nächsten Meldung ab – meist innerhalb von 15 Minuten.</p>
+    <?php } elseif ($i['kann_update'] && null !== $neueste) { ?>
+      <form method="post" action="/auftrag">
+        <?= $v->csrf() ?>
+        <input type="hidden" name="id" value="<?= $v->e($i['id']) ?>">
+        <input type="hidden" name="zurueck" value="detail">
+        <p>Die Website holt den Auftrag mit ihrer nächsten Meldung ab, legt eine Sicherung an, spielt <?= $v->e($neueste['version']) ?> ein und schaltet bei einem Fehler zurück.</p>
+        <button type="submit" class="knopf">Auf <?= $v->e($neueste['version']) ?> aktualisieren</button>
+      </form>
+    <?php } else { ?>
+      <p><?= $v->e($i['kein_update_grund']) ?></p>
+    <?php } ?>
+    <?php if (null !== $i['auftrag'] && null === $i['auftrag']['abgeholt'] && null === $i['auftrag']['erledigt']) { ?>
+      <form method="post" action="/auftrag/zurueckziehen" class="abstand">
+        <?= $v->csrf() ?>
+        <input type="hidden" name="id" value="<?= $v->e($i['id']) ?>">
+        <button type="submit" class="knopf knopf-leise">Auftrag zurückziehen</button>
+      </form>
+    <?php } ?>
+  </section>
+
+  <section class="karte" aria-labelledby="t-kunde">
+    <h2 id="t-kunde">Kunde</h2>
+    <form method="post" action="/notiz">
+      <?= $v->csrf() ?>
+      <input type="hidden" name="id" value="<?= $v->e($i['id']) ?>">
+      <label for="notiz">Kunde oder Notiz</label>
+      <p class="feldhilfe" id="notiz-hilfe">Installationen ohne Eintrag stehen in der Übersicht als „Unbekannt“ – so fällt eine fremde Nutzung auf.</p>
+      <input id="notiz" name="notiz" type="text" maxlength="200" value="<?= $v->e($i['notiz']) ?>" aria-describedby="notiz-hilfe">
+      <button type="submit" class="knopf abstand">Speichern</button>
+    </form>
+  </section>
+</div>
+
+<section class="karte" aria-labelledby="t-verlauf">
+  <h2 id="t-verlauf">Aufträge</h2>
+  <?php if ([] === $i['verlauf']) { ?>
+    <p>Noch kein Auftrag.</p>
+  <?php } else { ?>
+    <div class="tabelle-rahmen">
+    <table class="tabelle">
+      <thead><tr><th scope="col">Beauftragt</th><th scope="col">Fassung</th><th scope="col">Abgeholt</th><th scope="col">Ergebnis</th></tr></thead>
+      <tbody>
+      <?php foreach ($i['verlauf'] as $a) { ?>
+        <tr>
+          <td data-label="Beauftragt"><?= $v->e($v->zeit($a['erstellt'])) ?></td>
+          <td data-label="Fassung"><?= $v->e($a['fassung']) ?></td>
+          <td data-label="Abgeholt"><?= $v->e($v->zeit($a['abgeholt'])) ?></td>
+          <td data-label="Ergebnis"><span class="pille p-<?= $v->e($a['zustand']['art']) ?>"><?= $v->e($a['zustand']['text']) ?></span><?php if ('' !== (string) $a['meldung']) { ?><span class="klein block"><?= $v->e($a['meldung']) ?></span><?php } ?></td>
+        </tr>
+      <?php } ?>
+      </tbody>
+    </table>
+    </div>
+  <?php } ?>
+</section>
+
+<details class="karte gefahr">
+  <summary>Eintrag entfernen</summary>
+  <form method="post" action="/entfernen">
+    <?= $v->csrf() ?>
+    <input type="hidden" name="id" value="<?= $v->e($i['id']) ?>">
+    <p>Entfernt die Installation und ihre Aufträge aus dieser Liste. An der Website ändert sich nichts; meldet sie sich wieder, erscheint sie neu.</p>
+    <label class="bestaetigen"><input type="checkbox" name="bestaetigt" value="ja" required> Ja, <?= $v->e($i['domain']) ?> aus der Liste entfernen</label>
+    <button type="submit" class="knopf knopf-gefahr">Entfernen</button>
+  </form>
+</details>

zentrale/app/vorlagen/rahmen.php

@@ -0,0 +1,34 @@
+<?php /** @var Zentrale\Ansicht $v */ ?>
+<!doctype html>
+<html lang="de">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="robots" content="noindex, nofollow">
+<title><?= $v->e($titel) ?> · KantSites Zentrale</title>
+<link rel="stylesheet" href="/app.css?v=3">
+<script src="/app.js?v=1" defer></script>
+<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='7' fill='%23173f6b'/%3E%3Cpath d='M9 8v16M9 16l9-8M12.5 13l7 11' stroke='%23fff' stroke-width='3.2' fill='none' stroke-linecap='round'/%3E%3C/svg%3E">
+</head>
+<body>
+<a class="skip" href="#inhalt">Zum Inhalt</a>
+<header class="kopf">
+  <div class="kopf-innen">
+    <a class="marke" href="/"><span class="marke-zeichen" aria-hidden="true">K</span> KantSites <span>Zentrale</span></a>
+    <?php if (null !== $konto) { ?>
+      <form method="post" action="/abmelden" class="abmelden">
+        <?= $v->csrf() ?>
+        <span class="wer"><?= $v->e($konto['name']) ?></span>
+        <button type="submit" class="knopf knopf-leise">Abmelden</button>
+      </form>
+    <?php } ?>
+  </div>
+</header>
+<main id="inhalt" class="seite" tabindex="-1">
+  <?php if (null !== $hinweis) { ?>
+    <p class="hinweis hinweis-<?= $v->e($hinweis['art']) ?>" role="<?= 'fehler' === $hinweis['art'] ? 'alert' : 'status' ?>"><?= $v->e($hinweis['text']) ?></p>
+  <?php } ?>
+  <?= $inhalt ?>
+</main>
+</body>
+</html>

zentrale/app/vorlagen/uebersicht.php

@@ -0,0 +1,54 @@
+<?php /** @var Zentrale\Ansicht $v */ ?>
+<div class="titelzeile">
+  <h1>Installationen</h1>
+  <form method="post" action="/fassung" class="neueste">
+    <?= $v->csrf() ?>
+    <span>Neueste Fassung: <strong><?= null === $neueste ? 'unbekannt' : $v->e($neueste['version']) ?></strong></span>
+    <button type="submit" class="knopf knopf-leise">Neu abfragen</button>
+  </form>
+</div>
+
+<?php
+$kacheln = [
+    null => ['', 'gesamt', $zahlen['alle']],
+    'aktuell' => ['z-ok', 'aktuell', $zahlen['aktuell'] ?? '–'],
+    'veraltet' => ['z-warn', 'veraltet', $zahlen['veraltet']],
+    'still' => ['z-still', 'ohne Meldung seit 48 h', $zahlen['still']],
+    'unbekannt' => ['z-fremd', 'ohne Kundenzuordnung', $zahlen['unbekannt']],
+];
+?>
+<nav aria-label="Nach Zustand filtern">
+  <ul class="zahlen">
+    <?php foreach ($kacheln as $name => [$klasse, $text, $zahl]) { $aktiv = ($filter ?? '') === $name; ?>
+      <li class="<?= $klasse ?><?= $aktiv ? ' gewaehlt' : '' ?>"><a href="<?= $v->e($v->adresse(['q' => $suche, 'filter' => '' === $name ? null : $name])) ?>"<?= $aktiv ? ' aria-current="true"' : '' ?>><strong><?= $v->e($zahl) ?></strong> <?= $v->e($text) ?></a></li>
+    <?php } ?>
+  </ul>
+</nav>
+
+<?php if ([] !== $aktualisierbar && null !== $neueste) { ?>
+  <form method="post" action="/auftrag/alle" class="karte alle">
+    <?= $v->csrf() ?>
+    <div>
+      <h2>Alle auf <?= $v->e($neueste['version']) ?> aktualisieren</h2>
+      <?php $namen = array_column($aktualisierbar, 'domain'); ?>
+      <p><?= count($aktualisierbar) ?> Installation(en): <?= $v->e(implode(', ', array_slice($namen, 0, 8))) ?><?= count($namen) > 8 ? ' und '.(count($namen) - 8).' weitere' : '' ?>. Jede holt den Auftrag mit ihrer nächsten Meldung ab, sichert sich vorher und schaltet bei einem Fehler zurück.</p>
+      <label class="bestaetigen"><input type="checkbox" name="bestaetigt" value="ja" required> Ja, alle <?= count($aktualisierbar) ?> aktualisieren</label>
+    </div>
+    <button type="submit" class="knopf">Alle aktualisieren</button>
+  </form>
+<?php } ?>
+
+<?php if ($zahlen['alle'] > 0) { ?>
+  <form method="get" action="/" class="suche" role="search">
+    <?php if (null !== $filter) { ?><input type="hidden" name="filter" value="<?= $v->e($filter) ?>"><?php } ?>
+    <label for="q">Suchen</label>
+    <div class="suche-zeile">
+      <input id="q" name="q" type="search" value="<?= $v->e($suche) ?>" placeholder="Domain, Kunde, Fassung oder IP" autocomplete="off" aria-describedby="treffer" aria-controls="liste">
+      <button type="submit" class="knopf">Suchen</button>
+      <a class="knopf knopf-leise zuruecksetzen" href="/"<?= '' === $suche && null === $filter ? ' hidden' : '' ?>>Zurücksetzen</a>
+    </div>
+    <p class="klein" id="treffer" role="status"><?= $v->e($trefferText) ?></p>
+  </form>
+<?php } ?>
+
+<?php require __DIR__.'/_liste.php'; ?>

zentrale/config.example.php

@@ -0,0 +1,13 @@
+<?php
+
+// Als config.php neben diese Datei kopieren und den Einrichtungscode setzen.
+// config.php gehört nicht ins Repository.
+
+return [
+    // Nur für das erste Konto: Wer ihn kennt, kann das erste Konto anlegen. Danach wird er nicht
+    // mehr gebraucht. Mindestens 16 Zeichen, zufällig - etwa aus einem Passwortmanager.
+    'einrichtungscode' => '',
+
+    // Wo die neueste KantSites-Fassung steht. Dieselbe Releaseseite fragen die Installationen.
+    'releases_api' => 'https://git.kant-it.de/api/v1/repos/kantarci/KantSites',
+];

zentrale/public/.htaccess

@@ -0,0 +1,15 @@
+Options -Indexes
+DirectoryIndex index.php
+
+<IfModule mod_rewrite.c>
+    RewriteEngine On
+    RewriteCond %{HTTPS} off
+    RewriteCond %{HTTP_HOST} !^(localhost|127\.0\.0\.1)(:\d+)?$
+    RewriteRule ^ https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]
+    RewriteCond %{REQUEST_FILENAME} !-f
+    RewriteRule ^ index.php [L]
+</IfModule>
+
+<IfModule mod_headers.c>
+    Header always set Strict-Transport-Security "max-age=31536000" "expr=%{HTTPS} == 'on'"
+</IfModule>

zentrale/public/app.css

@@ -0,0 +1,183 @@
+:root {
+  --grund: #f4f6f9;
+  --flaeche: #ffffff;
+  --text: #17202b;
+  --leise: #5a6575;
+  --linie: #dde3ea;
+  --marke: #173f6b;
+  --marke-hell: #e6eef7;
+  --ok: #17663a;
+  --ok-grund: #e3f4e9;
+  --warn: #8a4b00;
+  --warn-grund: #fdf0dc;
+  --fehler: #a4161a;
+  --fehler-grund: #fde7e7;
+  --still: #5b4a8a;
+  --still-grund: #eeeaf8;
+  --fokus: #1f6feb;
+  --radius: 10px;
+  color-scheme: light;
+}
+
+* { box-sizing: border-box; }
+
+[hidden] { display: none !important; }
+
+html { -webkit-text-size-adjust: 100%; }
+
+body {
+  margin: 0;
+  background: var(--grund);
+  color: var(--text);
+  font: 15px/1.55 system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+}
+
+a { color: var(--marke); text-underline-offset: 2px; }
+a:hover { text-decoration-thickness: 2px; }
+
+:focus-visible { outline: 3px solid var(--fokus); outline-offset: 2px; border-radius: 4px; }
+
+h1 { font-size: 1.6rem; line-height: 1.25; margin: 0; }
+h2 { font-size: 1.05rem; margin: 0 0 .6rem; }
+p { margin: 0 0 .8rem; }
+code { background: var(--marke-hell); padding: 1px 5px; border-radius: 4px; font-size: .92em; }
+
+.skip { position: absolute; left: -9999px; top: 8px; background: var(--flaeche); padding: 8px 12px; border-radius: 6px; z-index: 10; }
+.skip:focus { left: 16px; }
+
+.unsichtbar { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); white-space: nowrap; }
+
+.kopf { background: var(--marke); color: #fff; }
+.kopf-innen { max-width: 1180px; margin: 0 auto; padding: 12px 16px; display: flex; align-items: center; justify-content: space-between; gap: 12px; flex-wrap: wrap; }
+.marke { color: #fff; text-decoration: none; font-weight: 700; font-size: 1.05rem; display: inline-flex; align-items: center; gap: 10px; }
+.marke span:last-child { font-weight: 400; opacity: .85; }
+.marke-zeichen { display: inline-grid; place-items: center; width: 30px; height: 30px; border-radius: 7px; background: #fff; color: var(--marke); font-weight: 800; }
+.abmelden { display: flex; align-items: center; gap: 10px; margin: 0; }
+.wer { font-size: .9rem; opacity: .9; }
+.kopf .knopf-leise { color: #fff; border-color: rgba(255, 255, 255, .5); background: transparent; }
+.kopf .knopf-leise:hover { background: rgba(255, 255, 255, .12); }
+.kopf :focus-visible { outline-color: #fff; }
+
+.seite { max-width: 1180px; margin: 0 auto; padding: 24px 16px 48px; }
+.seite:focus { outline: none; }
+
+.titelzeile { display: flex; align-items: center; justify-content: space-between; gap: 12px 20px; flex-wrap: wrap; margin-bottom: 18px; }
+.neueste { display: flex; align-items: center; gap: 10px; margin: 0; color: var(--leise); flex-wrap: wrap; }
+.neueste strong { color: var(--text); }
+.zurueck { margin-bottom: 8px; }
+
+.karte { background: var(--flaeche); border: 1px solid var(--linie); border-radius: var(--radius); padding: 18px 20px; margin-bottom: 18px; }
+.schmal { max-width: 440px; margin: 32px auto; }
+.schmal h1 { margin-bottom: 14px; }
+.raster { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 0 18px; align-items: start; }
+
+.zahlen { list-style: none; padding: 0; margin: 0 0 18px; display: flex; flex-wrap: wrap; gap: 10px; }
+.zahlen li { flex: 1 1 110px; background: var(--flaeche); border: 1px solid var(--linie); border-radius: var(--radius); padding: 10px 14px; color: var(--leise); font-size: .9rem; }
+.zahlen strong { display: block; font-size: 1.35rem; color: var(--text); line-height: 1.2; }
+.zahlen a { display: block; margin: -10px -14px; padding: 10px 14px; color: inherit; text-decoration: none; border-radius: inherit; }
+.zahlen a:hover { background: var(--marke-hell); }
+.zahlen li.gewaehlt { border-color: var(--marke); box-shadow: inset 0 0 0 1px var(--marke); }
+.z-ok strong { color: var(--ok); }
+.z-warn strong { color: var(--warn); }
+.z-still strong { color: var(--still); }
+.z-fremd strong { color: var(--fehler); }
+
+.alle { display: flex; align-items: flex-end; justify-content: space-between; gap: 16px; flex-wrap: wrap; border-left: 4px solid var(--marke); }
+.alle > div { flex: 1 1 420px; }
+.alle p { color: var(--leise); }
+.bestaetigen { display: flex; align-items: center; gap: 8px; font-weight: 600; margin: 4px 0 0; }
+.bestaetigen input { width: 18px; height: 18px; margin: 0; accent-color: var(--marke); }
+
+.tabelle-rahmen { background: var(--flaeche); border: 1px solid var(--linie); border-radius: var(--radius); overflow: hidden; }
+.karte .tabelle-rahmen { border: 0; border-radius: 0; }
+.tabelle { width: 100%; border-collapse: collapse; }
+.tabelle th, .tabelle td { text-align: left; padding: 11px 14px; border-bottom: 1px solid var(--linie); vertical-align: middle; }
+.tabelle thead th { font-size: .8rem; text-transform: uppercase; letter-spacing: .04em; color: var(--leise); background: #f9fafc; font-weight: 600; }
+.tabelle tbody tr:last-child > * { border-bottom: 0; }
+.tabelle tbody th { font-weight: 600; }
+.tabelle tbody tr:hover { background: #fafbfd; }
+.aktion { text-align: right; white-space: nowrap; }
+.aktion form { margin: 0; }
+
+.klein { color: var(--leise); font-size: .85rem; }
+.block { display: block; margin-top: 3px; }
+th .klein { display: block; font-weight: 400; }
+.still { color: var(--still); font-weight: 600; }
+
+.fassung { font-variant-numeric: tabular-nums; font-weight: 600; padding: 2px 8px; border-radius: 999px; font-size: .9rem; }
+.f-ok { background: var(--ok-grund); color: var(--ok); }
+.f-alt { background: var(--warn-grund); color: var(--warn); }
+
+.pille { display: inline-block; padding: 2px 9px; border-radius: 999px; font-size: .85rem; font-weight: 600; }
+.p-ok { background: var(--ok-grund); color: var(--ok); }
+.p-fehler { background: var(--fehler-grund); color: var(--fehler); }
+.p-warn, .p-wartet { background: var(--warn-grund); color: var(--warn); }
+.p-laeuft { background: var(--marke-hell); color: var(--marke); }
+.marke-fremd { display: inline-block; padding: 2px 9px; border-radius: 999px; font-size: .85rem; font-weight: 700; background: var(--fehler-grund); color: var(--fehler); }
+
+.fakten { display: grid; grid-template-columns: max-content 1fr; gap: 6px 16px; margin: 0; }
+.fakten dt { color: var(--leise); }
+.fakten dd { margin: 0; overflow-wrap: anywhere; }
+
+label { display: block; font-weight: 600; margin: 12px 0 4px; }
+.feldhilfe { color: var(--leise); font-size: .88rem; margin: -2px 0 6px; }
+input[type="text"], input[type="password"] {
+  width: 100%; font: inherit; font-size: 16px; padding: 9px 11px; border: 1px solid #b9c3cf; border-radius: 8px; background: #fff; color: var(--text);
+}
+input[type="text"]:focus-visible, input[type="password"]:focus-visible { border-color: var(--fokus); }
+
+.knopf {
+  display: inline-flex; align-items: center; justify-content: center; gap: 6px; min-height: 40px; padding: 8px 16px;
+  font: inherit; font-weight: 600; color: #fff; background: var(--marke); border: 1px solid var(--marke); border-radius: 8px; cursor: pointer;
+}
+.knopf:hover { background: #0f2f52; }
+.knopf-klein { min-height: 34px; padding: 5px 12px; font-size: .9rem; }
+.knopf-leise { background: var(--flaeche); color: var(--marke); border-color: #b9c3cf; min-height: 34px; padding: 5px 12px; font-size: .9rem; }
+.knopf-leise:hover { background: var(--marke-hell); }
+.knopf-gefahr { background: var(--fehler); border-color: var(--fehler); }
+.knopf-gefahr:hover { background: #7f1013; }
+.abstand { margin-top: 14px; }
+
+.hinweis { padding: 10px 14px; border-radius: 8px; margin-bottom: 18px; font-weight: 500; }
+.hinweis-ok { background: var(--ok-grund); color: var(--ok); }
+.hinweis-fehler { background: var(--fehler-grund); color: var(--fehler); }
+
+.gefahr summary { cursor: pointer; font-weight: 600; color: var(--fehler); }
+.gefahr[open] summary { margin-bottom: 10px; }
+.gefahr .knopf { margin-top: 12px; }
+
+.leer p { color: var(--leise); margin: 0; }
+
+.suche { margin-bottom: 14px; }
+.suche label { margin-top: 0; }
+.suche-zeile { display: flex; gap: 8px; flex-wrap: wrap; }
+.suche-zeile input { flex: 1 1 260px; width: auto; font: inherit; font-size: 16px; padding: 9px 11px; border: 1px solid #b9c3cf; border-radius: 8px; background: #fff; color: var(--text); }
+.suche-zeile .knopf-leise { min-height: 40px; text-decoration: none; }
+.suche .klein { margin: 8px 0 0; }
+
+.seiten { display: flex; align-items: center; justify-content: center; gap: 8px; flex-wrap: wrap; margin-top: 16px; }
+.seiten .knopf-leise { text-decoration: none; }
+.seiten ul { list-style: none; display: flex; gap: 4px; margin: 0; padding: 0; flex-wrap: wrap; }
+.seiten li a, .seiten li span[aria-current] { display: inline-grid; place-items: center; min-width: 36px; min-height: 36px; padding: 0 8px; border-radius: 8px; text-decoration: none; }
+.seiten li a { color: var(--marke); border: 1px solid var(--linie); background: var(--flaeche); }
+.seiten li a:hover { background: var(--marke-hell); }
+.seiten li span[aria-current] { background: var(--marke); color: #fff; font-weight: 700; }
+.seiten li[aria-hidden] { align-self: center; color: var(--leise); padding: 0 2px; }
+
+@media (max-width: 760px) {
+  h1 { font-size: 1.35rem; }
+  .karte { padding: 16px; }
+  .tabelle thead { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); }
+  .tabelle, .tabelle tbody, .tabelle tr, .tabelle th, .tabelle td { display: block; width: 100%; }
+  .tabelle tr { padding: 10px 14px; border-bottom: 1px solid var(--linie); }
+  .tabelle tbody tr:last-child { border-bottom: 0; }
+  .tabelle th, .tabelle td { border: 0; padding: 3px 0; }
+  .tabelle td[data-label]::before { content: attr(data-label) ": "; color: var(--leise); font-size: .85rem; }
+  .tabelle tbody th { font-size: 1.05rem; padding-bottom: 6px; }
+  .aktion { text-align: left; padding-top: 8px !important; }
+  .fakten { grid-template-columns: 1fr; gap: 0; }
+  .fakten dd { margin-bottom: 8px; }
+}
+
+#liste:focus { outline: none; }
+#liste[aria-busy="true"] { opacity: .6; transition: opacity .15s; }

zentrale/public/app.js

@@ -0,0 +1,118 @@
+// Live-Suche der Übersicht: Tippen, Filter und Seitenwechsel laden nur die Liste nach.
+// Ohne JavaScript bleibt alles ein gewöhnliches Formular mit Links.
+(() => {
+  const form = document.querySelector('form.suche');
+  const liste = document.getElementById('liste');
+  if (!form || !liste || !window.fetch || !window.URL) {
+    return;
+  }
+  const feld = form.querySelector('#q');
+  const status = document.getElementById('treffer');
+  const zuruecksetzen = form.querySelector('.zuruecksetzen');
+  const knopf = form.querySelector('button[type="submit"]');
+  const filterFeld = () => form.querySelector('input[name="filter"]');
+  knopf.hidden = true;
+
+  let warten = 0;
+  let laufend = null;
+
+  /** Die Adresse aus Suchfeld und Filter, ohne leere Werte. */
+  const adresseAusFormular = () => {
+    const url = new URL(form.action, location.href);
+    const q = feld.value.trim();
+    if (q !== '') url.searchParams.set('q', q);
+    const filter = filterFeld();
+    if (filter && filter.value !== '') url.searchParams.set('filter', filter.value);
+    return url;
+  };
+
+  /** Kacheln und Filterfeld an Suche und Filter der neuen Adresse angleichen. */
+  const umgebungAnpassen = (url) => {
+    const q = url.searchParams.get('q') || '';
+    const filter = url.searchParams.get('filter') || '';
+    document.querySelectorAll('.zahlen a').forEach((a) => {
+      const ziel = new URL(a.href, location.href);
+      if (q === '') ziel.searchParams.delete('q'); else ziel.searchParams.set('q', q);
+      ziel.searchParams.delete('seite');
+      a.href = ziel.pathname + ziel.search;
+      const gewaehlt = (ziel.searchParams.get('filter') || '') === filter;
+      a.parentElement.classList.toggle('gewaehlt', gewaehlt);
+      if (gewaehlt) a.setAttribute('aria-current', 'true'); else a.removeAttribute('aria-current');
+    });
+    let feldFilter = filterFeld();
+    if (filter !== '' && !feldFilter) {
+      feldFilter = document.createElement('input');
+      feldFilter.type = 'hidden';
+      feldFilter.name = 'filter';
+      form.prepend(feldFilter);
+    }
+    if (feldFilter) {
+      if (filter === '') feldFilter.remove(); else feldFilter.value = filter;
+    }
+    if (feld.value.trim() !== q) feld.value = q;
+    zuruecksetzen.hidden = q === '' && filter === '';
+  };
+
+  const laden = (url, verlauf) => {
+    if (laufend) laufend.abort();
+    laufend = new AbortController();
+    const abruf = new URL(url, location.href);
+    abruf.searchParams.set('teil', 'liste');
+    liste.setAttribute('aria-busy', 'true');
+    fetch(abruf, { signal: laufend.signal, credentials: 'same-origin', headers: { Accept: 'text/html' } })
+      .then((antwort) => {
+        // Abgelaufene Sitzung: Die Antwort ist die Anmeldeseite, nicht die Liste.
+        if (!antwort.ok || antwort.redirected) throw new Error('voll');
+        return antwort.text();
+      })
+      .then((html) => {
+        const neu = new DOMParser().parseFromString(html, 'text/html').getElementById('liste');
+        if (!neu) throw new Error('voll');
+        liste.replaceChildren(...neu.childNodes);
+        liste.dataset.treffer = neu.dataset.treffer || '';
+        status.textContent = liste.dataset.treffer;
+        const sichtbar = new URL(url, location.href);
+        if (verlauf === 'push') history.pushState(null, '', sichtbar.pathname + sichtbar.search);
+        else if (verlauf === 'replace') history.replaceState(null, '', sichtbar.pathname + sichtbar.search);
+        umgebungAnpassen(sichtbar);
+      })
+      .catch((fehler) => {
+        if (fehler.name !== 'AbortError') location.href = url.toString();
+      })
+      .finally(() => liste.removeAttribute('aria-busy'));
+  };
+
+  feld.addEventListener('input', () => {
+    clearTimeout(warten);
+    warten = setTimeout(() => laden(adresseAusFormular(), 'replace'), 250);
+  });
+
+  form.addEventListener('submit', (ereignis) => {
+    ereignis.preventDefault();
+    clearTimeout(warten);
+    laden(adresseAusFormular(), 'replace');
+  });
+
+  zuruecksetzen.addEventListener('click', (ereignis) => {
+    ereignis.preventDefault();
+    feld.value = '';
+    const filter = filterFeld();
+    if (filter) filter.remove();
+    laden(new URL('/', location.href), 'push');
+    feld.focus();
+  });
+
+  // Filterkacheln und Seitenzahlen: nur die Liste wechseln.
+  document.addEventListener('click', (ereignis) => {
+    const link = ereignis.target.closest('.zahlen a, #liste .seiten a');
+    if (!link || ereignis.ctrlKey || ereignis.metaKey || ereignis.shiftKey || ereignis.button !== 0) return;
+    ereignis.preventDefault();
+    laden(new URL(link.href, location.href), 'push');
+    if (link.closest('.seiten')) {
+      form.scrollIntoView({ block: 'start' });
+      liste.focus({ preventScroll: true });
+    }
+  });
+
+  window.addEventListener('popstate', () => laden(new URL(location.href), null));
+})();

zentrale/public/index.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+$wurzel = dirname(__DIR__);
+
+// Der eingebaute Server von PHP liefert Dateien aus public/ selbst aus.
+if ('cli-server' === PHP_SAPI && is_file(__DIR__.parse_url((string) $_SERVER['REQUEST_URI'], PHP_URL_PATH))) {
+    return false;
+}
+
+if (PHP_VERSION_ID < 80100) {
+    http_response_code(500);
+    header('Content-Type: text/plain; charset=UTF-8');
+    echo "Die Zentrale braucht PHP 8.1 oder neuer.\n";
+    exit;
+}
+
+spl_autoload_register(static function (string $klasse) use ($wurzel): void {
+    if (str_starts_with($klasse, 'Zentrale\\')) {
+        $datei = $wurzel.'/app/'.substr($klasse, 9).'.php';
+        if (is_file($datei)) {
+            require $datei;
+        }
+    }
+});
+
+$config = is_file($wurzel.'/config.php') ? require $wurzel.'/config.php' : [];
+$config = is_array($config) ? $config : [];
+$config += ['releases_api' => 'https://git.kant-it.de/api/v1/repos/kantarci/KantSites', 'einrichtungscode' => ''];
+
+(new Zentrale\Anwendung($config, $wurzel))->bearbeiten();

zentrale/var/.htaccess

@@ -0,0 +1 @@
+Require all denied