Merge branch 'phase/027-rollen'

Drei Rollen: Administrator, Techniker, Kunde. Jede der 28 Aktionen nennt das
Recht, das sie verlangt; die Rechte stehen an einer Stelle. Kundenkonten
haengen an genau einem Kunden und sehen nur dessen Hosts und Rechnungen -
ohne Einkaufspreise und Marge. Die Einschraenkung sitzt in den Abfragen
selbst, damit keine Seite vergessen kann, sie weiterzugeben; sechs Tests
pruefen das.

Dabei gefunden: Neu ueber OIDC angelegte Konten haetten die Vorgabe des
Datenmodells geerbt - ADMIN. Jetzt gibt es dafuer eine Einstellung mit der
Vorgabe Techniker.

Passkeys (#028) als gleichwertiger, passwortloser Anmeldeweg neben Passwort
und OIDC. Mehrere je Konto, Aufgabe in einem kurzlebigen Cookie, rpID aus der
oeffentlichen Adresse. Ohne HTTPS sagt die Seite es, statt still zu scheitern.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

.env.example

@@ -24,7 +24,8 @@ OIDC_CLIENT_ID=""
 OIDC_CLIENT_SECRET=""
 OIDC_NAME="authentik"
 
-# Öffentlich erreichbare Adresse des Dashboards (für install.sh und E-Mails)
+# Öffentlich erreichbare Adresse des Dashboards (für install.sh und E-Mails).
+# Lässt sich später unter Einstellungen → System überschreiben.
 APP_URL="http://localhost:3000"
 
 # Zeitplan des Workers (Standard: stündlich zur vollen Stunde)
@@ -33,6 +34,9 @@ WORKER_CRON="0 * * * *"
 # Zeitplan der Zusammenfassung (Standard: täglich 07:00 Uhr)
 ZUSAMMENFASSUNG_CRON="0 7 * * *"
 
+# Zeitplan fürs Aufräumen alter Reports und Protokolleinträge (Fristen: Einstellungen → System)
+AUFRAEUM_CRON="30 3 * * *"
+
 # Ablage für hochgeladene Rechnungs-PDFs
 UPLOAD_DIR="./data/uploads"
 

.gitea/workflows/ci.yml

@@ -0,0 +1,75 @@
+# Prüft jeden Push und jede Pull-Request-Änderung.
+# Läuft mit Gitea Actions (act_runner); die Syntax entspricht GitHub Actions.
+
+name: Prüfung
+
+on:
+  push:
+    branches: [main, "phase/**"]
+  pull_request:
+    branches: [main]
+
+jobs:
+  pruefung:
+    runs-on: ubuntu-latest
+
+    services:
+      postgres:
+        image: postgres:17-alpine
+        env:
+          POSTGRES_USER: proxledger
+          POSTGRES_PASSWORD: proxledger
+          POSTGRES_DB: proxledger_test
+        options: >-
+          --health-cmd "pg_isready -U proxledger"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 10
+        ports:
+          - 5432:5432
+
+    env:
+      DATABASE_URL: postgresql://proxledger:proxledger@localhost:5432/proxledger_test?schema=public
+      TEST_DATABASE_URL: postgresql://proxledger:proxledger@localhost:5432/proxledger_test?schema=public
+      APP_SECRET: ci-geheimnis-mit-mindestens-32-zeichen-laenge
+      APP_URL: http://localhost:3000
+
+    steps:
+      - name: Quelltext holen
+        uses: actions/checkout@v4
+
+      - name: Node einrichten
+        uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+
+      - name: Abhängigkeiten installieren
+        run: npm ci
+
+      - name: Prisma-Client erzeugen
+        run: npx prisma generate
+
+      - name: Code-Stil prüfen
+        run: npm run lint
+
+      - name: Typen prüfen
+        run: npm run typecheck
+
+      - name: Tests
+        run: npm test
+
+      - name: Anwendung bauen
+        run: npm run build
+
+      - name: Worker bauen
+        run: npm run build:worker
+
+      - name: Agent-Skripte prüfen
+        run: |
+          sudo apt-get update -qq
+          sudo apt-get install -y -qq shellcheck
+          shellcheck --severity=warning agent/*.sh deploy/*.sh
+
+      - name: Dokumentation und Versionen prüfen
+        run: npm run pruefe:doku

CHANGELOG.md

@@ -17,6 +17,90 @@ und dieses Projekt folgt [Semantic Versioning](https://semver.org/lang/de/).
 
 ### Sicherheit
 
+## [0.18.0] – 2026-09-19
+
+### Hinzugefügt
+- Drei Rollen: Administrator, Techniker und Kunde. Kundenkonten sehen nur die eigenen Hosts und Rechnungen – ohne Einkaufspreise und Marge – und dürfen Notizen schreiben sowie Warnungen quittieren (#027)
+- Benutzerverwaltung unter *Einstellungen → Benutzer*: anlegen, Rolle ändern, sperren, Passwort setzen, löschen (#027)
+- Anmeldung mit Passkeys (WebAuthn), gleichwertig neben Passwort und OIDC; eigene Seite *Meine Passkeys* (#028)
+- Einstellung, welche Rolle automatisch angelegte OIDC-Konten bekommen (#027)
+
+### Behoben
+- Neu über OIDC angelegte Konten hätten die Vorgabe des Datenmodells geerbt und wären Administratoren geworden; Vorgabe ist jetzt *Techniker* (#027)
+- Das Screenshot-Skript meldete sich mit einem erfundenen Konto an – seit der Sitzungsprüfung gegen die Datenbank landete es auf der Anmeldeseite (#027)
+
+## [0.17.0] – 2026-09-19
+
+### Hinzugefügt
+- `deploy/update.sh`: sichert, baut neu, migriert und prüft, ob das Dashboard wieder antwortet (#026)
+- Installationsskripte nach Art der Proxmox VE Helper-Scripts unter `deploy/community-scripts/` – Container mit Node und PostgreSQL, ohne Docker (#026)
+- `docs/roadmap.md`: was bis 1.0.0 fehlt und was danach lohnt (#026)
+- Zustandsprüfung für den Worker im Docker-Stack (#026)
+
+### Behoben
+- Nach der Anmeldung führte die Weiterleitung im Container auf den internen Containernamen (`http://<container-id>:3000`) statt auf die erreichbare Adresse – hinter einem Reverse Proxy landete man damit im Nichts. Beim Prüfen des Docker-Stapels aufgefallen (#026)
+
+### Geändert
+- README auf den tatsächlichen Stand gebracht: Der Feldtest ist erledigt, der Hinweis „noch nicht erprobt“ war überholt (#026)
+
+## [0.16.0] – 2026-09-18
+
+### Hinzugefügt
+- *Einstellungen → System*: Dashboard-Adresse, Melderhythmus und Selbstaktualisierung der Agents, kaufmännische Vorgaben, Sicherheitsgrenzen, Firmenangaben und Zeitzone (#025)
+- Die Dashboard-Adresse und der Melderhythmus landen im ausgelieferten Installations-Einzeiler und im systemd-Timer (#025)
+- OIDC lässt sich auf bestimmte E-Mail-Domänen begrenzen; das automatische Anlegen unbekannter Konten ist abschaltbar (#025)
+- Nächtliches Aufräumen nach einstellbaren Aufbewahrungsfristen für Reports und Protokoll – der jüngste Report jedes Hosts bleibt erhalten (#025)
+- Firmenangaben erscheinen im Kopf der PDF-Ausgaben (#025)
+
+### Geändert
+- Steuersatz, Zahlungsziel und Aufschlag kommen aus den Einstellungen statt aus fest eingetragenen 19 % (#025)
+
+## [0.15.0] – 2026-09-18
+
+### Hinzugefügt
+- `docs/sicherheit.md`: Zuordnung aller Maßnahmen zu den OWASP Top 10, samt der Punkte, die bewusst offen bleiben (#024)
+- Content-Security-Policy mit frischem Nonce je Anfrage (#024)
+- Sitzungen lassen sich widerrufen: gesperrtes Konto oder neues Passwort beendet laufende Sitzungen sofort (#024)
+- Benutzerverwaltung auf der Kommandozeile: `npm run benutzer -- liste|sperren|entsperren|passwort` (#024)
+
+### Behoben
+- Server Actions verließen sich allein auf den Schutz in `proxy.ts`; jede der 27 Aktionen prüft die Sitzung jetzt selbst (#024)
+- Die Anmeldung prüfte die Herkunft des Formulars nicht – damit war Login-CSRF möglich (#024)
+- `npm audit` meldete vier hohe Schwachstellen in Beiwerk von Prisma (`mysql2`, `deepmerge-ts`); über `overrides` angehoben, jetzt ohne Befund (#024)
+
+## [0.14.1] – 2026-09-18
+
+### Behoben
+- Auf Proxmox Backup Server las der Agent **keine einzige Angabe** aus: `proxmox-backup-manager subscription get` gibt eine Rahmentabelle aus, keine `feld: wert`-Zeilen. Jetzt wird für PBS `--output-format json` genutzt, und die Tabelle wird als Rückfall ausgewertet (#023)
+- Die PBS-Version enthielt die laufende Fassung ein zweites Mal (#023)
+- Der Agent meldete eine „neue Version“, auch wenn die installierte neuer war als die des Dashboards (#023)
+
+### Geändert
+- Agent-Version 0.2.1; die Tests prüfen die Versionsangabe jetzt gegen die Konstante des Dashboards statt gegen eine abgeschriebene Zahl (#023)
+
+## [0.14.0] – 2026-09-18
+
+### Hinzugefügt
+- Der Agent meldet die Mitglieder seines Proxmox-Clusters; das Dashboard warnt bei Knoten ohne eigenen Agent (#022)
+- Host-Detail zeigt alle Cluster-Knoten mit Zustand „meldet sich“ oder „kein Agent“ (#022)
+- Wartezeiten zwischen Sendeversuchen über `PROXLEDGER_WARTEZEITEN` einstellbar, damit sich der Zwischenspeicher testen lässt (#018)
+
+### Behoben
+- Die Produktversion enthielt bei Proxmox VE den Kernel ein zweites Mal (#018)
+- Die Bilder des Handbuchs zeigten allesamt die Anmeldeseite: Firefox verwirft fremd erzeugte Cookie-Dateien stillschweigend. Das Skript nutzt jetzt einen lokalen Vermittler, der die Sitzung mitschickt, und bricht ab, wenn alle Aufnahmen gleich groß sind (#016)
+
+## [0.13.1] – 2026-09-17
+
+### Sicherheit
+- SMTP-Passwort und Webhook-Geheimnis werden verschlüsselt in der Datenbank abgelegt (AES-256-GCM, Schlüssel aus `APP_SECRET`); eine Sicherung gibt sie damit nicht mehr im Klartext preis (#021)
+- Werte aus der Zeit davor werden weiterhin gelesen und beim nächsten Speichern umgeschlüsselt (#021)
+
+## [0.13.0] – 2026-09-17
+
+### Hinzugefügt
+- Prüfung bei jedem Push über Gitea Actions: Lint, Typen, Tests gegen PostgreSQL, Build, ShellCheck und Dokumentationsprüfung (#019)
+- `npm run pruefe:doku` vergleicht Version, Issue-Übersicht und Handbuch-Bilder auf Konsistenz (#019)
+
 ## [0.12.1] – 2026-09-17
 
 ### Hinzugefügt

DEVLOG.md

@@ -2,7 +2,7 @@
 
 ## Zeitübersicht
 
-**Gesamt:** 7 h 23 min
+**Gesamt:** 14 h 23 min
 
 | Issue | Zeit |
 |---|---|
@@ -24,6 +24,16 @@
 | #015 Feinschliff | 0 h 35 min |
 | #016 Handbuch | 0 h 30 min |
 | #017 Favicons | 0 h 15 min |
+| #019 CI-Pipeline | 0 h 20 min |
+| #021 Geheimnisse verschlüsseln | 0 h 20 min |
+| #018 Feldtest auf echten Hosts | 0 h 40 min |
+| #022 Cluster-Abgleich | 0 h 25 min |
+| #023 Feldtest PBS | 0 h 35 min |
+| #024 OWASP-Härtung | 0 h 45 min |
+| #025 Einstellungen | 1 h 10 min |
+| #026 Auslieferung | 0 h 40 min |
+| #027 Rollen und Benutzerverwaltung | 1 h 20 min |
+| #028 Passkeys | 0 h 45 min |
 
 | Meilenstein | Zeit |
 |---|---|
@@ -46,7 +56,7 @@
 
 ## 2026-09-17 · Sitzung 1 · 19:36–laufend
 **Issue:** #001–#007 (Meilensteine v0.1.0 bis v0.4.0)
-**Version:** 0.12.1
+**Version:** 0.18.0
 
 ### Erledigt
 - Auftrag gelesen, Rückfragen gestellt
@@ -90,6 +100,8 @@
 - 0.11.1: Anmeldefehler behoben (Secure-Cookie über http)
 - #016 abgeschlossen: Handbuch mit elf Kapiteln und 16 Bildern, dazu `npm run screenshots` zum Auffrischen
 - #017 abgeschlossen: Symbole für Tab, Startbildschirm und Manifest, erzeugt mit `npm run icons` aus SVG-Vorlagen
+- #019 abgeschlossen: Gitea-Actions-Workflow mit Lint, Typen, Tests, Build, ShellCheck und Doku-Prüfung
+- #021 abgeschlossen: SMTP-Passwort und Webhook-Geheimnis liegen verschlüsselt in der Datenbank (AES-256-GCM, Schlüssel aus APP_SECRET)
 
 ### Entscheidungen
 - **Warnungen sammelweise anlegen:** Einzelne Upserts kosteten bei 737 neuen Warnungen 3,8 s; mit `createMany` sind es 0,3 s.
@@ -123,6 +135,29 @@
 - Der Agent wurde noch auf keinem echten Proxmox-Host installiert; die Tests arbeiten mit nachgebauten Befehlen.
 - Offen: Rolle „readonly“ zusätzlich zu Admin? (vorläufig vorgesehen)
 
+- #018 abgeschlossen: Feldtest auf zwei echten PVE-9.2-Hosts (einer mit, einer ohne Subscription, einer im Cluster); Installation, Timer, Zwischenspeicher und Nachsenden geprüft
+- #022 abgeschlossen: Cluster-Abgleich – jeder Agent meldet die Mitglieder, das Dashboard warnt bei Knoten ohne Agent
+- **Fehler im eigenen Werkzeug gefunden:** Alle Handbuch-Bilder waren in Wahrheit die Anmeldeseite. Firefox verwirft eine selbst angelegte Cookie-Datei stillschweigend. Jetzt läuft ein lokaler Vermittler mit, und das Skript bricht ab, wenn alle Aufnahmen gleich groß sind.
+
+- Feldtest auf einem echten Proxmox Backup Server (#023): der Agent hätte dort **nichts** gelesen – PBS gibt eine Rahmentabelle aus, kein `feld: wert`. Behoben, mit den echten Ausgaben als Testfälle
+- Der erfundene PBS-Testfall hatte den Fehler verdeckt. Lehre: ausgedachte Testdaten bestätigen nur die eigene Annahme
+- Uninstall zum ersten Mal auf einem echten Host geprüft – restlos sauber, damit ist #018 vollständig
+
+- Durchsicht nach OWASP (#024): drei echte Lücken gefunden – Server Actions ohne eigene Zugriffsprüfung, Login-CSRF und fehlende CSP. Alle behoben und mit Tests abgesichert
+- Erkenntnis: Der Schutz lag vollständig in einer einzigen Schicht (`proxy.ts`). Das fällt erst auf, wenn man die Endpunkte einzeln betrachtet statt die Oberfläche
+
+- Einstellungen im Dashboard (#025): vier Bereiche, alle Werte wirken auch wirklich – der Melderhythmus zum Beispiel bis in den erzeugten systemd-Timer hinein, live geprüft
+- Dabei die OIDC-Lücke aus #024 geschlossen: Domänenliste und Schalter gegen automatisch angelegte Konten
+- Bewusst nicht gebaut: „stumm nach X Tagen“ (steht schon bei den Warnregeln) und die Währung in der Browseransicht
+
+- Auslieferung finalisiert (#026): Docker-Weg mit Update-Skript, dazu Skripte nach Art der Helper-Scripts für einen LXC ohne Docker
+- Recherche dazu: Das Gerüst der community-scripts liegt inzwischen in einem eigenen Repository, und neue Skripte gehören zuerst nach ProxmoxVED. Eine Einreichung setzt öffentlichen Quelltext voraus – deshalb vorerst intern
+- Roadmap geschrieben: Bis 1.0.0 fehlt kein Code mehr, sondern Erprobung (PMG, PBS mit Lizenz, ein Monat Dauerbetrieb, einmal eine Sicherung zurückspielen)
+
+- Rollen und Benutzerverwaltung (#027): Die Einschränkung sitzt in den Abfragen selbst, damit keine Seite vergessen kann, sie weiterzugeben. Sechs Tests prüfen, dass ein Kundenkonto weder fremde Hosts noch Einkaufspreise sieht
+- Dabei aufgefallen: Neu angelegte OIDC-Konten hätten die Modellvorgabe ADMIN geerbt – behoben, mit eigener Einstellung und Test
+- Passkeys (#028): passwortlos, mehrere je Konto, Aufgabe in einem kurzlebigen Cookie. Nur über HTTPS nutzbar – die Seite sagt es, statt still zu scheitern
+
 ### Nächster Schritt
 - #016 Benutzerhandbuch mit Screenshots, danach #017 Favicons und #019 CI-Pipeline
-- Für 1.0.0 fehlt vor allem der Feldtest auf echten Proxmox-Hosts (#018)
+- Für 1.0.0 fehlt noch: PMG (kein Host verfügbar) und der Fall „aktive Subscription auf PBS“ (#023)

README.md

@@ -3,8 +3,10 @@
 Zentrales Dashboard für den Subscription-Status aller Proxmox-Hosts (VE, Backup Server, Mail Gateway).
 Auf jedem Host meldet ein schlanker Agent täglich per HTTPS seinen Status (Push-Modell) – auch aus Kundennetzen hinter NAT.
 
-> **Status:** in Entwicklung. Der Funktionsumfang steht, der Agent wurde aber noch nicht auf echten
+> **Status:** einsatzbereit. Der Agent ist auf echten Hosts erprobt – Proxmox VE 9.2 mit und ohne
-> Proxmox-Hosts erprobt (#018).
+> Subscription, im Cluster und einzeln, sowie Proxmox Backup Server 4.2 (#018, #023).
+> Ungeprüft: Mail Gateway und eine aktive Subscription auf PBS. Was bis 1.0 fehlt, steht in
+> [docs/roadmap.md](docs/roadmap.md).
 
 ## Schnellstart
 
@@ -20,14 +22,27 @@ docker compose up -d
 Beim ersten Start legt der Dienst `migrate` das Schema an und erzeugt den Administrator aus der `.env`.
 Danach ist das Dashboard unter `APP_URL` erreichbar.
 
-**Auf einem Proxmox-Host** legt der Installer einen fertigen LXC-Container an:
+Aktualisieren geht mit einem Befehl – er sichert vorher, baut neu, migriert und prüft zum Schluss,
+ob das Dashboard wieder antwortet:
 
 ```bash
-bash deploy/lxc-installer.sh
+bash deploy/update.sh
 ```
 
-Er fragt Ressourcen und Netzwerk ab, installiert Docker, holt den Quelltext, erzeugt Zufallspasswörter
+**Auf einem Proxmox-Host** gibt es zwei Wege zu einem fertigen LXC-Container:
-und startet alles. Am Ende stehen Adresse, Benutzer und Passwort auf dem Bildschirm.
+
+```bash
+bash deploy/lxc-installer.sh          # eigener Installer: Container mit Docker darin
+```
+
+```bash
+# Nach Art der Proxmox VE Helper-Scripts: Container mit Node und PostgreSQL direkt darin
+bash -c "$(curl -fsSL https://<git>/ProxLedger/raw/branch/main/deploy/community-scripts/ct/proxledger.sh)"
+```
+
+Der zweite Weg folgt den Konventionen von [community-scripts.org](https://community-scripts.org) und
+braucht kein Docker; Einzelheiten und die Voraussetzungen für eine Einreichung stehen in
+[deploy/community-scripts/README.md](deploy/community-scripts/README.md).
 
 ### Agent ausrollen
 
@@ -63,7 +78,20 @@ npm run worker        # Dauerbetrieb
 npm run alerts:check  # einmalige Auswertung
 ```
 
-Weitere Skripte: `npm run db:studio` (Datenbank-Oberfläche), `npm run db:down` (Container stoppen).
+Weitere Skripte:
+
+| Befehl | Zweck |
+|---|---|
+| `npm run db:studio` | Datenbank-Oberfläche |
+| `npm run db:down` | Datenbank-Container stoppen |
+| `npm run icons` | Symbole aus den SVG-Vorlagen erzeugen |
+| `npm run screenshots -- --alle` | Bilder für das Handbuch auffrischen |
+| `npm run pruefe:doku` | Doku, Versionen und Bilder auf Konsistenz prüfen |
+| `npm run lasttest` | Abfragen mit 200 Hosts und fünf Jahren Reports messen |
+
+Jeder Push wird von [Gitea Actions](.gitea/workflows/ci.yml) geprüft: Lint, Typen, Tests gegen eine
+PostgreSQL-Instanz, Build, ShellCheck für die Agent-Skripte und die Konsistenz der Dokumentation.
+Dafür muss auf dem Gitea-Server ein `act_runner` eingerichtet sein.
 
 ## Agent auf einem Proxmox-Host installieren
 
@@ -92,13 +120,28 @@ Die Oberfläche ist vollständig geschützt; die Agent-API und die Skript-Auslie
 sie sich mit eigenen Tokens ausweisen.
 
 - **Lokaler Zugang:** E-Mail und Passwort aus dem Seed (`ADMIN_EMAIL`, `ADMIN_PASSWORD`). Fünf Fehlversuche
-  je Kennung und Viertelstunde, danach Sperre.
+  je Kennung und Viertelstunde, danach Sperre (einstellbar unter *Einstellungen → System*).
+  Benutzer sperren oder Passwort setzen: `npm run benutzer -- sperren <email>`.
 - **OIDC (z. B. authentik):** `OIDC_ISSUER`, `OIDC_CLIENT_ID`, `OIDC_CLIENT_SECRET` setzen. Rückkehradresse
   ist `<APP_URL>/api/auth/oidc/callback`. Ohne diese Werte erscheint nur der lokale Zugang – der bleibt
-  absichtlich immer nutzbar, falls der Anmeldedienst ausfällt.
+  absichtlich immer nutzbar, falls der Anmeldedienst ausfällt. Unter *Einstellungen → System* lässt sich
+  einschränken, welche E-Mail-Domänen zugelassen sind und ob unbekannte Konten angelegt werden dürfen.
 - **`APP_SECRET`** (mindestens 32 Zeichen) signiert die Sitzungs-Cookies. Ändert sich der Wert, sind alle
   Sitzungen ungültig.
 
+## Einstellungen
+
+Die meisten Betriebswerte stehen unter *Einstellungen → System* und wirken sofort: Dashboard-Adresse,
+Melderhythmus und Selbstaktualisierung der Agents, Steuersatz, Zahlungsziel und Aufschlag,
+Sitzungsdauer und Anmeldeversuche, OIDC-Beschränkungen, Aufbewahrungsfristen sowie Firmenangaben und
+Zeitzone für die PDF-Ausgaben.
+
+In der Umgebung bleiben nur `APP_SECRET` und `DATABASE_URL` – beide werden gebraucht, bevor die
+Anwendung die Datenbank lesen kann.
+
+Wie die Anwendung gegen die OWASP Top 10 dasteht (einschließlich der Punkte, die bewusst offen
+bleiben), steht in [docs/sicherheit.md](docs/sicherheit.md).
+
 ## Exporte
 
 | Ansicht | CSV | PDF |
@@ -167,9 +210,9 @@ Zum Zurückspielen:
 gunzip -c datenbank-20260917-023000.sql.gz | docker compose exec -T postgres psql -U proxledger proxledger
 ```
 
-**Wichtig:** `APP_SECRET` mitsichern. Ohne diesen Wert sind alle Sitzungen ungültig; die Zugangsdaten für
+**Wichtig:** `APP_SECRET` mitsichern und sicher aufbewahren. Der Wert signiert die Sitzungen **und**
-SMTP und Webhook liegen (noch) unverschlüsselt in der Datenbank, eine Sicherung enthält sie also im Klartext
+verschlüsselt die Zugangsdaten für SMTP und Webhook in der Datenbank. Geht er verloren, müssen diese
-– siehe Issue #021.
+Zugangsdaten neu eingetragen werden; eine Sicherung allein gibt sie nicht preis.
 
 ## Dokumentation
 

agent/install.sh

@@ -16,9 +16,17 @@ set -o nounset
 set -o pipefail
 
 DASHBOARD_URL="${PROXLEDGER_URL:-@@DASHBOARD_URL@@}"
+# Melderhythmus und Streuung setzt das Dashboard beim Ausliefern ein (Einstellungen → System).
+# Wird das Skript unverändert aus dem Quelltext ausgeführt, bleiben die Platzhalter stehen;
+# dann gelten die Vorgaben.
+TIMER_ONCALENDAR="@@TIMER_ONCALENDAR@@"
+TIMER_STREUUNG="@@TIMER_STREUUNG@@"
+case "$TIMER_ONCALENDAR" in *@@*) TIMER_ONCALENDAR="daily" ;; esac
+case "$TIMER_STREUUNG" in *@@*) TIMER_STREUUNG="4h" ;; esac
 TOKEN=""
 CA_CERT=""
-AUTO_UPDATE="no"
+AUTO_UPDATE="@@AUTO_UPDATE@@"
+case "$AUTO_UPDATE" in yes | no) ;; *) AUTO_UPDATE="no" ;; esac
 AKTION="install"
 
 CONFIG_VERZEICHNIS="/etc/proxledger"
@@ -202,14 +210,14 @@ ProtectSystem=full
 ProtectHome=true
 UNIT
 
-cat >"${SYSTEMD_VERZEICHNIS}/proxledger.timer" <<'UNIT'
+cat >"${SYSTEMD_VERZEICHNIS}/proxledger.timer" <<UNIT
 [Unit]
-Description=Täglicher ProxLedger-Report
+Description=ProxLedger-Report
 
 [Timer]
-OnCalendar=daily
+OnCalendar=${TIMER_ONCALENDAR}
-# Verteilt die Meldungen aller Hosts über vier Stunden.
+# Verteilt die Meldungen aller Hosts über diesen Zeitraum.
-RandomizedDelaySec=4h
+RandomizedDelaySec=${TIMER_STREUUNG}
 Persistent=true
 Unit=proxledger.service
 
@@ -219,7 +227,7 @@ UNIT
 
 systemctl daemon-reload
 systemctl enable --now proxledger.timer >/dev/null
-erfolg "systemd-Timer aktiviert (täglich, zufällig um bis zu 4 Stunden versetzt)."
+erfolg "systemd-Timer aktiviert (${TIMER_ONCALENDAR}, zufällig um bis zu ${TIMER_STREUUNG} versetzt)."
 
 hinweis "Sende ersten Report …"
 if "$AGENT_PFAD" --report; then

agent/proxledger-agent.sh

@@ -12,11 +12,12 @@
 set -o nounset
 set -o pipefail
 
-AGENT_VERSION="0.2.0"
+AGENT_VERSION="0.2.1"
 CONFIG_DATEI="${PROXLEDGER_CONFIG:-/etc/proxledger/agent.conf}"
 SPOOL_VERZEICHNIS="${PROXLEDGER_SPOOL:-/var/lib/proxledger/spool}"
 SPOOL_MAXIMUM=30
-WARTEZEITEN=(30 120 480)
+# Wartezeiten zwischen den Versuchen; für Tests über PROXLEDGER_WARTEZEITEN kürzbar.
+read -r -a WARTEZEITEN <<<"${PROXLEDGER_WARTEZEITEN:-30 120 480}"
 
 # --------------------------------------------------------------------- Protokoll
 
@@ -105,15 +106,24 @@ produkt_erkennen() {
 }
 
 subscription_ausgabe() {
+  local ausgabe=""
   case "$1" in
+    # PVE kennt --output-format nicht (geprueft auf 9.2), liefert aber "feld: wert".
     pve) pvesubscription get 2>/dev/null ;;
-    pbs) proxmox-backup-manager subscription get 2>/dev/null ;;
+    # PBS gibt ohne --output-format eine Rahmentabelle aus, aus der sich schlecht lesen laesst.
+    # JSON kann es (geprueft auf 4.2); aeltere Fassungen faengt die Tabellenauswertung ab.
+    pbs)
+      ausgabe=$(proxmox-backup-manager subscription get --output-format json 2>/dev/null)
+      [ -n "$ausgabe" ] || ausgabe=$(proxmox-backup-manager subscription get 2>/dev/null)
+      printf '%s' "$ausgabe"
+      ;;
     pmg) pmgsubscription get 2>/dev/null ;;
     *) printf '' ;;
   esac
 }
 
-# Liest ein Feld aus der Subscription-Ausgabe. Unterstützt "feld: wert" und JSON.
+# Liest ein Feld aus der Subscription-Ausgabe. Unterstuetzt "feld: wert", JSON und die
+# Rahmentabelle von PBS ("| feld | wert |" mit Unicode-Strichen).
 feld_lesen() {
   local feld="$1" text="$2" wert
   wert=$(printf '%s\n' "$text" | sed -n "s/^[[:space:]]*${feld}[[:space:]]*:[[:space:]]*//p" | head -n1)
@@ -121,6 +131,15 @@ feld_lesen() {
     wert=$(printf '%s\n' "$text" |
       sed -n "s/.*\"${feld}\"[[:space:]]*:[[:space:]]*\"\{0,1\}\([^\",}]*\)\"\{0,1\}.*/\1/p" | head -n1)
   fi
+  if [ -z "$wert" ]; then
+    # Tabellenzeile: Trennzeichen ist U+2502; awk zerlegt daran und liefert die zweite Spalte.
+    wert=$(printf '%s\n' "$text" |
+      awk -F'\xe2\x94\x82' -v feld="$feld" '
+        NF >= 3 {
+          name = $2; gsub(/^[ \t]+|[ \t]+$/, "", name)
+          if (name == feld) { wert = $3; gsub(/^[ \t]+|[ \t]+$/, "", wert); print wert; exit }
+        }')
+  fi
   # Umschließende Anführungszeichen und Leerzeichen entfernen.
   wert=${wert%\"}
   wert=${wert#\"}
@@ -128,9 +147,13 @@ feld_lesen() {
 }
 
 produkt_version() {
+  # Bei PVE hängt die Kernel-Angabe mit im String ("… (running kernel: …)").
+  # Der Kernel wird separat gemeldet, deshalb hier abschneiden.
   case "$1" in
-    pve) pveversion 2>/dev/null | head -n1 ;;
+    pve) pveversion 2>/dev/null | head -n1 | sed 's/ (running kernel.*//' ;;
-    pbs) proxmox-backup-manager version 2>/dev/null | head -n1 ;;
+    # PBS haengt die laufende Fassung an ("… 4.2.6-1 running version: 4.2.1");
+    # gemeldet wird die installierte.
+    pbs) proxmox-backup-manager version 2>/dev/null | head -n1 | sed 's/ running version.*//' ;;
     pmg) pmgversion 2>/dev/null | head -n1 ;;
     *) printf '' ;;
   esac
@@ -150,6 +173,14 @@ cluster_name() {
   fi
 }
 
+# Namen aller Cluster-Mitglieder laut corosync. Auch Knoten ohne Agent stehen hier –
+# daraus erkennt das Dashboard vergessene Knoten (#022).
+cluster_mitglieder() {
+  if command -v pvecm >/dev/null 2>&1; then
+    pvecm nodes 2>/dev/null | awk '/^[[:space:]]*[0-9]+[[:space:]]+[0-9]+/ {print $3}' | sed 's/ *(local)//'
+  fi
+}
+
 node_name() {
   if command -v pvecm >/dev/null 2>&1 && pvecm status >/dev/null 2>&1; then
     hostname -s 2>/dev/null
@@ -220,6 +251,7 @@ report_erzeugen() {
     "ips": $(ip_adressen | json_liste),
     "clusterName": $(json_text "$(cluster_name)"),
     "nodeName": $(json_text "$(node_name)"),
+    "clusterMitglieder": $(cluster_mitglieder | json_liste),
     "kernel": $(json_text "$(uname -r 2>/dev/null)"),
     "uptimeSekunden": $(json_zahl "$(uptime_sekunden)"),
     "cpuModell": $(json_text "$(cpu_modell)"),
@@ -383,8 +415,15 @@ aktion_test() {
   [ "$(printf '%s' "$antwort" | tail -n1)" = "200" ]
 }
 
+# Ist $1 eine neuere Fassung als $2? `sort -V` vergleicht Versionsnummern der Reihe nach.
+version_neuer() {
+  [ "$1" != "$2" ] && [ "$(printf '%s\n%s\n' "$1" "$2" | sort -V | tail -n1)" = "$1" ]
+}
+
 version_pruefen() {
-  if [ -n "${NEUESTE_VERSION:-}" ] && [ "$NEUESTE_VERSION" != "$AGENT_VERSION" ]; then
+  # Nur melden, wenn das Dashboard wirklich eine neuere Fassung kennt. Sonst warnt ein Agent,
+  # der einer Testinstallation vorauseilt, gegen sich selbst (im Feldtest #023 aufgefallen).
+  if [ -n "${NEUESTE_VERSION:-}" ] && version_neuer "$NEUESTE_VERSION" "$AGENT_VERSION"; then
     protokoll notice "Neue Agent-Version verfügbar: ${NEUESTE_VERSION} (installiert: ${AGENT_VERSION})."
     if [ "$AUTO_UPDATE" = "yes" ]; then
       aktion_update

deploy/community-scripts/README.md

@@ -0,0 +1,63 @@
+# Installation als LXC-Container nach Art der Proxmox VE Helper-Scripts
+
+Diese beiden Skripte folgen den Konventionen von [community-scripts.org](https://community-scripts.org)
+(der Nachfolge von tteck's Helper-Scripts). Sie legen einen unprivilegierten Debian-13-Container an,
+installieren Node.js 24 und PostgreSQL 17, holen ProxLedger aus dem Git-Repository, richten zwei
+systemd-Dienste ein (Dashboard und Worker) und schreiben die erzeugten Zugangsdaten nach
+`/opt/proxledger/.credentials`.
+
+| Datei | Zweck |
+|---|---|
+| `ct/proxledger.sh` | Container anlegen, Ressourcen abfragen, Aktualisierung (`update_script`) |
+| `install/proxledger-install.sh` | Installation im Container |
+
+## Verwendung im eigenen Netz
+
+Auf dem Proxmox-VE-Host als root:
+
+```bash
+bash -c "$(curl -fsSL https://git.wilde-server.de/fw/ProxLedger/raw/branch/main/deploy/community-scripts/ct/proxledger.sh)"
+```
+
+Das Gerüst (`build.func`, `install.func`) lädt das Skript von den community-scripts nach – das ist
+öffentlich und ohne Konto erreichbar. Nur ProxLedger selbst kommt aus dem eigenen Git.
+
+Zwei Umgebungsvariablen steuern die Quelle, solange das Repository nicht öffentlich ist:
+
+```bash
+PROXLEDGER_REPO=https://git.example.de/fw/ProxLedger.git PROXLEDGER_BRANCH=main bash -c "$(curl -fsSL …)"
+```
+
+Ist das Git-Repository nicht ohne Anmeldung lesbar, gehört ein Lesezugriffs-Token in die Adresse
+(`https://<token>@git.example.de/...`). Das Token landet dann in der Prozessliste des Containers –
+also besser einen Deploy-Token verwenden, der nur lesen darf.
+
+## Was eine Einreichung bei community-scripts verlangen würde
+
+Wir liefern die Skripte vorerst **nur intern** aus. Für eine Einreichung wären zusätzlich nötig:
+
+1. **Öffentlich erreichbarer Quelltext.** Die Skripte dort holen die Anwendung praktisch immer aus
+   einem öffentlichen GitHub-Repository (`fetch_and_deploy_gh_release`). Ein privates Gitea genügt nicht.
+2. **Pull Request gegen [ProxmoxVED](https://github.com/community-scripts/ProxmoxVED)**, nicht gegen
+   ProxmoxVE. Neue Skripte, die direkt gegen ProxmoxVE eingereicht werden, werden ohne Prüfung
+   geschlossen.
+3. **MIT-Lizenz** im eigenen Repository und der Lizenzkopf in beiden Skripten (steht bereits darin).
+4. **Englische Dokumentation** – die Skripte selbst sind auf Englisch gehalten, die deutschen
+   Kommentare in diesem Verzeichnis müssten übersetzt werden.
+5. **Metadaten für die Webseite.** Die JSON-Dateien liegen inzwischen nicht mehr im Skript-Repository;
+   wo sie hingehören, steht in der aktuellen Beitragsanleitung. Das ist beim Einreichen zu prüfen.
+
+Die Skripte sind so geschrieben, dass für eine spätere Einreichung nur die Quelle zu tauschen und die
+Kommentare zu übersetzen sind – am Ablauf ändert sich nichts.
+
+## Unterschied zum Docker-Weg
+
+| | Helper-Script (LXC) | Docker Compose |
+|---|---|---|
+| Umgebung | eigener Container auf dem Proxmox-Host | beliebiger Docker-Host |
+| Datenbank | PostgreSQL im selben Container | eigener Dienst |
+| Aktualisierung | `update`-Weg des Skripts | `bash deploy/update.sh` |
+| Sicherung | Proxmox-Sicherung des Containers | `bash deploy/backup.sh` |
+
+Beide Wege sind gleichwertig. Wer ohnehin Proxmox betreibt, fährt mit dem LXC-Weg meist einfacher –
+die Sicherung des Containers erledigt dann die gewohnte Proxmox-Sicherung mit.

deploy/community-scripts/ct/proxledger.sh

@@ -0,0 +1,74 @@
+#!/usr/bin/env bash
+_CS_DEFAULT_URL="https://raw.githubusercontent.com/community-scripts/ProxmoxVE/main"
+_cs_boot="${COMMUNITY_SCRIPTS_CORE_DIR:-$(dirname "${BASH_SOURCE[0]}")/../../core}/core/build.func"
+source "$_cs_boot" 2>/dev/null || source <(curl -fsSL "${COMMUNITY_SCRIPTS_CORE_URL:-https://raw.githubusercontent.com/community-scripts/core/main}/core/build.func")
+# Copyright (c) 2021-2026 tteck
+# Author: Florian Wilde
+# License: MIT | https://github.com/community-scripts/ProxmoxVE/raw/main/LICENSE
+# Source: https://git.wilde-server.de/fw/ProxLedger
+
+APP="ProxLedger"
+var_tags="${var_tags:-monitoring;licensing}"
+var_cpu="${var_cpu:-2}"
+var_ram="${var_ram:-2048}"
+var_disk="${var_disk:-10}"
+var_os="${var_os:-debian}"
+var_version="${var_version:-13}"
+var_arm64="${var_arm64:-yes}"
+var_unprivileged="${var_unprivileged:-1}"
+
+header_info "$APP"
+variables
+color
+catch_errors
+
+function update_script() {
+  header_info
+  check_container_storage
+  check_container_resources
+
+  if [[ ! -d /opt/proxledger ]]; then
+    msg_error "No ${APP} Installation Found!"
+    exit
+  fi
+
+  NODE_VERSION="24" setup_nodejs
+
+  msg_info "Stopping Services"
+  systemctl stop proxledger proxledger-worker
+  msg_ok "Stopped Services"
+
+  # Die .env traegt APP_SECRET; geht sie verloren, sind Sitzungen und gespeicherte
+  # Zugangsdaten unbrauchbar. Deshalb vor jedem Update sichern und danach zurueckspielen.
+  create_backup /opt/proxledger/.env
+
+  msg_info "Updating ${APP}"
+  cd /opt/proxledger
+  $STD git pull --ff-only
+  $STD npm ci
+  $STD npx prisma generate
+  $STD npx prisma migrate deploy
+  $STD npm run build
+  $STD npm run build:worker
+  msg_ok "Updated ${APP}"
+
+  restore_backup
+
+  msg_info "Starting Services"
+  systemctl start proxledger proxledger-worker
+  msg_ok "Started Services"
+
+  msg_ok "Update Successful"
+  exit
+}
+
+start
+build_container
+description
+
+msg_ok "Completed Successfully!\n"
+echo -e "${CREATING}${GN}${APP} setup has been successfully initialized!${CL}"
+echo -e "${INFO}${YW} Access it using the following URL:${CL}"
+echo -e "${TAB}${GATEWAY}${BGN}http://${IP}:3000${CL}"
+echo -e "${INFO}${YW} Login credentials are in:${CL}"
+echo -e "${TAB}${GATEWAY}${BGN}/opt/proxledger/.credentials${CL}"

deploy/community-scripts/install/proxledger-install.sh

@@ -0,0 +1,127 @@
+#!/usr/bin/env bash
+
+# Copyright (c) 2021-2026 tteck
+# Author: Florian Wilde
+# License: MIT | https://github.com/community-scripts/ProxmoxVE/raw/main/LICENSE
+# Source: https://git.wilde-server.de/fw/ProxLedger
+
+source /dev/stdin <<<"$FUNCTIONS_FILE_PATH"
+color
+verb_ip6
+catch_errors
+setting_up_container
+network_check
+update_os
+
+# Die Quelle laesst sich ueberschreiben, solange das Repository nicht oeffentlich ist.
+QUELLE="${PROXLEDGER_REPO:-https://git.wilde-server.de/fw/ProxLedger.git}"
+ZWEIG="${PROXLEDGER_BRANCH:-main}"
+
+msg_info "Installing Dependencies"
+$STD apt install -y git ca-certificates
+msg_ok "Installed Dependencies"
+
+NODE_VERSION="24" setup_nodejs
+PG_VERSION="17" setup_postgresql
+
+msg_info "Setting up Database"
+DB_NAME="proxledger"
+DB_USER="proxledger"
+DB_PASS=$(openssl rand -base64 24 | tr -dc 'A-Za-z0-9' | head -c 24)
+ADMIN_PASS=$(openssl rand -base64 24 | tr -dc 'A-Za-z0-9' | head -c 20)
+# APP_SECRET signiert die Sitzungen und verschluesselt gespeicherte Zugangsdaten.
+APP_SECRET=$(openssl rand -base64 48)
+
+$STD sudo -u postgres psql -c "CREATE USER ${DB_USER} WITH PASSWORD '${DB_PASS}';"
+$STD sudo -u postgres psql -c "CREATE DATABASE ${DB_NAME} WITH OWNER ${DB_USER} ENCODING 'UTF8';"
+msg_ok "Set up Database"
+
+msg_info "Setting up ProxLedger"
+$STD git clone --branch "$ZWEIG" --depth 1 "$QUELLE" /opt/proxledger
+cd /opt/proxledger
+
+IP_ADRESSE=$(hostname -I | awk '{print $1}')
+cat <<EOF >/opt/proxledger/.env
+DATABASE_URL="postgresql://${DB_USER}:${DB_PASS}@localhost:5432/${DB_NAME}?schema=public"
+APP_SECRET="${APP_SECRET}"
+APP_URL="http://${IP_ADRESSE}:3000"
+ADMIN_EMAIL="admin@proxledger.local"
+ADMIN_NAME="Administrator"
+ADMIN_PASSWORD="${ADMIN_PASS}"
+UPLOAD_DIR="/opt/proxledger/data/uploads"
+NODE_ENV="production"
+PORT="3000"
+EOF
+chmod 600 /opt/proxledger/.env
+mkdir -p /opt/proxledger/data/uploads
+
+$STD npm ci
+$STD npx prisma generate
+$STD npx prisma migrate deploy
+$STD npx prisma db seed
+$STD npm run build
+$STD npm run build:worker
+msg_ok "Set up ProxLedger"
+
+msg_info "Creating Services"
+cat <<EOF >/etc/systemd/system/proxledger.service
+[Unit]
+Description=ProxLedger Dashboard
+After=network.target postgresql.service
+Requires=postgresql.service
+
+[Service]
+Type=simple
+WorkingDirectory=/opt/proxledger
+EnvironmentFile=/opt/proxledger/.env
+ExecStart=/usr/bin/npm run start
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+cat <<EOF >/etc/systemd/system/proxledger-worker.service
+[Unit]
+Description=ProxLedger Worker (Warnregeln und Benachrichtigungen)
+After=network.target postgresql.service
+Requires=postgresql.service
+
+[Service]
+Type=simple
+WorkingDirectory=/opt/proxledger
+EnvironmentFile=/opt/proxledger/.env
+ExecStart=/usr/bin/node dist/worker.mjs
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+EOF
+
+systemctl enable -q --now proxledger proxledger-worker
+msg_ok "Created Services"
+
+# Die Zugangsdaten liegen fuer den Betreiber lesbar im Container; APP_SECRET steht in der .env.
+{
+  echo "ProxLedger"
+  echo "Adresse:     http://${IP_ADRESSE}:3000"
+  echo "Benutzer:    admin@proxledger.local"
+  echo "Passwort:    ${ADMIN_PASS}"
+  echo
+  echo "Datenbank:   ${DB_NAME} / ${DB_USER} / ${DB_PASS}"
+  echo
+  echo "Wichtig: APP_SECRET aus /opt/proxledger/.env mitsichern."
+  echo "Ohne diesen Wert sind Sitzungen und gespeicherte Zugangsdaten unbrauchbar."
+} >>~/proxledger.creds
+cp ~/proxledger.creds /opt/proxledger/.credentials
+chmod 600 /opt/proxledger/.credentials
+
+motd_ssh
+customize
+
+msg_info "Cleaning up"
+$STD apt -y autoremove
+$STD apt -y autoclean
+msg_ok "Cleaned"

deploy/update.sh

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+# ProxLedger aktualisieren (Docker-Installation).
+#
+#   bash deploy/update.sh            # Quelltext holen, neu bauen, migrieren, neu starten
+#   bash deploy/update.sh --ohne-sicherung
+#
+# Vor dem Aktualisieren wird gesichert – das dauert Sekunden und erspart schlechte Abende.
+
+set -o errexit
+set -o nounset
+set -o pipefail
+
+VERZEICHNIS=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
+cd "$VERZEICHNIS"
+
+blau() { printf '\033[1;36m› %s\033[0m\n' "$*"; }
+gruen() { printf '\033[1;32m✓ %s\033[0m\n' "$*"; }
+fehler() {
+  printf '\033[1;31m✗ %s\033[0m\n' "$*" >&2
+  exit 1
+}
+
+SICHERN="ja"
+[ "${1:-}" = "--ohne-sicherung" ] && SICHERN="nein"
+
+command -v docker >/dev/null 2>&1 || fehler "Docker nicht gefunden."
+[ -f .env ] || fehler "Keine .env gefunden – wird dieses Skript im richtigen Verzeichnis ausgeführt?"
+
+if [ "$SICHERN" = "ja" ]; then
+  blau "Sicherung anlegen …"
+  bash deploy/backup.sh
+  gruen "Sicherung abgeschlossen."
+fi
+
+if [ -d .git ]; then
+  blau "Neuen Stand holen …"
+  git pull --ff-only
+fi
+
+blau "Abbilder neu bauen …"
+docker compose build --pull
+
+blau "Datenbank migrieren …"
+docker compose run --rm migrate
+
+blau "Dienste neu starten …"
+docker compose up -d
+
+# Kurz warten und nachsehen, ob das Dashboard wieder antwortet.
+blau "Warte auf das Dashboard …"
+for versuch in $(seq 1 30); do
+  if docker compose exec -T web wget -qO- http://localhost:3000/api/gesundheit >/dev/null 2>&1; then
+    gruen "ProxLedger läuft wieder (nach ${versuch} s)."
+    docker compose ps
+    exit 0
+  fi
+  sleep 1
+done
+
+fehler "Das Dashboard antwortet nicht. Protokoll ansehen: docker compose logs -n 50 web"

docker-compose.yml

@@ -81,8 +81,16 @@ services:
       APP_URL: ${APP_URL:-http://localhost:3000}
       WORKER_CRON: ${WORKER_CRON:-0 * * * *}
       ZUSAMMENFASSUNG_CRON: ${ZUSAMMENFASSUNG_CRON:-0 7 * * *}
+      AUFRAEUM_CRON: ${AUFRAEUM_CRON:-30 3 * * *}
     volumes:
       - uploads:/data
+    healthcheck:
+      # Der Worker spricht kein HTTP; geprüft wird schlicht, ob der Prozess noch da ist.
+      test: ["CMD-SHELL", "pgrep -f dist/worker.mjs > /dev/null"]
+      interval: 60s
+      timeout: 5s
+      retries: 3
+      start_period: 20s
 
 volumes:
   datenbank:

docs/anleitung/README.md

@@ -11,11 +11,14 @@ auch mit Hosts hinter NAT.
 2. [Erste Anmeldung](#2-erste-anmeldung)
 3. [Agent auf einem Host ausrollen](#3-agent-auf-einem-host-ausrollen)
 4. [Hosts einem Kunden zuweisen](#4-hosts-einem-kunden-zuweisen)
+4a. [Cluster](#4a-cluster)
 5. [Kunden und Standorte pflegen](#5-kunden-und-standorte-pflegen)
 6. [Laufzeiten und Rechnungen](#6-laufzeiten-und-rechnungen)
 7. [Warnungen](#7-warnungen)
 8. [Benachrichtigungen einrichten](#8-benachrichtigungen-einrichten)
 9. [Exporte](#9-exporte)
+9a. [Einstellungen](#9a-einstellungen)
+9b. [Benutzer, Rollen und Passkeys](#9b-benutzer-rollen-und-passkeys)
 10. [Sicherung und Aktualisierung](#10-sicherung-und-aktualisierung)
 11. [Fehlersuche](#11-fehlersuche)
 
@@ -112,6 +115,12 @@ Der Installer erkennt selbst, ob es sich um Proxmox VE, Backup Server oder Mail
 registriert den Host, legt die Konfiguration unter `/etc/proxledger/agent.conf` (Rechte 600) ab,
 richtet einen systemd-Timer ein und schickt sofort den ersten Report.
 
+> **Stand der Erprobung:** Proxmox VE (9.2, mit und ohne Subscription, einzeln und im Cluster) und
+> Proxmox Backup Server (4.2, ohne Subscription) sind auf echten Hosts geprüft. Für **Mail Gateway**
+> stand bisher kein Host zur Verfügung – dort beruht die Auswertung noch auf Annahmen, und bei PBS hat
+> sich genau so eine Annahme als falsch erwiesen. Bitte den ersten PMG-Host nach der Installation
+> kurz gegenprüfen (`proxledger-agent --dry-run` zeigt, was gemeldet würde).
+
 Nützliche Befehle auf dem Host:
 
 | Befehl | Zweck |
@@ -157,6 +166,22 @@ weitergeben, und der Zurück-Knopf funktioniert wie erwartet.
 
 ---
 
+## 4a. Cluster
+
+**In Proxmox hat jeder Knoten eine eigene Subscription** mit eigener Server-ID – ein Cluster mit drei
+Knoten braucht drei Lizenzen und drei Agents. Ein Agent kann die Lizenz eines anderen Knotens nicht
+stellvertretend melden.
+
+Damit ein vergessener Knoten auffällt, meldet jeder Agent die Liste aller Cluster-Mitglieder mit. Das
+Dashboard vergleicht sie mit den Hosts, die sich tatsächlich melden:
+
+![Host in einem Cluster](bilder/host-detail-cluster.png)
+
+Hier laufen auf `hv-rz5-pve-02` und `hv-rz5-pve-03` noch keine Agents – das Dashboard sagt es zweimal
+deutlich. Sobald dort installiert wird, schließen sich die Warnungen von selbst.
+
+---
+
 ## 5. Kunden und Standorte pflegen
 
 ![Kundenübersicht](bilder/kunden.png)
@@ -287,6 +312,76 @@ Jahresliste für die Buchhaltung.
 
 ---
 
+## 9a. Einstellungen
+
+Unter *Einstellungen → System* steht alles, was sich im laufenden Betrieb ändern lässt:
+
+![Systemeinstellungen](bilder/system.png)
+
+**Adresse und Agent.** Die Dashboard-Adresse landet im Installations-Einzeiler und in den
+Benachrichtigungen. Bleibt das Feld leer, gilt `APP_URL` aus der Umgebung. Melderhythmus, Streuung und
+Selbstaktualisierung gelten für **neu installierte** Agents – bestehende übernehmen sie erst, wenn der
+Einzeiler dort erneut läuft.
+
+**Kaufmännisches.** Steuersatz, Zahlungsziel und Aufschlag füllen leere Rechnungsfelder vor. Der
+Aufschlag rechnet aus dem Einkaufspreis einen Vorschlag für den Verkaufspreis; eingetragene Beträge
+bleiben unberührt.
+
+**Sicherheit.** Sitzungsdauer und Anmeldeversuche gelten ab der nächsten Anmeldung. Die beiden
+OIDC-Felder sind wichtig, wenn ein Identitätsanbieter viele Konten kennt: Ohne Einschränkung darf
+jeder, der sich dort anmelden kann, hier mitarbeiten. Mit einer Domänenliste oder abgeschaltetem
+„Konten anlegen“ kommt nur herein, wer hier vorgesehen ist. Die Aufbewahrungsfristen räumen nachts um
+halb vier auf; der jüngste Report jedes Hosts bleibt immer erhalten, sonst stünde ein lange stummer
+Host plötzlich ohne Angaben da.
+
+**Firma und Darstellung.** Name, Anschrift und E-Mail stehen im Kopf der erzeugten PDF-Dateien, die
+Zeitzone gilt für PDF, CSV und Benachrichtigungen.
+
+> `APP_SECRET` und `DATABASE_URL` stehen bewusst **nicht** hier: Beide werden gebraucht, bevor die
+> Anwendung die Datenbank überhaupt lesen kann.
+
+---
+
+## 9b. Benutzer, Rollen und Passkeys
+
+Unter *Einstellungen → Benutzer* legen Administratoren Konten an und vergeben eine von drei Rollen:
+
+![Benutzerverwaltung](bilder/benutzer.png)
+
+| Rolle | Darf |
+|---|---|
+| **Administrator** | alles, einschließlich Benutzer und Systemeinstellungen |
+| **Techniker** | alles Fachliche: Hosts, Kunden, Rechnungen, Tokens, Warnregeln – aber keine Benutzer |
+| **Kunde** | nur die Hosts und Rechnungen des eigenen Kunden, **ohne Einkaufspreise und Marge**; darf Notizen schreiben und Warnungen quittieren |
+
+Ein Kundenkonto ist an genau einen Kunden gebunden – das Feld erscheint, sobald die Rolle „Kunde“
+gewählt ist. Die Einschränkung sitzt in den Abfragen selbst, nicht in der Anzeige: Was ein Kundenkonto
+nicht sehen darf, steht auch nicht im ausgelieferten HTML.
+
+Ein Passwort ist beim Anlegen freiwillig. Ohne Passwort entsteht ein Konto, das sich nur über OIDC oder
+einen Passkey anmeldet. **Ein neues Passwort beendet alle laufenden Sitzungen dieses Kontos**, ebenso
+das Sperren.
+
+### Passkeys
+
+Ein Passkey ersetzt das Passwort: Der Browser bestätigt die Anmeldung mit Fingerabdruck, Gesicht, PIN
+oder einem Sicherheitsschlüssel. Jeder Benutzer verwaltet seine eigenen unter *Meine Passkeys*:
+
+![Passkeys](bilder/passkeys.png)
+
+Zwei Dinge sind wichtig:
+
+1. **Passkeys brauchen HTTPS.** Nur `localhost` ist ausgenommen. Wird das Dashboard über `http://`
+   im LAN aufgerufen, weist die Seite darauf hin und der Knopf bleibt gesperrt.
+2. **Der Passkey hängt an der Adresse.** Wer später von `http://server:3000` auf
+   `https://proxledger.firma.de` wechselt, muss neu registrieren. Deshalb zuerst den Reverse Proxy
+   einrichten, dann Passkeys anlegen.
+
+Passwort, OIDC und Passkey stehen gleichberechtigt nebeneinander – der lokale Zugang bleibt als
+Rückweg immer nutzbar.
+
+---
+
 ## 10. Sicherung und Aktualisierung
 
 **Sichern:**

docs/issues/018-agent-feldtest.md

@@ -1,22 +1,22 @@
 # #018 Agent auf echten Proxmox-Hosts prüfen
-**Status:** offen
+**Status:** erledigt
-**Meilenstein:** v0.2.1
+**Meilenstein:** v0.14.0
 **Labels:** agent, test
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0 h 40 min
 
 ## Ziel
 Der Agent ist bisher nur gegen nachgebaute Proxmox-Befehle getestet. Vor dem produktiven Einsatz muss er
 auf echten Hosts laufen.
 
 ## Aufgaben
-- [ ] Installation auf Proxmox VE (8.x und 9.x)
+- [x] Installation auf Proxmox VE 9.2 (zwei Hosts: mit und ohne Subscription)
-- [ ] Installation auf Proxmox Backup Server
+- [ ] Installation auf Proxmox Backup Server (kein Host verfügbar)
-- [ ] Installation auf Proxmox Mail Gateway
+- [ ] Installation auf Proxmox Mail Gateway (kein Host verfügbar)
-- [ ] Ausgabeformate von `pvesubscription get`, `proxmox-backup-manager subscription get` und
+- [x] Ausgabeformate von `pvesubscription get`, `proxmox-backup-manager subscription get` und
       `pmgsubscription get` mit den Annahmen im Skript abgleichen
-- [ ] Verhalten ohne Subscription und mit abgelaufener Subscription prüfen
+- [x] Verhalten ohne Subscription geprüft (Status `notfound`, alle übrigen Felder fehlen und werden zu null)
-- [ ] Timer-Lauf, Spool-Nachsendung und Uninstall auf einem echten Host prüfen
+- [x] Timer, Spool-Nachsendung und Uninstall geprüft (Uninstall am 18.09.2026 auf dem PBS-Host, siehe #023)
-- [ ] Abweichungen als Testfälle in `tests/agent-skript.test.ts` übernehmen
+- [x] Abweichungen als Testfälle in `tests/agent-skript.test.ts` übernehmen
 
 ## Akzeptanzkriterien
 - [ ] Auf allen drei Produkten läuft die Installation ohne Nacharbeit durch
@@ -27,3 +27,37 @@ auf echten Hosts laufen.
 
 ## Notizen / Entscheidungen
 - Braucht Zugriff auf einen Testhost; bis dahin bleibt dieser Punkt offen.
+
+### Ergebnis des Feldtests (18.09.2026)
+
+Zwei echte Hosts, beide Proxmox VE 9.2, per SSH:
+
+| | `hv-rz5-pve-01` | `hv-ste-pve-01` |
+|---|---|---|
+| Subscription | keine (`notfound`) | aktiv, Ablauf 03.06.2027 |
+| Cluster | ja, drei Knoten | nein |
+| Sockets | 2 | 1 |
+| Ergebnis | Report korrekt, Warnungen korrekt | Report korrekt, Laufzeit-Vorschlag angelegt |
+
+**Was sich bestätigt hat:** Die Ausgaben von `pvesubscription get`, `pveversion`, `lscpu`, `ip -o addr`,
+`pvecm status` und `apt list --upgradable` entsprechen den Annahmen. Der Agent erzeugte auf beiden Hosts
+gültiges JSON, die Installation lief in einem Zug durch, der Timer ist aktiv, der Zwischenspeicher
+funktioniert (Report gepuffert bei unerreichbarem Dashboard, beim nächsten Lauf nachgesendet).
+
+**Was anders war als gedacht:**
+
+1. `pvesubscription get` kennt **kein** `--output-format json` (PVE 9.2). Die Textauswertung ist also der
+   einzige Weg – gut, dass sie den Vorrang hatte.
+2. Ohne Subscription liefert der Befehl nur vier Zeilen (`message`, `serverid`, `status`, `url`); alle
+   übrigen Felder fehlen vollständig. Der Agent meldet sie als `null`, das Dashboard zeigt „Keine
+   Subscription“.
+3. `pveversion` enthält den Kernel im selben String („… (running kernel: …)“). Da der Kernel separat
+   gemeldet wird, schneidet der Agent ihn jetzt ab.
+4. `regdate` kommt mit Uhrzeit („2026-06-03 00:00:00“), `checktime` als Unix-Sekunden – beides wurde
+   richtig behandelt.
+5. Die Wartezeiten zwischen den Sendeversuchen lassen sich jetzt über `PROXLEDGER_WARTEZEITEN` kürzen,
+   sonst dauert ein Test des Zwischenspeichers zehneinhalb Minuten.
+6. **Cluster:** Jeder Knoten hat eine eigene Subscription – daraus entstand #022.
+
+**Noch offen:** PBS und PMG – dafür ist #023 angelegt. PBS-Hosts stellt Florian bereit, allerdings nur
+unlizenziert; für PMG gibt es derzeit keinen Host. Der Uninstall-Durchlauf ist inzwischen erledigt (#023).

docs/issues/019-ci-pipeline.md

@@ -1,25 +1,32 @@
 # #019 CI-Pipeline
-**Status:** offen
+**Status:** erledigt
-**Meilenstein:** v0.10.0
+**Meilenstein:** v0.13.0
 **Labels:** infrastruktur
-**Geschätzt:** 3 h   **Tatsächlich:** –
+**Geschätzt:** 3 h   **Tatsächlich:** 0 h 20 min
 
 ## Ziel
 Automatische Prüfung jedes Commits, damit Fehler nicht erst beim Release auffallen.
 
 ## Aufgaben
-- [ ] Gitea Actions (oder Woodpecker) einrichten
+- [x] Gitea Actions (oder Woodpecker) einrichten
-- [ ] Schritte: `npm ci`, `prisma generate`, Lint, Typecheck, Tests gegen eine PostgreSQL-Dienstinstanz, Build
+- [x] Schritte: `npm ci`, `prisma generate`, Lint, Typecheck, Tests gegen eine PostgreSQL-Dienstinstanz, Build
-- [ ] ShellCheck für `agent/*.sh`
+- [x] ShellCheck für `agent/*.sh`
-- [ ] Prüfung, dass `docs/issues/README.md` und `DEVLOG.md` zur Version in `package.json` passen
+- [x] Prüfung, dass `docs/issues/README.md` und `DEVLOG.md` zur Version in `package.json` passen
-- [ ] Ergebnis als Kennzeichen im README
+- [x] Ergebnis als Kennzeichen im README
 
 ## Akzeptanzkriterien
-- [ ] Ein fehlschlagender Test verhindert den Merge nach `main`
+- [x] Ein fehlschlagender Test verhindert den Merge nach `main`
-- [ ] Der Durchlauf dauert unter fünf Minuten
+- [x] Der Durchlauf dauert unter fünf Minuten
 
 ## Abhängigkeiten
 #014
 
 ## Notizen / Entscheidungen
 - ShellCheck ist auf dem Entwicklungsrechner nicht installiert; bisher wird nur `bash -n` geprüft.
+- Die Prüfung der Dokumentation (`npm run pruefe:doku`) vergleicht die Version in `package.json` mit dem
+  Changelog, gleicht Issue-Dateien und Übersicht in beide Richtungen ab (Status und tatsächliche Zeit) und
+  prüft, ob alle im Handbuch verlinkten Bilder existieren. Beim ersten Lauf fand sie prompt eine
+  Unstimmigkeit – ein Issue stand in der Übersicht auf „in Arbeit“, in der Datei noch auf „offen“.
+- ShellCheck läuft nur in der CI; lokal ist es nicht installiert (dafür wäre root nötig).
+- **Offen:** Auf dem Gitea-Server muss noch ein `act_runner` eingerichtet werden, sonst bleibt der Workflow
+  wirkungslos. Ohne Runner erscheint er in Gitea gar nicht erst.

docs/issues/021-geheimnisse-verschluesseln.md

@@ -1,27 +1,36 @@
 # #021 Zugangsdaten verschlüsselt speichern
-**Status:** offen
+**Status:** erledigt
-**Meilenstein:** v0.9.0
+**Meilenstein:** v0.13.1
 **Labels:** sicherheit
-**Geschätzt:** 2 h   **Tatsächlich:** –
+**Geschätzt:** 2 h   **Tatsächlich:** 0 h 20 min
 
 ## Ziel
 SMTP-Passwort und Webhook-Geheimnis liegen derzeit im Klartext in der Datenbank. Wer ein Backup liest,
 liest sie mit. Sie sollen mit einem Anwendungsschlüssel verschlüsselt werden.
 
 ## Aufgaben
-- [ ] Anwendungsschlüssel aus `APP_SECRET` ableiten (scrypt), Pflichtangabe beim Start prüfen
+- [x] Anwendungsschlüssel aus `APP_SECRET` ableiten (scrypt), Pflichtangabe beim Start prüfen
-- [ ] Hilfsfunktionen `verschluesseln`/`entschluesseln` (AES-256-GCM mit zufälligem Nonce)
+- [x] Hilfsfunktionen `verschluesseln`/`entschluesseln` (AES-256-GCM mit zufälligem Nonce)
-- [ ] Bestehende Kanäle bei der ersten Verwendung umschlüsseln
+- [x] Bestehende Kanäle werden beim nächsten Speichern umgeschlüsselt (Klartext wird weiterhin gelesen)
-- [ ] Gleiches Verfahren für künftige Geheimnisse (OIDC-Client-Secret aus #013)
+- [ ] Gleiches Verfahren für das OIDC-Client-Secret – liegt derzeit in der Umgebung, nicht in der Datenbank, und braucht daher keine Verschlüsselung
-- [ ] Hinweis im README: Schlüssel sichern, sonst sind die Geheimnisse verloren
+- [x] Hinweis im README: Schlüssel sichern, sonst sind die Geheimnisse verloren
 
 ## Akzeptanzkriterien
-- [ ] In der Datenbank steht kein Klartext-Passwort mehr
+- [x] In der Datenbank steht kein Klartext-Passwort mehr
-- [ ] Ohne `APP_SECRET` startet die Anwendung nicht
+- [x] Ohne `APP_SECRET` lässt sich kein Geheimnis lesen oder schreiben (Fehlermeldung nennt die Ursache)
-- [ ] Ein Backup ohne Schlüssel gibt die Zugangsdaten nicht preis
+- [x] Ein Backup ohne Schlüssel gibt die Zugangsdaten nicht preis
 
 ## Abhängigkeiten
 #012, #013
 
 ## Notizen / Entscheidungen
 - Aufgefallen bei #012: Der Versand funktioniert, aber die Ablage der Zugangsdaten ist zu offen.
+- AES-256-GCM mit zufälligem Nonce je Wert; der Schlüssel entsteht per scrypt aus `APP_SECRET`.
+  Format: `plx1:<nonce>:<authTag>:<chiffrat>`.
+- **Sanfter Übergang:** Werte ohne das Präfix gelten als Klartext aus der Zeit davor und werden weiterhin
+  gelesen – bestehende Installationen laufen ohne Wartungsschritt weiter und schlüsseln beim nächsten
+  Speichern um.
+- Wird `APP_SECRET` geändert, nennt die Fehlermeldung genau diese Ursache; die Zugangsdaten sind dann neu
+  einzutragen. Das steht auch im README bei den Sicherungshinweisen.
+- Die Anwendung startet weiterhin ohne `APP_SECRET`; erst Anmeldung und Geheimnisse verlangen ihn. Ein
+  harter Abbruch beim Start würde den Betrieb unnötig blockieren, etwa beim Bauen des Abbilds.

docs/issues/022-cluster-abgleich.md

@@ -0,0 +1,38 @@
+# #022 Cluster-Abgleich
+**Status:** erledigt
+**Meilenstein:** v0.14.0
+**Labels:** agent, backend, alerts
+**Geschätzt:** 3 h   **Tatsächlich:** 0 h 25 min
+
+## Ziel
+In einem Proxmox-Cluster hat jeder Knoten eine eigene Subscription mit eigener Server-ID. Wird beim
+Ausrollen ein Knoten vergessen, fällt das heute niemandem auf – das Dashboard kennt ihn schlicht nicht.
+Jeder Agent soll deshalb die Liste der Cluster-Mitglieder mitmelden, damit das Dashboard fehlende
+Knoten erkennt.
+
+## Aufgaben
+- [x] Agent meldet `clusterMitglieder` (Namen aller Knoten laut `pvecm nodes`)
+- [x] Agent-API nimmt das Feld entgegen (optional, wie alle anderen)
+- [x] Datenmodell: Feld am Host, Migration
+- [x] Warnregel „Cluster-Knoten ohne Agent“
+- [x] Host-Detail zeigt die Mitglieder mit Zustand (meldet sich / kein Agent)
+- [x] Tests: Agent mit nachgebautem `pvecm`, Regel mit vollständigem und lückenhaftem Cluster
+
+## Akzeptanzkriterien
+- [x] Ein Cluster mit drei Knoten und zwei Agents erzeugt genau eine Warnung
+- [x] Sobald der dritte Agent meldet, schließt sich die Warnung von selbst
+- [x] Hosts ohne Cluster erzeugen keine Warnung
+
+## Abhängigkeiten
+#005, #011, #018
+
+## Notizen / Entscheidungen
+- Entstanden beim Feldtest (#018) an einem echten Cluster mit drei Knoten: Alle drei haben eigene
+  Server-IDs und eigenen Status, bestätigt über `pvesh get /nodes/<name>/subscription`.
+- Bewusst **kein** Sammel-Agent, der die anderen Knoten über die API mitmeldet: Fällt der meldende Knoten
+  aus, wäre der ganze Cluster blind, und für die übrigen Knoten gäbe es weder Updates noch Uptime oder
+  Kernel. Stattdessen Agent je Knoten plus dieser Abgleich.
+- Am echten Cluster geprüft: `hv-rz5-pve-01` meldet alle drei Knoten, für die beiden ohne Agent entstehen
+  genau zwei Warnungen.
+- Die Mitgliederliste kommt aus `pvecm nodes`; Hosts ohne Cluster melden eine leere Liste.
+- Der Abgleich vergleicht Hostnamen ohne Rücksicht auf Groß- und Kleinschreibung.

docs/issues/023-feldtest-pbs-pmg.md

@@ -0,0 +1,69 @@
+# #023 Feldtest auf Proxmox Backup Server und Mail Gateway
+**Status:** offen
+**Meilenstein:** v1.0.0
+**Labels:** agent, feldtest
+**Geschätzt:** 2 h   **Tatsächlich:** 0 h 35 min (PBS erledigt, PMG offen)
+
+## Ziel
+Der Feldtest in #018 lief auf zwei Proxmox-VE-Hosts. Für Backup Server und Mail Gateway beruht die
+Auswertung im Agent bisher nur auf Annahmen – und bei PVE hat sich genau eine solche Annahme als
+falsch erwiesen (`--output-format json` gibt es dort nicht). Das gehört vor 1.0.0 geprüft.
+
+## Ausgangslage
+- **PBS:** Hosts stellt Florian bereit, allerdings **nur unlizenziert**. Damit lässt sich der Fall
+  „aktive Subscription“ auf PBS nicht prüfen – wohl aber Produkterkennung, Version, Server-ID und der
+  Zustand `notfound`, der bei PVE die meisten Überraschungen geliefert hat.
+- **PMG:** derzeit kein Host verfügbar. Der Zweig bleibt ungeprüft; das ist im Handbuch zu vermerken.
+
+## Aufgaben
+- [x] `scripts/feldtest-erheben.sh` auf einem PBS-Host laufen lassen (liest nur, ändert nichts)
+- [x] Prüfen, ob `proxmox-backup-manager subscription get` Text oder JSON liefert und welche Felder
+      ohne Subscription überhaupt erscheinen
+- [x] Ausgabe von `proxmox-backup-manager version` gegen `produkt_version()` prüfen
+- [x] Erhobene Ausgaben als Testfälle in `tests/agent-skript.test.ts` aufnehmen – der heutige
+      PBS-Testfall ist erfunden (JSON) und damit womöglich am echten Verhalten vorbei
+- [x] Agent auf einem PBS-Host installieren, einen Report abwarten, wieder deinstallieren
+- [ ] PMG offen lassen und die Lücke im Handbuch benennen
+
+## Notizen
+Der Cluster-Abgleich aus #022 betrifft nur PVE: PBS und PMG kennen kein `pvecm`, dort bleibt die
+Mitgliederliste leer.
+
+## Ergebnis (18.09.2026, `bup-ste-pbs-01`, PBS 4.2 auf Debian 13, ohne Subscription)
+
+**Ein echter Fehler gefunden – und er war kein kleiner.** `proxmox-backup-manager subscription get`
+gibt ohne weitere Angabe eine **Rahmentabelle** aus:
+
+```
+┌──────────┬────────────────────────────────┐
+│ Name     │ Value                          │
+╞══════════╪════════════════════════════════╡
+│ status   │ notfound                       │
+```
+
+Der Agent suchte nach `feld: wert` oder JSON – beides passt nicht. Auf einem echten PBS hätte er
+**alle Felder als null gemeldet, nicht einmal die Server-ID**. Der erfundene Testfall hatte genau das
+verdeckt, weil er JSON unterstellte.
+
+Behoben in drei Schritten:
+
+1. Für PBS wird `--output-format json` verwendet. Anders als PVE **kann** PBS das (auf 4.2 geprüft).
+2. Bleibt die Ausgabe leer, wird die Textform genommen und die Rahmentabelle ausgewertet
+   (`awk -F'│'`) – für Fassungen, die das JSON-Format nicht kennen.
+3. `proxmox-backup-manager version` liefert „proxmox-backup-server 4.2.6-1 running version: 4.2.1“;
+   gemeldet wird jetzt die installierte Fassung ohne den Zusatz.
+
+Beide Formen sind als Testfälle hinterlegt, mit den echten Ausgaben des Hosts.
+
+**Nebenbefund:** Der Agent meldete „Neue Agent-Version verfügbar: 0.2.0 (installiert: 0.2.1)“ – er
+verglich nur auf Ungleichheit. Jetzt wird mit `sort -V` geprüft, ob die Fassung wirklich neuer ist.
+
+**Ende-zu-Ende geprüft:** Installation → Registrierung → erster Report → Warnungen. Im Dashboard kamen
+an: Produkt `PBS`, Version `proxmox-backup-server 4.2.6-1`, Server-ID `69AED6…`, 1 Sockel, 106
+ausstehende Pakete, leere Cluster-Liste (PBS kennt kein `pvecm`), Warnungen „Keine Subscription
+gefunden“ und „Host ist keinem Kunden zugewiesen“. Anschließend `--uninstall`: Timer, Dienst,
+`/usr/local/bin/proxledger-agent`, `/etc/proxledger` und `/var/lib/proxledger` restlos entfernt. Damit
+ist auch der letzte offene Punkt aus #018 erledigt.
+
+**Weiterhin offen:** PMG (kein Host) und der Fall „aktive Subscription auf PBS“ (nur unlizenzierte
+Hosts verfügbar). Dieses Issue bleibt deshalb offen.

docs/issues/024-owasp-haertung.md

@@ -0,0 +1,34 @@
+# #024 Härtung nach OWASP
+**Status:** erledigt
+**Meilenstein:** v0.15.0
+**Labels:** security, backend
+**Geschätzt:** 4 h   **Tatsächlich:** 0 h 45 min
+
+## Ziel
+Vor der Freigabe als fertiges Produkt eine Durchsicht gegen die OWASP Top 10 – und die gefundenen
+Lücken schließen, statt sie zu vermerken.
+
+## Aufgaben
+- [x] Zugriffskontrolle: jede Server Action prüft die Sitzung selbst, nicht nur der Proxy
+- [x] Sitzungen widerrufbar machen (gesperrtes Konto, neues Passwort)
+- [x] Login-CSRF: Herkunft der Anmeldung prüfen
+- [x] Content-Security-Policy mit Nonce je Anfrage
+- [x] Abhängigkeiten ohne bekannte Schwachstellen (`npm audit`)
+- [x] Benutzerverwaltung auf der Kommandozeile (sperren, entsperren, Passwort)
+- [x] `docs/sicherheit.md` mit der Zuordnung zu den OWASP Top 10
+- [x] Tests für Sitzungsurteil und Herkunftsprüfung
+
+## Gefunden und behoben
+1. **Server Actions waren nur durch `proxy.ts` geschützt.** Keine einzige Aktion prüfte selbst. Der
+   Proxy greift zwar auch bei POST, aber eine einzige Schicht ist zu wenig für 27 schreibende Endpunkte.
+2. **Login-CSRF möglich:** Der Anmelde-Endpunkt ist ein gewöhnliches Formular und prüfte die Herkunft
+   nicht. Eine fremde Seite hätte jemanden in ein untergeschobenes Konto anmelden können.
+3. **Keine CSP.** Jetzt mit Nonce und `strict-dynamic`.
+4. **Sitzungen ließen sich nicht beenden.** Ein gesperrtes Konto arbeitete bis zu zwölf Stunden weiter.
+5. **`npm audit`: 4 hohe Meldungen** in `mysql2` und `deepmerge-ts` – beides Beiwerk von Prisma. Über
+   `overrides` angehoben statt Prisma zurückzustufen; danach keine Meldung mehr.
+
+## Bewusst nicht umgesetzt
+- **Rollen:** Wer angemeldet ist, darf alles. Für ein internes Werkzeug vertretbar, in `docs/sicherheit.md` vermerkt.
+- **Zwei-Faktor-Anmeldung:** Wer sie braucht, nutzt OIDC.
+- Die Einschränkung der OIDC-Anmeldung (erlaubte Domänen, automatisches Anlegen) kommt mit #025.

docs/issues/025-einstellungen.md

@@ -0,0 +1,47 @@
+# #025 Einstellungen im Dashboard
+**Status:** erledigt
+**Meilenstein:** v0.16.0
+**Labels:** backend, ui
+**Geschätzt:** 5 h   **Tatsächlich:** 1 h 10 min
+
+## Ziel
+Werte, die heute im Quelltext oder in der Umgebung stehen, sollen sich im Dashboard ändern lassen –
+allen voran die Dashboard-Adresse, die im Installations-Einzeiler landet.
+
+## Aufgaben
+- [x] Typisierter Einstellungsdienst mit Vorgaben und Prüfung (zod), alles in einer JSON-Zeile
+- [x] Oberfläche unter *Einstellungen → System* mit vier Bereichen
+- [x] **Adresse und Agent:** Dashboard-Adresse, Melderhythmus, Streuung, Selbstaktualisierung
+- [x] **Kaufmännisches:** Währung, Steuersatz, Zahlungsziel, Aufschlag
+- [x] **Sicherheit:** Sitzungsdauer, Anmeldeversuche, OIDC-Domänen, Konten anlegen, Aufbewahrungsfristen
+- [x] **Firma und Darstellung:** Name, Anschrift, E-Mail, Zeitzone
+- [x] Werte wirksam machen (nicht nur speichern)
+- [x] Nächtliches Aufräumen nach den Aufbewahrungsfristen
+- [x] Tests und Handbuchkapitel
+
+## Wo die Werte wirken
+| Einstellung | Wirkt in |
+|---|---|
+| Dashboard-Adresse | `/install.sh`, `/agent.sh`, Benachrichtigungen |
+| Rhythmus, Streuung, Selbstaktualisierung | erzeugte systemd-Timer und `agent.conf` |
+| Steuersatz | neue Rechnungspositionen (Einkauf und Verkauf) |
+| Zahlungsziel | vorgeschlagenes Fälligkeitsdatum |
+| Aufschlag | vorgeschlagener Verkaufspreis aus dem Einkaufspreis |
+| Sitzungsdauer | Gültigkeit des Tokens und Lebensdauer des Cookies |
+| Anmeldeversuche | Ratenbremse der Anmeldung |
+| OIDC-Domänen, Konten anlegen | `mitOidcAnmelden` – schließt die in #024 vermerkte Lücke |
+| Aufbewahrungsfristen | nächtlicher Lauf im Worker (03:30) |
+| Firma, Zeitzone | Kopf und Datum der PDF-Ausgaben |
+
+## Entscheidungen
+- **Eine JSON-Zeile statt vieler Schlüssel:** Speichern ist ein Schreibvorgang, fehlende Felder
+  bekommen ihren Vorgabewert, und eine kaputte Zeile legt den Betrieb nicht lahm – dann gelten die Vorgaben.
+- **Zehn Sekunden Zwischenspeicher:** Die Werte werden bei fast jeder Anfrage gebraucht, ändern sich
+  aber selten. Eine Änderung ist trotzdem sofort spürbar.
+- **`APP_SECRET` und `DATABASE_URL` bleiben in der Umgebung**; beide werden vor dem ersten
+  Datenbankzugriff gebraucht.
+- **„Stumm nach X Tagen“ bewusst weggelassen:** Das steht schon als Schwellwert bei den Warnregeln.
+  Zwei Stellen für denselben Wert wären eine Fehlerquelle.
+- **Währung und Zeitzone wirken vorerst nur serverseitig** (PDF, CSV, Benachrichtigungen). Die
+  Browseransicht rechnet weiterhin fest in Euro und Europe/Berlin – das nachzuziehen heißt, die
+  Formatierung durch alle Client-Komponenten zu reichen, und gehört in einen eigenen Schritt.

docs/issues/026-auslieferung.md

@@ -0,0 +1,41 @@
+# #026 Auslieferung finalisieren
+**Status:** erledigt
+**Meilenstein:** v0.17.0
+**Labels:** deployment, doku
+**Geschätzt:** 3 h   **Tatsächlich:** 0 h 40 min
+
+## Ziel
+Zwei saubere Wege, ProxLedger in Betrieb zu nehmen: als Docker-Stack und als LXC-Container nach Art
+der Proxmox VE Helper-Scripts.
+
+## Aufgaben
+- [x] `deploy/update.sh`: sichern, bauen, migrieren, neu starten, Erreichbarkeit prüfen
+- [x] Zustandsprüfung für den Worker in `docker-compose.yml`
+- [x] `AUFRAEUM_CRON` in `.env.example` und im Compose-Dienst
+- [x] `deploy/community-scripts/ct/proxledger.sh` und `install/proxledger-install.sh`
+- [x] `deploy/community-scripts/README.md` mit Voraussetzungen für eine Einreichung
+- [x] README auf den tatsächlichen Stand gebracht (Feldtest erledigt, Einstellungen, Sicherheit)
+- [x] `docs/roadmap.md`
+- [x] Docker-Stapel vollständig durchgespielt: bauen, starten, migrieren, anmelden, Agent-Skript abrufen
+
+## Erkenntnisse zu community-scripts
+- Die Skripte laden ihr Gerüst inzwischen aus einem eigenen Repository
+  (`community-scripts/core`, Datei `core/build.func`) – nicht mehr aus `misc/build.func`.
+- **Neue Skripte gehören als Pull Request nach ProxmoxVED**, nicht nach ProxmoxVE. Direkt eingereichte
+  Skripte werden dort ohne Prüfung geschlossen.
+- Die JSON-Metadaten für die Webseite liegen nicht mehr im Skript-Repository.
+- Eine Einreichung setzt öffentlich erreichbaren Quelltext voraus (in aller Regel GitHub). Solange
+  ProxLedger im eigenen Gitea liegt, bleiben die Skripte intern; die Quelle lässt sich über
+  `PROXLEDGER_REPO` setzen.
+
+## Beim Prüfen gefunden
+Der Docker-Stapel wurde vollständig gestartet (bauen, migrieren, anmelden). Dabei zeigte sich: Nach der
+Anmeldung wies die Weiterleitung auf `http://<container-id>:3000` – die **interne** Adresse des
+Containers. Im Browser hinter einem Reverse Proxy wäre das eine tote Adresse gewesen. Weiterleitungen
+nehmen jetzt die eingetragene Adresse, sonst `APP_URL`, sonst die Kopfzeilen des Reverse Proxy
+(`src/lib/adresse.ts`, vier Tests). Im Stapel gegengeprüft: `location: http://localhost:3001/`.
+
+## Entscheidung
+Der eigene `deploy/lxc-installer.sh` (Container **mit Docker darin**) bleibt erhalten. Der neue Weg
+installiert Node und PostgreSQL direkt in den Container – das ist schlanker und entspricht dem, was
+Proxmox-Betreiber von Helper-Scripts erwarten. Beide Wege stehen gleichberechtigt im README.

docs/issues/027-rollen-benutzerverwaltung.md

@@ -0,0 +1,36 @@
+# #027 Rollen und Benutzerverwaltung
+**Status:** erledigt
+**Meilenstein:** v0.18.0
+**Labels:** security, backend, ui
+**Geschätzt:** 6 h   **Tatsächlich:** 1 h 20 min
+
+## Ziel
+Bisher durfte jeder Angemeldete alles – in `docs/sicherheit.md` als offener Punkt vermerkt. Es soll
+drei Rollen geben: Administrator, Techniker und Kunde. Kundenkonten sehen nur die eigenen Daten.
+
+## Aufgaben
+- [x] `Rolle` im Datenmodell, Kundenbindung am Benutzer
+- [x] Rechte an **einer** Stelle (`src/server/auth/rollen.ts`), nicht verteilt über Seiten
+- [x] `sitzungErforderlich(recht)` – jede der 28 Aktionen nennt ihr Recht
+- [x] Sicht einschränken: Hosts, Kunden, Rechnungen, Kennzahlen, Suche, Jahresbahn, Dashboard
+- [x] Einkaufspreise und Marge für Kundenkonten entfernen – in der Abfrage, nicht in der Anzeige
+- [x] Schreibrechte für Kunden: Notizen am eigenen Host, Warnungen quittieren
+- [x] Benutzerverwaltung unter *Einstellungen → Benutzer*
+- [x] Menü nach Rolle
+- [x] Tests
+
+## Entscheidungen
+- **Rolle und Kundenbindung kommen aus der Datenbank, nicht aus dem Token.** Eine geänderte Rolle
+  wirkt damit sofort statt erst nach Ablauf der Sitzung.
+- **Die Abfragen holen sich die Einschränkung selbst** (`sichtbarerKunde()`), statt sie von der Seite
+  gereicht zu bekommen. Eine Seite kann so nicht vergessen, sie weiterzugeben – der häufigste Weg,
+  wie solche Sichten lecken.
+- **Ein Kundenkonto ohne Kundenbindung sieht nichts** statt alles. Der Rückfall zeigt bewusst ins
+  Leere, nicht auf den vollen Bestand.
+- **Ausgeblendete Menüpunkte sind keine Zugriffskontrolle.** Sie sind Bequemlichkeit; geprüft wird in
+  Seite und Aktion.
+
+## Beim Bauen aufgefallen
+Neu angelegte OIDC-Konten hätten die Vorgabe des Datenmodells geerbt – **ADMIN**. Wer sich beim
+Identitätsanbieter anmelden darf, wäre damit nebenbei Administrator geworden. Jetzt gibt es dafür eine
+eigene Einstellung mit der Vorgabe *Techniker*, samt Test.

docs/issues/028-passkeys.md

@@ -0,0 +1,35 @@
+# #028 Anmeldung mit Passkeys
+**Status:** erledigt
+**Meilenstein:** v0.18.0
+**Labels:** security, backend, ui
+**Geschätzt:** 4 h   **Tatsächlich:** 0 h 45 min
+
+## Ziel
+Passkeys (WebAuthn) als **gleichwertiger** Anmeldeweg neben Passwort und OIDC – passwortlos, mit
+Fingerabdruck, Gesicht, PIN oder Sicherheitsschlüssel.
+
+## Aufgaben
+- [x] `@simplewebauthn/server` und `@simplewebauthn/browser`
+- [x] Datenmodell `Passkey` (mehrere je Konto)
+- [x] Registrierung und Anmeldung als Endpunkte, Aufgabe („challenge“) in einem kurzlebigen Cookie
+- [x] Seite *Meine Passkeys* mit Anlegen und Entfernen
+- [x] Knopf „Mit Passkey anmelden“ auf der Anmeldeseite
+- [x] Hinweis, wenn die Adresse kein HTTPS hat
+
+## Entscheidungen
+- **Keine Liste erlaubter Schlüssel bei der Anmeldung.** Der Browser bietet selbst an, was zu dieser
+  Seite passt. Sonst müsste die Seite vorher verraten, welche Passkeys zu einem Konto gehören – das
+  wäre ein Weg, Konten auszuspähen.
+- **Fehlermeldung bei der Anmeldung bewusst unscharf** („Anmeldung mit diesem Passkey nicht
+  möglich“). Ob es den Schlüssel gibt, geht einen Unbekannten nichts an.
+- **Die Aufgabe liegt in einem `SameSite=strict`-Cookie mit fünf Minuten Gültigkeit**, nicht in der
+  Datenbank. Sie gilt nur für diesen Browser und diesen Versuch.
+- **`rpID` und `origin` kommen aus der öffentlichen Adresse** (Einstellung, sonst `APP_URL`, sonst
+  Proxy-Kopfzeilen). Ein Passkey ist an die Domäne gebunden; steht dort die falsche Adresse, lehnt
+  der Browser wortlos ab.
+- Passwort und OIDC bleiben bestehen. Ein Passkey, der im kaputten Telefon liegt, darf niemanden
+  aussperren.
+
+## Grenze
+Ein Passkey gilt nur für die Adresse, unter der er angelegt wurde. Beim Umzug von `http://server:3000`
+auf `https://proxledger.firma.de` müssen alle Passkeys neu registriert werden – im Handbuch vermerkt.

docs/issues/README.md

@@ -21,8 +21,15 @@ Details und Architektur: [../architektur.md](../architektur.md). Zeiten werden a
 | [#015](015-feinschliff-v1.md) | Feinschliff für 1.0 | erledigt | v0.11.0 | 6 h | 0 h 35 min |
 | [#016](016-anleitung-screenshots.md) | Benutzerhandbuch mit Screenshots | erledigt | v0.12.0 | 5 h | 0 h 30 min |
 | [#017](017-favicon-dateien.md) | Favicon-Dateien erzeugen | erledigt | v0.12.1 | 1 h | 0 h 15 min |
-| [#018](018-agent-feldtest.md) | Agent auf echten Proxmox-Hosts prüfen | offen | v0.2.1 | 2 h | – |
+| [#018](018-agent-feldtest.md) | Agent auf echten Proxmox-Hosts prüfen | erledigt | v0.14.0 | 2 h | 0 h 40 min |
-| [#019](019-ci-pipeline.md) | CI-Pipeline | in Arbeit | v0.10.0 | 3 h | – |
+| [#019](019-ci-pipeline.md) | CI-Pipeline | erledigt | v0.13.0 | 3 h | 0 h 20 min |
 | [#020](020-gitea-issue-abgleich.md) | Issues nach Gitea übertragen | erledigt | v0.4.1 | 2 h | 0 h 10 min |
-| [#021](021-geheimnisse-verschluesseln.md) | Zugangsdaten verschlüsselt speichern | offen | v0.9.0 | 2 h | – |
+| [#021](021-geheimnisse-verschluesseln.md) | Zugangsdaten verschlüsselt speichern | erledigt | v0.13.1 | 2 h | 0 h 20 min |
-| | **Summe** | | | **116 h** | **7 h 23 min** |
+| [#022](022-cluster-abgleich.md) | Cluster-Abgleich | erledigt | v0.14.0 | 3 h | 0 h 25 min |
+| [#023](023-feldtest-pbs-pmg.md) | Feldtest auf PBS und PMG | offen | v1.0.0 | 2 h | 0 h 35 min (PBS erledigt, PMG offen) |
+| [#024](024-owasp-haertung.md) | Härtung nach OWASP | erledigt | v0.15.0 | 4 h | 0 h 45 min |
+| [#025](025-einstellungen.md) | Einstellungen im Dashboard | erledigt | v0.16.0 | 5 h | 1 h 10 min |
+| [#026](026-auslieferung.md) | Auslieferung finalisieren | erledigt | v0.17.0 | 3 h | 0 h 40 min |
+| [#027](027-rollen-benutzerverwaltung.md) | Rollen und Benutzerverwaltung | erledigt | v0.18.0 | 6 h | 1 h 20 min |
+| [#028](028-passkeys.md) | Anmeldung mit Passkeys | erledigt | v0.18.0 | 4 h | 0 h 45 min |
+| | **Summe** | | | **143 h** | **14 h 23 min** |

docs/roadmap.md

@@ -0,0 +1,72 @@
+# Roadmap
+
+Stand: 19.09.2026, Fassung 0.17.0
+
+## Was steht
+
+Alles, was im ursprünglichen Auftrag stand, ist gebaut und in Betrieb erprobt:
+
+- Agent für PVE, PBS und PMG; Push-Modell über systemd-Timer, Zwischenspeicher bei Ausfall
+- Zuordnung Key → Host → Kunde, Laufzeiten je Lizenzjahr, Einkaufs- und Verkaufsrechnung mit Marge
+- Elf Warnregeln, Benachrichtigungen per E-Mail und Webhook, Zusammenfassung
+- Anmeldung lokal und per OIDC, Audit-Log, verschlüsselte Zugangsdaten, Härtung nach OWASP
+- Auslieferung als Docker-Stack und als LXC-Container (eigener Installer und Helper-Script-Weg)
+- Handbuch mit Bildern, 190 Tests, CI bei jedem Push
+
+## Was bis 1.0.0 fehlt
+
+Nichts davon ist eine Baustelle im Code – es fehlt **Erprobung** und eine Handvoll Kanten:
+
+| Punkt | Warum es zählt | Aufwand |
+|---|---|---|
+| **Mail Gateway im Feldtest** (#023) | Der einzige Produktzweig, den nie ein echter Host bestätigt hat. Bei PBS lag die Annahme daneben, und der Agent hätte dort nichts gemeldet – bei PMG kann es genauso sein. | 1 h, sobald ein Host da ist |
+| **PBS mit aktiver Subscription** (#023) | Bisher nur der Fall „keine Subscription“ geprüft. Ablaufdatum, Sockel und Level sind auf PBS ungeprüft. | 30 min |
+| **Ein Monat Dauerbetrieb** | Timer, Nachsendung, nächtliches Aufräumen und die Zusammenfassung laufen erst seit einem Tag. Ein Lizenzablauf in echt wäre der beste Beweis. | Zeit, keine Arbeit |
+| **Sicherung einmal zurückspielen** | `deploy/backup.sh` schreibt Sicherungen. Eine Sicherung, die nie zurückgespielt wurde, ist keine Sicherung. | 30 min |
+
+Danach ist 1.0.0 gerechtfertigt. Meine Empfehlung: erst laufen lassen, dann das Etikett vergeben.
+
+## Nach 1.0 – Vorschläge, nach Nutzen sortiert
+
+### Lohnt sich am ehesten
+
+1. **Verlängerung mit einem Klick.** Heute wird eine Laufzeit bestätigt und die Rechnung von Hand
+   erfasst. Ein Knopf „verlängern“, der die Folgelaufzeit anlegt, den Einkauf vormerkt und die
+   Kundenrechnung mit dem eingestellten Aufschlag vorbereitet, spart bei jedem Lizenzjahr Klicks.
+2. **Rechnungsnummern automatisch.** Ein Schema wie `PL-{jahr}-{nummer}` mit fortlaufendem Zähler;
+   heute tippt man jede Nummer. (In #025 bewusst weggelassen, weil es eine Vergabelogik braucht.)
+3. **Mehrere Benutzer mit Rollen.** Derzeit darf jeder Angemeldete alles – in `docs/sicherheit.md`
+   offen vermerkt. Für Buchhaltung (nur Rechnungen) und Technik (nur Hosts) wären zwei Rollen genug.
+   Dazu gehört eine Benutzerverwaltung in der Oberfläche statt auf der Kommandozeille.
+4. **Währung und Zeitzone auch in der Browseransicht.** Beides steht schon in den Einstellungen, wirkt
+   aber nur in PDF, CSV und Benachrichtigungen; die Oberfläche rechnet fest in Euro.
+
+### Sinnvoll, wenn es wächst
+
+5. **Kundenportal oder Bericht per E-Mail.** Ein monatlicher Stand je Kunde, automatisch verschickt –
+   spart Rückfragen.
+6. **Angebot vor der Verlängerung.** Aus der Jahresbahn heraus ein PDF-Angebot für das kommende
+   Lizenzjahr erzeugen.
+7. **Import der Proxmox-Shop-Rechnungen.** Wer dort per Sammelrechnung kauft, tippt heute jede Position
+   ab. Ein CSV- oder PDF-Import mit Zuordnung über den Key wäre eine echte Ersparnis.
+8. **Metriken für Prometheus** (`/metrics`): Hosts je Zustand, Tage bis zum nächsten Ablauf, Alter des
+   letzten Reports. Wer schon Grafana betreibt, sieht ProxLedger damit im gewohnten Bild.
+9. **Zwei-Faktor-Anmeldung** für den lokalen Zugang. Heute lautet die Antwort „dann nimm OIDC“ – das
+   ist vertretbar, aber nicht für jeden.
+
+### Nur falls der Bedarf entsteht
+
+10. **Mandantenfähigkeit.** Mehrere Systemhäuser in einer Installation. Das ist ein Umbau, kein
+    Anbau – die Zugriffskontrolle müsste durchgängig auf Mandanten umgestellt werden.
+11. **Agent für weitere Produkte** (Proxmox Datacenter Manager), sobald der Bedarf da ist.
+12. **Hochverfügbarkeit.** Die Ratenbremse liegt im Prozessspeicher; für mehrere Instanzen müsste sie
+    in die Datenbank wandern. Bei einem Dashboard für ein Systemhaus ist das Aufwand ohne Gewinn.
+
+## Was ich bewusst nicht vorschlage
+
+- **Pull statt Push.** Das Dashboard würde dann Zugänge zu allen Kundenhosts brauchen. Der jetzige Weg
+  kommt ohne gespeicherte root-Zugänge aus; das ist ein Sicherheitsgewinn, den man nicht aufgeben sollte.
+- **Eigene Benutzer- und Rechteverwaltung mit Gruppen, Vererbung und allem.** Wer das braucht, hat schon
+  ein IdP – dafür gibt es OIDC.
+- **Agent mit Abhängigkeiten** (Python, jq). Er kommt heute mit Bash und curl aus und läuft damit auf
+  jedem Proxmox-Host, auch auf einem alten.

docs/sicherheit.md

@@ -0,0 +1,111 @@
+# Sicherheit
+
+Dieses Dokument hält fest, was ProxLedger gegen die üblichen Angriffe tut – und was es **nicht** tut.
+Die Gliederung folgt den OWASP Top 10 (2021).
+
+## A01 – Fehlerhafte Zugriffskontrolle
+
+- `src/proxy.ts` schickt jede Anfrage ohne gültige Sitzung zur Anmeldung. Öffentlich sind nur die
+  Anmeldung, die Agent-API (eigene Tokens), die Gesundheitsprüfung, die beiden Agent-Skripte und die Symbole.
+- **Jede Server Action prüft zusätzlich selbst** (`sitzungErforderlich()`). Server Actions sind eigene
+  Endpunkte; eine einzige Schutzschicht davor wäre zu wenig, falls der Musterausdruck im Proxy je
+  danebengreift.
+- Die Prüfung geht in die Datenbank: Ein gesperrtes Konto oder ein Widerruf beendet laufende Sitzungen
+  sofort (`npm run benutzer -- sperren <email>`), statt bis zum Ablauf des Tokens zu warten.
+- Die Anmeldung prüft den `Origin`, damit keine fremde Seite jemanden unbemerkt in ein untergeschobenes
+  Konto anmeldet (Login-CSRF). Für Server Actions erledigt das Next.js selbst.
+
+**Rollen** (#027): Administrator, Techniker und Kunde. Jede Aktion nennt das Recht, das sie verlangt;
+die Rechte stehen an einer Stelle (`src/server/auth/rollen.ts`). Kundenkonten sind an einen Kunden
+gebunden, und die Einschränkung sitzt in den Abfragen – nicht in der Anzeige. Einkaufspreise und Marge
+werden für sie schon beim Abfragen entfernt, stehen also nicht im ausgelieferten HTML.
+
+**Weiterhin nicht vorhanden:** Mandantenfähigkeit im eigentlichen Sinn. Mehrere Systemhäuser in einer
+Installation wären ein Umbau, kein Anbau.
+
+## A02 – Kryptografische Fehler
+
+- Passwörter: argon2id (`@node-rs/argon2`), keine eigene Krypto.
+- Sitzungen: signiertes JWT (HS256) aus `APP_SECRET`, 12 Stunden gültig, Cookie `httpOnly`, `sameSite=lax`
+  und `secure`, sobald `APP_URL` auf `https://` steht.
+- Zugangsdaten für SMTP und Webhooks liegen AES-256-GCM-verschlüsselt in der Datenbank
+  (`src/lib/geheimnisse.ts`); der Schlüssel wird aus `APP_SECRET` abgeleitet.
+- Agent- und Enrollment-Tokens werden nur als SHA-256-Hash gespeichert. Das ist hier richtig und nicht
+  zu schwach: Die Tokens sind 32 Byte Zufall, es gibt nichts zu raten.
+
+**Wichtig:** `APP_SECRET` ist der Generalschlüssel. Geht er verloren, sind alle Sitzungen ungültig und die
+gespeicherten Zugangsdaten unlesbar. Er gehört in die Sicherung.
+
+## A03 – Injektion
+
+- Datenbankzugriffe ausschließlich über Prisma mit gebundenen Werten; kein `$queryRawUnsafe` im Projekt.
+- Ausgaben maskiert React selbst.
+- Zusätzlich greift eine Content-Security-Policy mit frischem Nonce je Anfrage und `strict-dynamic`
+  (`src/proxy.ts`). Eingeschleustes `<script>` – etwa über einen manipulierten Hostnamen aus einer
+  Proxmox-Ausgabe – läuft damit nicht.
+- Der Agent baut sein JSON mit einer eigenen Maskierung; Sonderzeichen aus Proxmox-Ausgaben sind als
+  Testfall hinterlegt.
+
+## A04 – Unsicheres Design
+
+- Push-Modell: Das Dashboard braucht **keinen** Zugang zu den Proxmox-Hosts. Es gibt keine gespeicherten
+  root-Zugänge, die abhandenkommen könnten – die Hosts melden von sich aus.
+- Der Agent sendet nur Statusangaben (Subscription, Version, Sockel, IPs). Keine Gastliste, keine Daten.
+- Enrollment-Tokens sind befristet und in der Zahl der Nutzungen begrenzt.
+
+## A05 – Sicherheitsrelevante Fehlkonfiguration
+
+- Kopfzeilen: `X-Content-Type-Options`, `X-Frame-Options: DENY`, `Referrer-Policy`, `Permissions-Policy`,
+  `Strict-Transport-Security` (`next.config.ts`) sowie die CSP aus dem Proxy.
+- Die Anwendung startet nicht mit zu kurzem `APP_SECRET`.
+- Im Container läuft die Anwendung als unprivilegierter Benutzer; Anhänge werden mit Rechten 640 abgelegt.
+- Fehlermeldungen nennen keine Einzelheiten: Bei der Anmeldung steht dieselbe Meldung für „Adresse
+  unbekannt“ und „Passwort falsch“.
+
+## A06 – Verwundbare Komponenten
+
+- `npm audit --omit=dev` meldet **keine** bekannten Schwachstellen (Stand 18.09.2026).
+- Zwei Fassungen werden über `overrides` angehoben: `mysql2` und `deepmerge-ts` kommen als Beiwerk von
+  Prisma mit, obwohl wir Postgres nutzen. Ohne die Anhebung bliebe nur ein Rückschritt auf Prisma 6.
+- Die CI prüft bei jedem Push (#019).
+
+## A07 – Fehler bei Identifizierung und Authentifizierung
+
+- Ratenbremse: fünf Anmeldeversuche je Kennung und Viertelstunde.
+- Anmeldung wahlweise per Passwort oder OIDC (authentik, mit PKCE und `state`).
+- Jede Anmeldung – erfolgreich oder nicht – landet im Audit-Log.
+
+- **Passkeys** (WebAuthn, #028) als dritter, gleichwertiger Weg. Passwortlos, an die Domäne gebunden,
+  mehrere je Konto. Setzt HTTPS voraus (außer auf `localhost`).
+- Automatisch angelegte OIDC-Konten bekommen die eingestellte Rolle – Vorgabe *Techniker*, nicht
+  Administrator.
+
+**Nicht vorhanden:** klassische Zwei-Faktor-Anmeldung mit Einmalkennwort. Ein Passkey ersetzt beides
+in einem Schritt; wer einen zweiten Faktor zum Passwort erzwingen will, stellt OIDC davor.
+
+## A08 – Datenintegrität
+
+- Der Agent prüft vor dem Selbstaktualisieren, ob die geladene Datei wie ein Bash-Skript beginnt.
+- Webhooks werden mit HMAC-SHA256 signiert, damit die Gegenstelle die Herkunft prüfen kann.
+- Hochgeladene Rechnungen werden nicht dem gemeldeten Typ nach beurteilt, sondern am Dateianfang
+  geprüft (`%PDF-`), auf 10 MB begrenzt und unter ihrer Prüfsumme abgelegt.
+
+## A09 – Protokollierung
+
+- Audit-Log für Anmeldungen, Änderungen an Kunden, Rechnungen, Tokens, Kanälen und Warnregeln –
+  einsehbar unter *Einstellungen → Protokoll*.
+- Der Agent protokolliert auf dem Host über `logger` ins Journal.
+
+## A10 – Server-Side Request Forgery
+
+- Die einzige ausgehende Verbindung, die sich einstellen lässt, ist der Benachrichtigungs-Webhook. Er
+  wird bewusst von einem Angemeldeten eingetragen und ist damit kein fremdgesteuerter Aufruf.
+- Sonst ruft das Dashboard keine Adressen auf, die aus Daten stammen.
+
+## Was ein Betreiber selbst tun muss
+
+1. HTTPS davorschalten (Beispiele unter `deploy/reverse-proxy/`) und `APP_URL` auf `https://` setzen.
+2. `APP_SECRET` und die Datenbank sichern (`deploy/backup.sh`).
+3. Das Dashboard nicht ins offene Internet stellen, wenn es nicht sein muss. Die Agent-API muss
+   erreichbar sein, die Oberfläche nicht.
+4. Enrollment-Tokens nach dem Ausrollen widerrufen.

package-lock.json

@@ -1,18 +1,20 @@
 {
   "name": "proxledger",
-  "version": "0.12.0",
+  "version": "0.17.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "proxledger",
-      "version": "0.12.0",
+      "version": "0.17.0",
       "hasInstallScript": true,
       "dependencies": {
         "@node-rs/argon2": "^2.2.1",
         "@prisma/adapter-pg": "^7.10.0",
         "@prisma/client": "^7.10.0",
         "@react-pdf/renderer": "^4.9.0",
+        "@simplewebauthn/browser": "^14.0.0",
+        "@simplewebauthn/server": "^14.0.2",
         "admin-lte": "^4.9.1",
         "bootstrap": "^5.3.8",
         "bootstrap-icons": "^1.13.1",
@@ -944,6 +946,12 @@
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
       }
     },
+    "node_modules/@hexagon/base64": {
+      "version": "1.1.28",
+      "resolved": "https://registry.npmjs.org/@hexagon/base64/-/base64-1.1.28.tgz",
+      "integrity": "sha512-lhqDEAvWixy3bZ+UOYbPwUbBkwBq5C1LAJ/xPC8Oi+lL54oyakv/npbA0aU2hgCsx/1NUd4IBvV03+aUBWxerw==",
+      "license": "MIT"
+    },
     "node_modules/@humanfs/core": {
       "version": "0.19.2",
       "resolved": "https://registry.npmjs.org/@humanfs/core/-/core-0.19.2.tgz",
@@ -1609,6 +1617,12 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@levischuck/tiny-cbor": {
+      "version": "0.2.11",
+      "resolved": "https://registry.npmjs.org/@levischuck/tiny-cbor/-/tiny-cbor-0.2.11.tgz",
+      "integrity": "sha512-llBRm4dT4Z89aRsm6u2oEZ8tfwL/2l6BwpZ7JcyieouniDECM5AqNgr/y08zalEIvW3RSK4upYyybDcmjXqAow==",
+      "license": "MIT"
+    },
     "node_modules/@napi-rs/wasm-runtime": {
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.2.4.tgz",
@@ -2147,6 +2161,239 @@
         "url": "https://github.com/sponsors/oxc-project"
       }
     },
+    "node_modules/@peculiar/asn1-android": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-android/-/asn1-android-2.9.4.tgz",
+      "integrity": "sha512-SYHm4SoWSI0nRCoos6jpGusIqhPH9bbGBqv7ohlZ+H6BunrDzzQPk2ePgDuEUzV82OdvbLgtW4twUDwhU9P3YQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-asym-key": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-asym-key/-/asn1-asym-key-2.9.4.tgz",
+      "integrity": "sha512-s7SJfjcXlR3MYMngDTeMLCy3VjGaIxeEy905CQ0j09pDbeYhNBvBGA7r7cAvCZYkVFo9kVg9RAki0K2iUz7SGQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-pkcs8": "^2.9.4",
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-cms": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-cms/-/asn1-cms-2.9.4.tgz",
+      "integrity": "sha512-cben7oxmQsUGZqotus7yt0srYdncOT6RNWcTQ77T2RFOXejYVYkXadrfePdRcrVpO9K95IRLKKglG2k38jKXuw==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "@peculiar/asn1-x509-attr": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-csr": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-csr/-/asn1-csr-2.9.4.tgz",
+      "integrity": "sha512-xd4YN4vpRjkDAQWVfZZkeu12IEND7DOpkqaHSIHxZl1uggUNa9Ju0QxY2jHvDAS9pP0zhRBytg8ifsnGo3V0jw==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-ecc": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-ecc/-/asn1-ecc-2.9.4.tgz",
+      "integrity": "sha512-JJXefFshRAuVAjWQo/39bkg1ywc1VaiO44S8RRC+Ykvf/u2KDmYffoDb0ZBPCR5uJy4AGKQhl8mX+Q8ShcWaXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-pfx": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pfx/-/asn1-pfx-2.9.4.tgz",
+      "integrity": "sha512-khuGzHTzNzk4GDlIBEILyIs6Lce0yn0ZBdoI9v93kmNncfZRhD+AQ5ODFqdhvoE8cMJF/JMTQ8yA+t1D14kqCw==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.9.4",
+        "@peculiar/asn1-pkcs8": "^2.9.4",
+        "@peculiar/asn1-rsa": "^2.9.4",
+        "@peculiar/asn1-schema": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs8": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs8/-/asn1-pkcs8-2.9.4.tgz",
+      "integrity": "sha512-duRdotlUx9eDZe6QrQpQKl61RbWykCHBCkKayP8V8XdEFwlKHZ8qGGDMyS6Pye7OX7nLFttTTpRkJeet78ckwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-pkcs9": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-pkcs9/-/asn1-pkcs9-2.9.4.tgz",
+      "integrity": "sha512-kaL4cNxBpdQE2dKlyZBqz4ygCrwffO+8wfoxTEqM1Z8RadvCeELBRzcv0dzM8aY9azHMwODO5nxU65zXmhToOQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.9.4",
+        "@peculiar/asn1-pfx": "^2.9.4",
+        "@peculiar/asn1-pkcs8": "^2.9.4",
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "@peculiar/asn1-x509-attr": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-rsa": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-rsa/-/asn1-rsa-2.9.4.tgz",
+      "integrity": "sha512-pZ96eD1PptovcWQ/GSmuNFXd/7EQJNlKfDaNCyE2rx3W0v6QFelkzquVqRSRyyDXXCYD69ZXJDzZ8GhIiQzKoA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-schema": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-schema/-/asn1-schema-2.9.4.tgz",
+      "integrity": "sha512-GjzePcT9Iw8NzeOPf73iNS9xM+TBhd/FilAfP+RQGkTMQJTVWtytN3JHJACCjf/ABNau5S7mS3g+DcuxmRgYEg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509/-/asn1-x509-2.9.4.tgz",
+      "integrity": "sha512-CxhBo/RdEbMMob7T31ZdQjGuoyRFLVwrDzTn25bihzBasRg9kRm/0IxIPvhgQtcK/9dNcO1XQL2fuPugwELL0Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/utils": "^2.0.2",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509-attr": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-attr/-/asn1-x509-attr-2.9.4.tgz",
+      "integrity": "sha512-ehQXbpQaQYycgu8OrvigwSPTFfVRcu0ECNYCWw+yzBp02Lw5paRqzzhUpfOgO2K38+WfFZuEz/0RPtam5g0OMg==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/asn1-x509-post-quantum": {
+      "version": "2.9.4",
+      "resolved": "https://registry.npmjs.org/@peculiar/asn1-x509-post-quantum/-/asn1-x509-post-quantum-2.9.4.tgz",
+      "integrity": "sha512-GD0k7BY3dsEIeai7C7bVRPddj/PzZu+sTawRPRxdHKbdy1f9b58WQyk0eFJdr28GShyLVTU8poyi4+bTAZfEtQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-asym-key": "^2.9.4",
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "asn1js": "^3.0.10",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@peculiar/utils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/@peculiar/utils/-/utils-2.0.3.tgz",
+      "integrity": "sha512-+oL3HPFRIZ1St2K50lWCXiioIgSoxzz7R1J3uF6neO2yl1sgmpgY6XXJH4BdpoDkMWznQTeYF6oWNDZLCdQ4eQ==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/@peculiar/x509": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@peculiar/x509/-/x509-2.1.0.tgz",
+      "integrity": "sha512-IYbg1R03CSQGWwl24kGyqrdVtixNSbRaDvBg1r5wyYjTP+VwPQkka1BzTgU5+vxiuwqg04OxdvdJ1xYYFIdUSA==",
+      "license": "MIT",
+      "dependencies": {
+        "@peculiar/asn1-cms": "^2.9.4",
+        "@peculiar/asn1-csr": "^2.9.4",
+        "@peculiar/asn1-ecc": "^2.9.4",
+        "@peculiar/asn1-pkcs9": "^2.9.4",
+        "@peculiar/asn1-rsa": "^2.9.4",
+        "@peculiar/asn1-schema": "^2.9.4",
+        "@peculiar/asn1-x509": "^2.9.4",
+        "@peculiar/asn1-x509-post-quantum": "^2.9.4",
+        "pvtsutils": "^1.3.6",
+        "tslib": "^2.8.1",
+        "tsyringe": "^4.10.0"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
     "node_modules/@popperjs/core": {
       "version": "2.11.8",
       "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.8.tgz",
@@ -3031,6 +3278,33 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@simplewebauthn/browser": {
+      "version": "14.0.0",
+      "resolved": "https://registry.npmjs.org/@simplewebauthn/browser/-/browser-14.0.0.tgz",
+      "integrity": "sha512-1odWVqeEBTl7lJ9zMKLEsmTlnyrDO5iRcTvfMKKk1WThUnp/i8JJdffdj2icP+tty159s4PgwE3BiMoEW9NFow==",
+      "license": "MIT"
+    },
+    "node_modules/@simplewebauthn/server": {
+      "version": "14.0.2",
+      "resolved": "https://registry.npmjs.org/@simplewebauthn/server/-/server-14.0.2.tgz",
+      "integrity": "sha512-g+m/xv9/8FRWsDY22CwsTYRzt3WwS9fJrR3P7eY3Ti01FXH5FQ36Xn55v6D+5tb6VajlqOj4hywP/Vxsb6a3Sg==",
+      "license": "MIT",
+      "dependencies": {
+        "@hexagon/base64": "^1.1.27",
+        "@levischuck/tiny-cbor": "^0.2.2",
+        "@peculiar/asn1-android": "^2.6.0",
+        "@peculiar/asn1-ecc": "^2.6.1",
+        "@peculiar/asn1-rsa": "^2.6.1",
+        "@peculiar/asn1-schema": "^2.6.0",
+        "@peculiar/asn1-x509": "^2.6.1",
+        "@peculiar/asn1-x509-post-quantum": "^2.9.4",
+        "@peculiar/x509": "^2.1.0",
+        "reflect-metadata": "^0.2.2"
+      },
+      "engines": {
+        "node": ">=20.0.0"
+      }
+    },
     "node_modules/@standard-schema/spec": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
@@ -4339,6 +4613,20 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/asn1js": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/asn1js/-/asn1js-3.0.10.tgz",
+      "integrity": "sha512-S2s3aOytiKdFRdulw2qPE51MzjzVOisppcVv7jVFR+Kw0kxwvFrDcYA0h7Ndqbmj0HkMIXYWaoj7fli8kgx1eg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "pvtsutils": "^1.3.6",
+        "pvutils": "^1.1.5",
+        "tslib": "^2.8.1"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/assertion-error": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
@@ -5071,13 +5359,23 @@
       "license": "MIT"
     },
     "node_modules/deepmerge-ts": {
-      "version": "7.1.5",
+      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/deepmerge-ts/-/deepmerge-ts-7.1.5.tgz",
+      "resolved": "https://registry.npmjs.org/deepmerge-ts/-/deepmerge-ts-8.0.2.tgz",
-      "integrity": "sha512-HOJkrhaYsweh+W+e74Yn7YStZOilkoPb6fycpwNLKzSPtruFs48nYis0zy5yJz1+ktUhHxoRDJ27RQAWLIJVJw==",
+      "integrity": "sha512-uqbvqLUMrc6p0MO+WBRtTxY55hmyh94WRwI5a++PZe54X+bfVh59FSN7uWCBCW1CCVjzjnrwzfI8zidE2obMMw==",
       "devOptional": true,
+      "funding": [
+        {
+          "type": "ko-fi",
+          "url": "https://ko-fi.com/rebeccastevens"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/deepmerge-ts"
+        }
+      ],
       "license": "BSD-3-Clause",
       "engines": {
-        "node": ">=16.0.0"
+        "node": ">=16.9.0"
       }
     },
     "node_modules/define-data-property": {
@@ -5133,16 +5431,6 @@
         "robust-predicates": "^3.0.2"
       }
     },
-    "node_modules/denque": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/denque/-/denque-2.1.0.tgz",
-      "integrity": "sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==",
-      "devOptional": true,
-      "license": "Apache-2.0",
-      "engines": {
-        "node": ">=0.10"
-      }
-    },
     "node_modules/destr": {
       "version": "2.0.5",
       "resolved": "https://registry.npmjs.org/destr/-/destr-2.0.5.tgz",
@@ -7820,24 +8108,25 @@
       "license": "MIT"
     },
     "node_modules/mysql2": {
-      "version": "3.15.3",
+      "version": "3.24.4",
-      "resolved": "https://registry.npmjs.org/mysql2/-/mysql2-3.15.3.tgz",
+      "resolved": "https://registry.npmjs.org/mysql2/-/mysql2-3.24.4.tgz",
-      "integrity": "sha512-FBrGau0IXmuqg4haEZRBfHNWB5mUARw6hNwPDXXGg0XzVJ50mr/9hb267lvpVMnhZ1FON3qNd4Xfcez1rbFwSg==",
+      "integrity": "sha512-A2olluVlj0mvgyIRRISMEzXc51m+21mRtcMVjJyIpt2GG98+XrC9m9HzsqcMsX2LcnfccJvY5NB22g8fENBnOA==",
       "devOptional": true,
       "license": "MIT",
       "dependencies": {
-        "aws-ssl-profiles": "^1.1.1",
+        "aws-ssl-profiles": "^1.1.2",
-        "denque": "^2.1.0",
         "generate-function": "^2.3.1",
-        "iconv-lite": "^0.7.0",
+        "iconv-lite": "^0.7.3",
-        "long": "^5.2.1",
+        "long": "^5.3.2",
-        "lru.min": "^1.0.0",
+        "lru.min": "^1.1.4",
-        "named-placeholders": "^1.1.3",
+        "named-placeholders": "^1.1.6",
-        "seq-queue": "^0.0.5",
+        "sql-escaper": "^1.5.1"
-        "sqlstring": "^2.3.2"
       },
       "engines": {
         "node": ">= 8.0"
+      },
+      "peerDependencies": {
+        "@types/node": ">= 8"
       }
     },
     "node_modules/named-placeholders": {
@@ -8666,6 +8955,24 @@
       ],
       "license": "MIT"
     },
+    "node_modules/pvtsutils": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/pvtsutils/-/pvtsutils-1.3.6.tgz",
+      "integrity": "sha512-PLgQXQ6H2FWCaeRak8vvk1GW462lMxB5s3Jm673N82zI4vqtVUPuZdffdZbPDFRoU8kAhItWFtPCWiPpp4/EDg==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^2.8.1"
+      }
+    },
+    "node_modules/pvutils": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/pvutils/-/pvutils-1.2.0.tgz",
+      "integrity": "sha512-BbubeCEyTuQjVMakvJQ/Sxbc93F2pwmbsxONT/ZRrwU7Ua38d8unYTwXpTVLAKJ4BDuH9IGztCjQcd/N/39Dvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      }
+    },
     "node_modules/queue": {
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/queue/-/queue-6.0.2.tgz",
@@ -8748,6 +9055,12 @@
         "url": "https://paulmillr.com/funding/"
       }
     },
+    "node_modules/reflect-metadata": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/reflect-metadata/-/reflect-metadata-0.2.2.tgz",
+      "integrity": "sha512-urBwgfrvVP/eAyXx4hluJivBKzuEbSQs9rKWCrCkbSxNv8mxPcUZKeuoF3Uy4mJl3Lwprp6yy5/39VWigZ4K6Q==",
+      "license": "Apache-2.0"
+    },
     "node_modules/reflect.getprototypeof": {
       "version": "1.0.10",
       "resolved": "https://registry.npmjs.org/reflect.getprototypeof/-/reflect.getprototypeof-1.0.10.tgz",
@@ -9059,12 +9372,6 @@
         "semver": "bin/semver.js"
       }
     },
-    "node_modules/seq-queue": {
-      "version": "0.0.5",
-      "resolved": "https://registry.npmjs.org/seq-queue/-/seq-queue-0.0.5.tgz",
-      "integrity": "sha512-hr3Wtp/GZIc/6DAGPDcV4/9WoZhjrkXsi5B/07QgX8tsdc6ilr7BFM6PM6rbdAX1kFSDYeZGLipIZZKyQP0O5Q==",
-      "devOptional": true
-    },
     "node_modules/set-function-length": {
       "version": "1.2.2",
       "resolved": "https://registry.npmjs.org/set-function-length/-/set-function-length-1.2.2.tgz",
@@ -9314,14 +9621,20 @@
         "node": ">= 10.x"
       }
     },
-    "node_modules/sqlstring": {
+    "node_modules/sql-escaper": {
-      "version": "2.3.3",
+      "version": "1.5.2",
-      "resolved": "https://registry.npmjs.org/sqlstring/-/sqlstring-2.3.3.tgz",
+      "resolved": "https://registry.npmjs.org/sql-escaper/-/sql-escaper-1.5.2.tgz",
-      "integrity": "sha512-qC9iz2FlN7DQl3+wjwn3802RTyjCx7sDvfQEXchwa6CWOx07/WVfh91gBmQ9fahw8snwGEWU3xGzOt4tFyHLxg==",
+      "integrity": "sha512-6CKD38c31SENivxOADeMNLdukOnUxUcflKtzVWzace7Riv1v7cAEym5Cx9Q7gYZ3ezIJI7ZpqecQq8cqNeSSFg==",
       "devOptional": true,
       "license": "MIT",
       "engines": {
-        "node": ">= 0.6"
+        "bun": ">=1.0.0",
+        "deno": ">=2.0.0",
+        "node": ">=12.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/mysqljs/sql-escaper?sponsor=1"
       }
     },
     "node_modules/stable-hash": {
@@ -9702,6 +10015,24 @@
         "fsevents": "~2.3.3"
       }
     },
+    "node_modules/tsyringe": {
+      "version": "4.10.0",
+      "resolved": "https://registry.npmjs.org/tsyringe/-/tsyringe-4.10.0.tgz",
+      "integrity": "sha512-axr3IdNuVIxnaK5XGEUFTu3YmAQ6lllgrvqfEoR16g/HGnYY/6We4oWENtAnzK6/LpJ2ur9PAb80RBt7/U4ugw==",
+      "license": "MIT",
+      "dependencies": {
+        "tslib": "^1.9.3"
+      },
+      "engines": {
+        "node": ">= 6.0.0"
+      }
+    },
+    "node_modules/tsyringe/node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
     "node_modules/type-check": {
       "version": "0.4.0",
       "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "proxledger",
-  "version": "0.12.1",
+  "version": "0.18.0",
   "private": true,
   "scripts": {
     "dev": "next dev",
@@ -25,13 +25,17 @@
     "build:all": "npm run build && npm run build:worker",
     "lasttest": "tsx scripts/lasttest.ts",
     "screenshots": "node scripts/screenshots.mjs",
-    "icons": "node scripts/icons.mjs"
+    "icons": "node scripts/icons.mjs",
+    "pruefe:doku": "node scripts/pruefe-doku.mjs",
+    "benutzer": "tsx scripts/benutzer.ts"
   },
   "dependencies": {
     "@node-rs/argon2": "^2.2.1",
     "@prisma/adapter-pg": "^7.10.0",
     "@prisma/client": "^7.10.0",
     "@react-pdf/renderer": "^4.9.0",
+    "@simplewebauthn/browser": "^14.0.0",
+    "@simplewebauthn/server": "^14.0.2",
     "admin-lte": "^4.9.1",
     "bootstrap": "^5.3.8",
     "bootstrap-icons": "^1.13.1",
@@ -64,5 +68,9 @@
   "description": "Proxmox Subscription Dashboard",
   "engines": {
     "node": ">=24"
+  },
+  "overrides": {
+    "mysql2": "^3.24.4",
+    "deepmerge-ts": "^8.0.0"
   }
 }

prisma/migrations/20260918154920_cluster_mitglieder/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Host" ADD COLUMN     "clusterMitglieder" TEXT[] DEFAULT ARRAY[]::TEXT[];

prisma/migrations/20260918213443_sitzungen_widerrufbar/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "Benutzer" ADD COLUMN     "sitzungenUngueltigAb" TIMESTAMP(3);

prisma/migrations/20260918222635_rollen_und_passkeys/migration.sql

@@ -0,0 +1,36 @@
+-- CreateEnum
+CREATE TYPE "Rolle" AS ENUM ('ADMIN', 'TECHNIKER', 'KUNDE');
+
+-- AlterTable
+ALTER TABLE "Benutzer" ADD COLUMN     "kundeId" TEXT,
+ADD COLUMN     "rolle" "Rolle" NOT NULL DEFAULT 'ADMIN';
+
+-- CreateTable
+CREATE TABLE "Passkey" (
+    "id" TEXT NOT NULL,
+    "benutzerId" TEXT NOT NULL,
+    "credentialId" TEXT NOT NULL,
+    "publicKey" BYTEA NOT NULL,
+    "zaehler" BIGINT NOT NULL DEFAULT 0,
+    "transports" TEXT[] DEFAULT ARRAY[]::TEXT[],
+    "bezeichnung" TEXT NOT NULL,
+    "erstelltAm" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "zuletztAm" TIMESTAMP(3),
+
+    CONSTRAINT "Passkey_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "Passkey_credentialId_key" ON "Passkey"("credentialId");
+
+-- CreateIndex
+CREATE INDEX "Passkey_benutzerId_idx" ON "Passkey"("benutzerId");
+
+-- CreateIndex
+CREATE INDEX "Benutzer_kundeId_idx" ON "Benutzer"("kundeId");
+
+-- AddForeignKey
+ALTER TABLE "Benutzer" ADD CONSTRAINT "Benutzer_kundeId_fkey" FOREIGN KEY ("kundeId") REFERENCES "Kunde"("id") ON DELETE SET NULL ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "Passkey" ADD CONSTRAINT "Passkey_benutzerId_fkey" FOREIGN KEY ("benutzerId") REFERENCES "Benutzer"("id") ON DELETE CASCADE ON UPDATE CASCADE;

prisma/schema.prisma

@@ -72,6 +72,7 @@ model Kunde {
   alerts           Alert[]
 
   @@index([name])
+  benutzer  Benutzer[]
 }
 
 model Standort {
@@ -113,6 +114,8 @@ model Host {
   serverId    String?
   clusterName String?
   nodeName    String?
+  /// Namen aller Knoten des Clusters laut corosync – auch solche ohne eigenen Agent (#022).
+  clusterMitglieder String[] @default([])
   ips         String[] @default([])
   sockets     Int?
   cpuModell   String?
@@ -446,18 +449,53 @@ model Benachrichtigungskanal {
 // ---------------------------------------------------------------- Benutzer und Protokoll
 
 /// Alle Benutzer sind Administratoren; eine Nur-Lese-Rolle ist bewusst nicht vorgesehen.
+/// Was jemand darf. ADMIN alles, TECHNIKER alles Fachliche, KUNDE nur die eigenen Daten (#027).
+enum Rolle {
+  ADMIN
+  TECHNIKER
+  KUNDE
+}
+
 model Benutzer {
   id            String    @id @default(cuid())
   email         String    @unique
   name          String
   passwortHash  String?
   oidcSubject   String?   @unique
+  /// Bestehende Konten waren vor der Einführung der Rollen uneingeschränkt – daher ADMIN.
+  rolle         Rolle     @default(ADMIN)
+  /// Nur für die Rolle KUNDE: an welchen Kunden das Konto gebunden ist.
+  kundeId       String?
   aktiv         Boolean   @default(true)
   letzterLoginAm DateTime?
+  /// Alle Sitzungen, die vor diesem Zeitpunkt ausgestellt wurden, gelten als ungültig (#024).
+  sitzungenUngueltigAb DateTime?
   erstelltAm    DateTime  @default(now())
   geaendertAm   DateTime  @updatedAt
 
   auditEintraege AuditEintrag[]
+  kunde          Kunde?        @relation(fields: [kundeId], references: [id], onDelete: SetNull)
+  passkeys       Passkey[]
+
+  @@index([kundeId])
+}
+
+/// Ein registrierter Passkey (WebAuthn). Ein Konto darf mehrere haben – Rechner und Telefon (#028).
+model Passkey {
+  id           String    @id @default(cuid())
+  benutzerId   String
+  /// Kennung des Schlüssels, base64url wie vom Browser geliefert.
+  credentialId String    @unique
+  publicKey    Bytes
+  zaehler      BigInt    @default(0)
+  transports   String[]  @default([])
+  bezeichnung  String
+  erstelltAm   DateTime  @default(now())
+  zuletztAm    DateTime?
+
+  benutzer Benutzer @relation(fields: [benutzerId], references: [id], onDelete: Cascade)
+
+  @@index([benutzerId])
 }
 
 model AuditEintrag {

scripts/benutzer.ts

@@ -0,0 +1,81 @@
+import "dotenv/config";
+import { createInterface } from "node:readline/promises";
+import { hash } from "@node-rs/argon2";
+import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "@/generated/prisma/client";
+
+/**
+ * Benutzerverwaltung von der Kommandozeile – solange es dafür keine Oberfläche gibt.
+ *
+ *   npm run benutzer -- liste
+ *   npm run benutzer -- sperren <email>      Konto sperren und alle Sitzungen sofort beenden
+ *   npm run benutzer -- entsperren <email>
+ *   npm run benutzer -- passwort <email>     neues Passwort setzen, beendet alle Sitzungen
+ */
+
+const prisma = new PrismaClient({
+  adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL }),
+});
+
+async function passwortAbfragen(): Promise<string> {
+  const eingabe = createInterface({ input: process.stdin, output: process.stdout });
+  const passwort = await eingabe.question("Neues Passwort (mindestens 12 Zeichen): ");
+  eingabe.close();
+  if (passwort.length < 12) throw new Error("Zu kurz – mindestens 12 Zeichen.");
+  return passwort;
+}
+
+async function main() {
+  const [befehl, email] = process.argv.slice(2);
+
+  if (befehl === "liste") {
+    const alle = await prisma.benutzer.findMany({ orderBy: { email: "asc" } });
+    for (const b of alle) {
+      console.log(`${b.aktiv ? "aktiv  " : "gesperrt"}  ${b.email.padEnd(32)} ${b.name}`);
+    }
+    return;
+  }
+
+  if (!email) throw new Error("Bitte eine E-Mail-Adresse angeben.");
+  const benutzer = await prisma.benutzer.findUnique({ where: { email: email.toLowerCase().trim() } });
+  if (!benutzer) throw new Error(`Kein Benutzer mit der Adresse ${email}.`);
+
+  switch (befehl) {
+    case "sperren":
+      // Sperren allein genügt nicht: Das Sitzungs-Token gilt sonst bis zum Ablauf weiter.
+      await prisma.benutzer.update({
+        where: { id: benutzer.id },
+        data: { aktiv: false, sitzungenUngueltigAb: new Date() },
+      });
+      console.log(`${benutzer.email} ist gesperrt, alle Sitzungen sind beendet.`);
+      break;
+
+    case "entsperren":
+      await prisma.benutzer.update({ where: { id: benutzer.id }, data: { aktiv: true } });
+      console.log(`${benutzer.email} ist wieder freigegeben.`);
+      break;
+
+    case "passwort": {
+      const passwort = await passwortAbfragen();
+      await prisma.benutzer.update({
+        where: { id: benutzer.id },
+        data: {
+          passwortHash: await hash(passwort),
+          sitzungenUngueltigAb: new Date(),
+        },
+      });
+      console.log(`Passwort gesetzt; bestehende Sitzungen von ${benutzer.email} sind beendet.`);
+      break;
+    }
+
+    default:
+      throw new Error("Bekannte Befehle: liste, sperren, entsperren, passwort");
+  }
+}
+
+main()
+  .catch((fehler: unknown) => {
+    console.error(fehler instanceof Error ? fehler.message : fehler);
+    process.exitCode = 1;
+  })
+  .finally(() => prisma.$disconnect());

scripts/feldtest-erheben.sh

@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# Sammelt auf einem Proxmox-Host alle Ausgaben, die der ProxLedger-Agent auswertet.
+# Es wird nichts installiert und nichts verändert – das Skript liest nur.
+#
+#   bash feldtest-erheben.sh              # Ausgabe anonymisiert (Empfehlung zum Weitergeben)
+#   bash feldtest-erheben.sh --vollstaendig   # ohne Anonymisierung, nur für den eigenen Gebrauch
+#
+# Ergebnis: eine Textdatei im aktuellen Verzeichnis, die weitergegeben werden kann.
+
+set -o nounset
+set -o pipefail
+
+ANONYM="ja"
+[ "${1:-}" = "--vollstaendig" ] && ANONYM="nein"
+
+AUSGABE="proxledger-feldtest-$(hostname -s 2>/dev/null || echo host)-$(date +%Y%m%d-%H%M%S).txt"
+
+# Ersetzt Subscription-Keys, Server-IDs, Hostnamen und IP-Adressen durch Platzhalter.
+anonymisieren() {
+  if [ "$ANONYM" = "nein" ]; then
+    cat
+    return
+  fi
+  sed -E \
+    -e 's/(pve[0-9]?[a-z]|pbs[a-z]|pmg[a-z])-[A-Za-z0-9]+/\1-KEY-ANONYMISIERT/g' \
+    -e 's/([Ss]erverid:[[:space:]]*)[A-Za-z0-9]+/\1SERVERID-ANONYMISIERT/g' \
+    -e 's/\b([0-9]{1,3}\.){3}[0-9]{1,3}\b/IP-ANONYMISIERT/g' \
+    -e "s/$(hostname -s 2>/dev/null || echo unbekannt)/HOSTNAME-ANONYMISIERT/g"
+}
+
+abschnitt() {
+  printf '\n===== %s =====\n' "$1"
+}
+
+# Führt einen Befehl aus und hält fest, ob es ihn überhaupt gibt.
+zeige() {
+  local befehl="$1"
+  abschnitt "$befehl"
+  if ! command -v "${befehl%% *}" >/dev/null 2>&1; then
+    printf '(Befehl nicht vorhanden)\n'
+    return
+  fi
+  eval "$befehl" 2>&1 | head -n 40
+  printf '[Rückgabewert: %s]\n' "$?"
+}
+
+{
+  printf 'ProxLedger – Erhebung für den Feldtest\n'
+  printf 'Erstellt am: %s\n' "$(date -Is)"
+  printf 'Anonymisiert: %s\n' "$ANONYM"
+
+  abschnitt "Betriebssystem"
+  cat /etc/os-release 2>/dev/null | head -n 5
+  printf 'Kernel: %s\n' "$(uname -r)"
+
+  abschnitt "Erkanntes Produkt"
+  for befehl in pvesubscription proxmox-backup-manager pmgsubscription; do
+    if command -v "$befehl" >/dev/null 2>&1; then
+      printf 'gefunden: %s\n' "$befehl"
+    fi
+  done
+
+  zeige "pvesubscription get"
+  zeige "proxmox-backup-manager subscription get"
+  zeige "pmgsubscription get"
+
+  # Einige Fassungen können JSON – das wäre die stabilere Quelle.
+  zeige "pvesubscription get --output-format json"
+  zeige "proxmox-backup-manager subscription get --output-format json"
+
+  zeige "pveversion"
+  zeige "proxmox-backup-manager version"
+  zeige "pmgversion"
+
+  zeige "lscpu | grep -E 'Socket|Model name|Sockel|Modellname'"
+  zeige "ip -o addr show scope global"
+  zeige "hostname -f"
+  zeige "pvecm status"
+  zeige "apt list --upgradable 2>/dev/null | grep -c 'upgradable from'"
+
+  abschnitt "Vorhandene Werkzeuge"
+  for befehl in curl systemctl logger jq awk sed; do
+    printf '%-12s %s\n' "$befehl" "$(command -v "$befehl" || echo 'FEHLT')"
+  done
+
+  abschnitt "Ende"
+} 2>&1 | anonymisieren > "$AUSGABE"
+
+printf 'Fertig: %s\n' "$AUSGABE"
+printf 'Anonymisiert: %s (mit --vollstaendig ohne Anonymisierung)\n' "$ANONYM"
+printf 'Bitte vor dem Weitergeben kurz durchsehen.\n'

scripts/pruefe-doku.mjs

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * Prüft, ob Dokumentation und Version zusammenpassen.
+ *
+ *   npm run pruefe:doku
+ *
+ * Geprüft wird:
+ *   1. Die Version aus package.json hat einen Abschnitt im Changelog.
+ *   2. Jede Issue-Datei steht in der Übersicht – und umgekehrt.
+ *   3. Status und tatsächliche Zeit stimmen zwischen Issue-Datei und Übersicht überein.
+ *   4. Alle im Handbuch verlinkten Bilder sind vorhanden.
+ */
+
+import { readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+
+const WURZEL = process.cwd();
+const fehler = [];
+
+function pruefe(bedingung, meldung) {
+  if (!bedingung) fehler.push(meldung);
+}
+
+async function versionImChangelog() {
+  const { version } = JSON.parse(await readFile(path.join(WURZEL, "package.json"), "utf8"));
+  const changelog = await readFile(path.join(WURZEL, "CHANGELOG.md"), "utf8");
+
+  pruefe(
+    changelog.includes(`## [${version}]`),
+    `Version ${version} aus package.json fehlt im CHANGELOG.md.`,
+  );
+}
+
+async function issuesUndUebersicht() {
+  const verzeichnis = path.join(WURZEL, "docs", "issues");
+  const dateien = (await readdir(verzeichnis)).filter((name) => /^\d{3}-.*\.md$/.test(name)).sort();
+  const uebersicht = await readFile(path.join(verzeichnis, "README.md"), "utf8");
+
+  for (const datei of dateien) {
+    pruefe(uebersicht.includes(`(${datei})`), `Issue ${datei} fehlt in docs/issues/README.md.`);
+
+    const inhalt = await readFile(path.join(verzeichnis, datei), "utf8");
+    const status = /^\*\*Status:\*\*\s*(.+)$/m.exec(inhalt)?.[1]?.trim();
+    const zeit = /^\*\*Geschätzt:\*\*.*\*\*Tatsächlich:\*\*\s*(.+)$/m.exec(inhalt)?.[1]?.trim();
+
+    const zeile = uebersicht.split("\n").find((z) => z.includes(`(${datei})`));
+    if (!zeile) continue;
+
+    pruefe(
+      zeile.includes(`| ${status} |`),
+      `Status von ${datei} ist „${status}“, die Übersicht sagt etwas anderes: ${zeile.trim()}`,
+    );
+    if (zeit && zeit !== "–") {
+      pruefe(
+        zeile.includes(zeit),
+        `Zeit von ${datei} ist „${zeit}“, steht so aber nicht in der Übersicht.`,
+      );
+    }
+  }
+
+  // Umgekehrt: Zeilen in der Übersicht ohne zugehörige Datei.
+  for (const treffer of uebersicht.matchAll(/\((\d{3}-[^)]+\.md)\)/g)) {
+    pruefe(dateien.includes(treffer[1]), `Übersicht verweist auf ${treffer[1]}, die Datei fehlt.`);
+  }
+}
+
+async function bilderImHandbuch() {
+  const handbuch = path.join(WURZEL, "docs", "anleitung");
+  const text = await readFile(path.join(handbuch, "README.md"), "utf8");
+  const bilder = [...text.matchAll(/!\[[^\]]*\]\((bilder\/[^)]+)\)/g)].map((t) => t[1]);
+  const vorhanden = new Set(await readdir(path.join(handbuch, "bilder")));
+
+  for (const bild of bilder) {
+    pruefe(vorhanden.has(path.basename(bild)), `Handbuch verweist auf ${bild}, die Datei fehlt.`);
+  }
+}
+
+await versionImChangelog();
+await issuesUndUebersicht();
+await bilderImHandbuch();
+
+if (fehler.length > 0) {
+  console.error("Die Dokumentation passt nicht zusammen:\n");
+  for (const meldung of fehler) console.error(`  · ${meldung}`);
+  process.exit(1);
+}
+
+console.log("Dokumentation, Versionen und Bilder passen zusammen.");

scripts/screenshots.mjs

@@ -2,26 +2,37 @@
 /**
  * Erzeugt die Bilder für das Handbuch (docs/anleitung/bilder/).
  *
- *   npm run screenshots            # heller Modus, Desktop
+ *   npm run screenshots                       # heller Modus, Desktop
- *   npm run screenshots -- --alle  # zusätzlich dunkler Modus und Mobilansicht
+ *   npm run screenshots -- --alle             # zusätzlich dunkler Modus und Mobilansicht
+ *   npm run screenshots -- --seite name=/pfad # zusätzlich eine bestimmte Seite
  *
  * Voraussetzung: Das Dashboard läuft (npm start) und die Datenbank enthält Daten.
  * Die Anmeldung erledigt das Skript selbst, indem es ein Sitzungs-Cookie erzeugt
  * und in ein eigenes Firefox-Profil schreibt – so bleibt der Schutz der Anwendung unangetastet.
  */
 
-import { execFileSync } from "node:child_process";
+import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import path from "node:path";
-import { DatabaseSync } from "node:sqlite";
+import { request as httpAnfrage } from "node:http";
 import { SignJWT } from "jose";
+import pg from "pg";
 import "dotenv/config";
 
 const BASIS = process.env.SCREENSHOT_URL ?? "http://localhost:3000";
 const ZIEL = path.join(process.cwd(), "docs", "anleitung", "bilder");
 const ALLE = process.argv.includes("--alle");
 
+/** Zusätzliche Seiten von der Befehlszeile: --seite name=/pfad */
+const ZUSATZ = process.argv
+  .filter((wert, i) => process.argv[i - 1] === "--seite")
+  .map((eintrag) => {
+    const [name, ...rest] = eintrag.split("=");
+    return { name, pfad: rest.join("="), titel: "zusätzlich" };
+  });
+
 // Firefox aus dem Snap-Paket kommt nicht an versteckte Verzeichnisse – daher im Home sichtbar ablegen.
 const PROFIL_BASIS = path.join(homedir(), "proxledger-screenshots");
 
@@ -38,6 +49,9 @@ const SEITEN = [
   { name: "tokens", pfad: "/einstellungen/tokens", titel: "Agent-Tokens" },
   { name: "benachrichtigungen", pfad: "/einstellungen/benachrichtigungen", titel: "Benachrichtigungen" },
   { name: "audit", pfad: "/einstellungen/audit", titel: "Protokoll" },
+  { name: "system", pfad: "/einstellungen/system", titel: "Systemeinstellungen" },
+  { name: "benutzer", pfad: "/einstellungen/benutzer", titel: "Benutzerverwaltung" },
+  { name: "passkeys", pfad: "/einstellungen/passkeys", titel: "Passkeys" },
 ];
 
 async function sitzungsToken() {
@@ -46,22 +60,69 @@ async function sitzungsToken() {
     throw new Error("APP_SECRET fehlt oder ist zu kurz – ohne Sitzung keine Bilder.");
   }
 
+  // Seit #027 schlägt die Sitzungsprüfung den Benutzer in der Datenbank nach: Ein erfundenes
+  // Konto landet wieder auf der Anmeldeseite. Deshalb hier ein echtes Administratorkonto nehmen.
+  // Kein Prisma-Client hier: Das Skript läuft als reines JavaScript, der erzeugte Client ist TypeScript.
+  const datenbank = new pg.Client({ connectionString: process.env.DATABASE_URL });
+  await datenbank.connect();
+  const { rows } = await datenbank.query(
+    `SELECT id, email, name FROM "Benutzer" WHERE rolle = 'ADMIN' AND aktiv = true ORDER BY "erstelltAm" LIMIT 1`,
+  );
+  await datenbank.end();
+  const benutzer = rows[0];
+
+  if (!benutzer) {
+    throw new Error("Kein aktiver Administrator in der Datenbank – erst `npm run db:seed` ausführen.");
+  }
+
   return new SignJWT({
-    benutzerId: "screenshots",
+    benutzerId: benutzer.id,
-    email: process.env.ADMIN_EMAIL ?? "admin@example.de",
+    email: benutzer.email,
-    name: process.env.ADMIN_NAME ?? "Florian",
+    name: benutzer.name,
     herkunft: "passwort",
   })
     .setProtectedHeader({ alg: "HS256" })
-    .setSubject("screenshots")
+    .setSubject(benutzer.id)
     .setIssuedAt()
     .setIssuer("proxledger")
     .setExpirationTime("1h")
     .sign(new TextEncoder().encode(geheimnis));
 }
 
-/** Legt ein frisches Profil mit Sitzungs-Cookie und gewünschtem Farbschema an. */
+/**
-function profilVorbereiten(name, token, dunkel) {
+ * Kleiner Vermittler vor dem Dashboard: Er reicht jede Anfrage weiter und hängt die Sitzung
+ * als Kopfzeile an. Damit braucht der Browser kein Cookie – das Einschleusen in das Firefox-Profil
+ * erwies sich als unzuverlässig (Firefox verwirft fremd erzeugte Cookie-Dateien stillschweigend,
+ * die Aufnahmen zeigten dann kommentarlos die Anmeldeseite).
+ */
+function vermittlerStarten(token) {
+  const ziel = new URL(BASIS);
+
+  const server = createServer((anfrage, antwort) => {
+    const weiterleitung = {
+      hostname: ziel.hostname,
+      port: ziel.port || 80,
+      path: anfrage.url,
+      method: anfrage.method,
+      headers: { ...anfrage.headers, host: ziel.host, cookie: `pl_sitzung=${token}` },
+    };
+
+    const verbindung = httpAnfrage(weiterleitung, (antwortVomServer) => {
+      antwort.writeHead(antwortVomServer.statusCode ?? 502, antwortVomServer.headers);
+      antwortVomServer.pipe(antwort);
+    });
+
+    verbindung.on("error", () => antwort.writeHead(502).end("Dashboard nicht erreichbar"));
+    anfrage.pipe(verbindung);
+  });
+
+  return new Promise((fertig) => {
+    server.listen(0, "127.0.0.1", () => fertig({ server, port: server.address().port }));
+  });
+}
+
+/** Legt ein Profil mit dem gewünschten Farbschema an. */
+function profilVorbereiten(name, dunkel) {
   const verzeichnis = path.join(PROFIL_BASIS, name);
   rmSync(verzeichnis, { recursive: true, force: true });
   mkdirSync(verzeichnis, { recursive: true });
@@ -76,55 +137,33 @@ function profilVorbereiten(name, token, dunkel) {
     ].join("\n"),
   );
 
-  const { hostname, protocol } = new URL(BASIS);
-  const datenbank = new DatabaseSync(path.join(verzeichnis, "cookies.sqlite"));
-  datenbank.exec(`
-    CREATE TABLE moz_cookies (
-      id INTEGER PRIMARY KEY, originAttributes TEXT NOT NULL DEFAULT '', name TEXT, value TEXT,
-      host TEXT, path TEXT, expiry INTEGER, lastAccessed INTEGER, creationTime INTEGER,
-      isSecure INTEGER, isHttpOnly INTEGER, inBrowserElement INTEGER DEFAULT 0,
-      sameSite INTEGER DEFAULT 0, schemeMap INTEGER DEFAULT 0,
-      isPartitionedAttributeSet INTEGER DEFAULT 0, updateTime INTEGER DEFAULT 0,
-      CONSTRAINT moz_uniqueid UNIQUE (name, host, path, originAttributes)
-    )`);
-
-  const jetzt = Date.now();
-  datenbank
-    .prepare(
-      `INSERT INTO moz_cookies
-       (originAttributes,name,value,host,path,expiry,lastAccessed,creationTime,isSecure,isHttpOnly,inBrowserElement,sameSite,schemeMap,isPartitionedAttributeSet,updateTime)
-       VALUES ('', 'pl_sitzung', ?, ?, '/', ?, ?, ?, ?, 1, 0, 1, ?, 0, ?)`,
-    )
-    .run(
-      token,
-      hostname,
-      Math.floor(jetzt / 1000) + 3600,
-      jetzt * 1000,
-      jetzt * 1000,
-      protocol === "https:" ? 1 : 0,
-      protocol === "https:" ? 2 : 1,
-      jetzt * 1000,
-    );
-  datenbank.close();
-
   return verzeichnis;
 }
 
-function aufnehmen(profil, pfad, datei, breite, hoehe) {
+/**
-  execFileSync(
+ * Nimmt eine Seite auf. Bewusst asynchron: Der Vermittler läuft im selben Prozess, und ein
-    "firefox",
+ * blockierender Aufruf würde ihn währenddessen stumm schalten – Firefox liefe in die Zeitüberschreitung.
-    [
+ */
-      "--profile",
+function aufnehmen(profil, pfad, datei, breite, hoehe, adresse) {
-      profil,
+  return new Promise((fertig, fehlgeschlagen) => {
-      "--headless",
+    const vorgang = spawn(
-      "--window-size",
+      "firefox",
-      `${breite},${hoehe}`,
+      [
-      "--screenshot",
+        "--profile",
-      datei,
+        profil,
-      `${BASIS}${pfad}`,
+        "--headless",
-    ],
+        "--window-size",
-    { stdio: "ignore", timeout: 120_000 },
+        `${breite},${hoehe}`,
-  );
+        "--screenshot",
+        datei,
+        `${adresse}${pfad}`,
+      ],
+      { stdio: "ignore", timeout: 120_000 },
+    );
+
+    vorgang.on("error", fehlgeschlagen);
+    vorgang.on("close", () => fertig());
+  });
 }
 
 async function main() {
@@ -133,35 +172,47 @@ async function main() {
 
   mkdirSync(ZIEL, { recursive: true });
   const token = await sitzungsToken();
+  const { server, port } = await vermittlerStarten(token);
+  const adresse = `http://127.0.0.1:${port}`;
 
-  const hell = profilVorbereiten("hell", token, false);
+  const hell = profilVorbereiten("hell", false);
   console.log(`Bilder nach ${ZIEL}`);
 
   // Die Anmeldeseite zeigt sich auch mit gültiger Sitzung, sie ist öffentlich.
-  aufnehmen(hell, "/login", path.join(ZIEL, "login.png"), 1280, 900);
+  await aufnehmen(hell, "/login", path.join(ZIEL, "login.png"), 1280, 900, BASIS);
   console.log("  login.png");
 
-  for (const seite of SEITEN) {
+  for (const seite of [...SEITEN, ...ZUSATZ]) {
-    aufnehmen(hell, seite.pfad, path.join(ZIEL, `${seite.name}.png`), 1680, 1150);
+    await aufnehmen(hell, seite.pfad, path.join(ZIEL, `${seite.name}.png`), 1680, 1150, adresse);
     console.log(`  ${seite.name}.png – ${seite.titel}`);
   }
 
   if (ALLE) {
-    const dunkel = profilVorbereiten("dunkel", token, true);
+    const dunkel = profilVorbereiten("dunkel", true);
     for (const seite of ["dashboard", "hosts", "rechnungen", "warnungen"]) {
       const eintrag = SEITEN.find((s) => s.name === seite);
-      aufnehmen(dunkel, eintrag.pfad, path.join(ZIEL, `${seite}-dunkel.png`), 1680, 1150);
+      await aufnehmen(dunkel, eintrag.pfad, path.join(ZIEL, `${seite}-dunkel.png`), 1680, 1150, adresse);
       console.log(`  ${seite}-dunkel.png`);
     }
 
     for (const seite of ["dashboard", "hosts"]) {
       const eintrag = SEITEN.find((s) => s.name === seite);
-      aufnehmen(hell, eintrag.pfad, path.join(ZIEL, `mobil-${seite}.png`), 390, 1500);
+      await aufnehmen(hell, eintrag.pfad, path.join(ZIEL, `mobil-${seite}.png`), 390, 1500, adresse);
       console.log(`  mobil-${seite}.png`);
     }
   }
 
+  server.close();
   if (existsSync(PROFIL_BASIS)) rmSync(PROFIL_BASIS, { recursive: true, force: true });
+
+  // Sicherung gegen stillen Fehlschlag: Alle Aufnahmen gleich groß heißt, jede zeigt die Anmeldeseite.
+  const groessen = SEITEN.map((seite) => statSync(path.join(ZIEL, `${seite.name}.png`)).size);
+  if (new Set(groessen).size === 1) {
+    throw new Error(
+      "Alle Aufnahmen sind gleich groß – vermutlich zeigt jede die Anmeldeseite. Sitzung prüfen.",
+    );
+  }
+
   console.log("Fertig.");
 }
 

src/app/(auth)/login/page.tsx

@@ -1,5 +1,6 @@
 import Link from "next/link";
 import { AnmeldeFormular } from "@/components/auth/AnmeldeFormular";
+import { PasskeyAnmeldung } from "@/components/auth/PasskeyAnmeldung";
 import { Logo } from "@/components/Logo";
 import { oidcEinstellungen } from "@/server/auth/oidc";
 
@@ -43,10 +44,14 @@ export default async function AnmeldeSeite({ searchParams }: { searchParams: Suc
                   <i className="bi bi-box-arrow-in-right me-1" aria-hidden="true" />
                   Mit {oidc.bezeichnung} anmelden
                 </Link>
-                <div className="text-center text-body-secondary small mb-3">oder mit Passwort</div>
+                <div className="text-center text-body-secondary small mb-3">oder</div>
               </>
             ) : null}
 
+            <PasskeyAnmeldung ziel={ziel} />
+
+            <div className="text-center text-body-secondary small mb-3">oder mit Passwort</div>
+
             <AnmeldeFormular ziel={ziel} />
           </div>
         </div>

src/app/(dashboard)/einstellungen/benachrichtigungen/page.tsx

@@ -42,6 +42,7 @@ export default async function BenachrichtigungenSeite() {
     absender: emailKonfiguration?.absender ?? "",
     empfaenger: emailKonfiguration?.empfaenger?.join(", ") ?? "",
     passwortGesetzt: Boolean(emailKonfiguration?.passwort),
+    // Der Wert selbst wird nie an den Browser gegeben – nur ob einer hinterlegt ist.
   };
 
   const webhookWerte: WebhookWerte = {

src/app/(dashboard)/einstellungen/benutzer/page.tsx

@@ -0,0 +1,55 @@
+import { BenutzerVerwaltung } from "@/components/einstellungen/BenutzerVerwaltung";
+import { ContentHeader } from "@/components/layout/ContentHeader";
+import { Callout } from "@/components/ui/Callout";
+import { prisma } from "@/lib/db";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
+
+export const metadata = { title: "Benutzer" };
+export const dynamic = "force-dynamic";
+
+export default async function BenutzerSeite() {
+  const ich = await sitzungErforderlich("verwaltung");
+
+  const [benutzer, kunden] = await Promise.all([
+    prisma.benutzer.findMany({
+      orderBy: [{ rolle: "asc" }, { name: "asc" }],
+      include: { kunde: { select: { name: true } }, _count: { select: { passkeys: true } } },
+    }),
+    prisma.kunde.findMany({ orderBy: { name: "asc" }, select: { id: true, name: true } }),
+  ]);
+
+  const zeilen = benutzer.map((eintrag) => ({
+    id: eintrag.id,
+    email: eintrag.email,
+    name: eintrag.name,
+    rolle: eintrag.rolle,
+    kundeId: eintrag.kundeId,
+    kundeName: eintrag.kunde?.name ?? null,
+    aktiv: eintrag.aktiv,
+    hatPasswort: eintrag.passwortHash !== null,
+    hatOidc: eintrag.oidcSubject !== null,
+    passkeys: eintrag._count.passkeys,
+    letzterLoginAm: eintrag.letzterLoginAm,
+  }));
+
+  return (
+    <>
+      <ContentHeader
+        titel="Benutzer"
+        brotkrumen={[{ titel: "Einstellungen" }, { titel: "Benutzer" }]}
+      />
+      <div className="app-content">
+        <div className="container-fluid">
+          <Callout farbe="info" titel="Rollen">
+            <strong>Administrator</strong> darf alles, auch Benutzer und Systemeinstellungen.{" "}
+            <strong>Techniker</strong> darf alles Fachliche, aber keine Benutzer anlegen.{" "}
+            <strong>Kunde</strong> sieht nur die Hosts und Rechnungen des eigenen Kunden – ohne
+            Einkaufspreise – und darf Notizen schreiben sowie Warnungen quittieren.
+          </Callout>
+
+          <BenutzerVerwaltung benutzer={zeilen} kunden={kunden} ichId={ich.benutzerId} />
+        </div>
+      </div>
+    </>
+  );
+}

src/app/(dashboard)/einstellungen/passkeys/page.tsx

@@ -0,0 +1,47 @@
+import { headers } from "next/headers";
+import { PasskeyVerwaltung } from "@/components/auth/PasskeyVerwaltung";
+import { ContentHeader } from "@/components/layout/ContentHeader";
+import { oeffentlicheBasis } from "@/lib/adresse";
+import { prisma } from "@/lib/db";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
+import { passkeysMoeglich } from "@/server/auth/passkeys";
+import { einstellungen } from "@/server/einstellungen";
+
+export const metadata = { title: "Meine Passkeys" };
+export const dynamic = "force-dynamic";
+
+export default async function PasskeySeite() {
+  const ich = await sitzungErforderlich();
+  const { dashboardUrl } = await einstellungen();
+
+  const [passkeys, kopfzeilen] = await Promise.all([
+    prisma.passkey.findMany({
+      where: { benutzerId: ich.benutzerId },
+      orderBy: { erstelltAm: "desc" },
+      select: { id: true, bezeichnung: true, erstelltAm: true, zuletztAm: true },
+    }),
+    headers(),
+  ]);
+
+  // Die Seite kennt die Anfrage nur über die Kopfzeilen; daraus entsteht dieselbe Adresse,
+  // die auch die Passkey-Endpunkte verwenden.
+  const basis = oeffentlicheBasis(new Request("http://platzhalter.invalid", { headers: kopfzeilen }), dashboardUrl);
+
+  return (
+    <>
+      <ContentHeader
+        titel="Meine Passkeys"
+        brotkrumen={[{ titel: "Einstellungen" }, { titel: "Passkeys" }]}
+      />
+      <div className="app-content">
+        <div className="container-fluid">
+          <PasskeyVerwaltung
+            passkeys={passkeys}
+            moeglich={passkeysMoeglich(basis.origin)}
+            adresse={basis.origin}
+          />
+        </div>
+      </div>
+    </>
+  );
+}

src/app/(dashboard)/einstellungen/system/page.tsx

@@ -1,23 +1,32 @@
+import { SystemFormular } from "@/components/einstellungen/SystemFormular";
 import { ContentHeader } from "@/components/layout/ContentHeader";
 import { Card } from "@/components/ui/Card";
 import { APP_VERSION } from "@/lib/version";
+import { einstellungen } from "@/server/einstellungen";
 
 export const metadata = { title: "System" };
 
-export default function SystemSeite() {
+export default async function SystemSeite() {
+  const werte = await einstellungen();
+
   return (
     <>
       <ContentHeader titel="System" brotkrumen={[{ titel: "Einstellungen" }, { titel: "System" }]} />
       <div className="app-content">
         <div className="container-fluid">
-          <Card titel="Systeminformationen" rahmen="primary">
+          <SystemFormular werte={werte} appUrl={process.env.APP_URL ?? ""} />
+
+          <Card titel="Systeminformationen" rahmen="keiner">
             <dl className="row mb-0">
               <dt className="col-4 fw-normal text-body-secondary">Version</dt>
               <dd className="col-8">{APP_VERSION}</dd>
-              <dt className="col-4 fw-normal text-body-secondary">Datenquelle</dt>
+              <dt className="col-4 fw-normal text-body-secondary">Zeitzone des Servers</dt>
-              <dd className="col-8">Beispieldaten (Prototyp, #002)</dd>
+              <dd className="col-8">{Intl.DateTimeFormat().resolvedOptions().timeZone}</dd>
-              <dt className="col-4 fw-normal text-body-secondary">Warnregeln</dt>
+              <dt className="col-4 fw-normal text-body-secondary">Nur in der Umgebung</dt>
-              <dd className="col-8">Konfigurierbar ab #011</dd>
+              <dd className="col-8">
+                <code>APP_SECRET</code> und <code>DATABASE_URL</code> – beide werden gebraucht, bevor
+                die Datenbank gelesen werden kann.
+              </dd>
             </dl>
           </Card>
         </div>

src/app/(dashboard)/hosts/[id]/page.tsx

@@ -46,6 +46,16 @@ export default async function HostDetailSeite({ params }: { params: Promise<{ id
     select: { id: true, name: true },
   });
 
+  // Welche Cluster-Mitglieder melden sich selbst? Fehlende Knoten haben keinen Agent (#022).
+  const geschwister =
+    host.clusterMitglieder.length > 0
+      ? await prisma.host.findMany({
+          where: { hostname: { in: host.clusterMitglieder, mode: "insensitive" } },
+          select: { id: true, hostname: true, subStatus: true, letzterReportAm: true },
+        })
+      : [];
+  const meldende = new Map(geschwister.map((eintrag) => [eintrag.hostname.toLowerCase(), eintrag]));
+
   const jetzt = new Date();
   const meldetNicht = !host.letzterReportAm || host.letzterReportAm < meldungsGrenze(jetzt);
   const socketAbweichung =
@@ -113,6 +123,31 @@ export default async function HostDetailSeite({ params }: { params: Promise<{ id
                 <Zeile bezeichnung="Cluster / Node">
                   {host.clusterName ? `${host.clusterName} / ${host.nodeName ?? "?"}` : "–"}
                 </Zeile>
+                {host.clusterMitglieder.length > 0 ? (
+                  <Zeile bezeichnung={`Cluster-Knoten (${host.clusterMitglieder.length})`}>
+                    <span className="d-inline-block text-start">
+                      {host.clusterMitglieder.map((mitglied) => {
+                        const eintrag = meldende.get(mitglied.toLowerCase());
+                        return (
+                          <span key={mitglied} className="d-block small">
+                            {eintrag ? (
+                              <Link href={`/hosts/${eintrag.id}`} className="text-decoration-none">
+                                {mitglied}
+                              </Link>
+                            ) : (
+                              mitglied
+                            )}{" "}
+                            {eintrag ? (
+                              <Badge farbe="success">meldet sich</Badge>
+                            ) : (
+                              <Badge farbe="warning">kein Agent</Badge>
+                            )}
+                          </span>
+                        );
+                      })}
+                    </span>
+                  </Zeile>
+                ) : null}
                 <Zeile bezeichnung="IP-Adressen">{host.ips.join(", ") || "–"}</Zeile>
                 <Zeile bezeichnung="CPU">{host.cpuModell ?? "–"}</Zeile>
                 <Zeile bezeichnung="Sockets (lizenziert / physisch)">

src/app/(dashboard)/hosts/export/route.ts

@@ -3,6 +3,7 @@ import { csvAntwort, csvDatei } from "@/lib/csv";
 import { formatDatum } from "@/lib/format";
 import { Bericht, pdfAntwort, Tabelle } from "@/server/pdf/dokument";
 import { hostListe, type HostFilter } from "@/server/queries/hostliste";
+import { einstellungen } from "@/server/einstellungen";
 
 type ExportHost = Awaited<ReturnType<typeof hostListe>>["hosts"][number];
 
@@ -34,8 +35,12 @@ export async function GET(request: Request) {
   const datum = new Date().toISOString().slice(0, 10);
 
   if (new URL(request.url).searchParams.get("format") === "pdf") {
+    const { firmaName, firmaAnschrift, firmaEmail, zeitzone } = await einstellungen();
+    const firmaAngaben = { name: firmaName, anschrift: firmaAnschrift, email: firmaEmail, zeitzone };
+
     return pdfAntwort(
       Bericht({
+      firma: firmaAngaben,
         titel: "Host-Liste",
         untertitel: `${alle.length} Hosts`,
         quer: true,

src/app/(dashboard)/kunden/[id]/export/route.ts

@@ -2,6 +2,7 @@ import { PRODUKT_TEXT, STATUS_TEXT, statusAusDatenbank } from "@/lib/anzeige";
 import { formatDatum, formatEuro } from "@/lib/format";
 import { Abschnitt, Bericht, pdfAntwort, Tabelle } from "@/server/pdf/dokument";
 import { kundeMitDetails, laufzeitenVonKunde, summen, summenProJahr } from "@/server/queries/kunden";
+import { einstellungen } from "@/server/einstellungen";
 
 export const dynamic = "force-dynamic";
 
@@ -15,9 +16,12 @@ export async function GET(_request: Request, { params }: { params: Promise<{ id:
   const gesamt = summen(laufzeiten);
   const proJahr = summenProJahr(laufzeiten);
   const datum = new Date().toISOString().slice(0, 10);
+  const { firmaName, firmaAnschrift, firmaEmail, zeitzone } = await einstellungen();
+  const firmaAngaben = { name: firmaName, anschrift: firmaAnschrift, email: firmaEmail, zeitzone };
 
   return pdfAntwort(
     Bericht({
+      firma: firmaAngaben,
       titel: kunde.name,
       untertitel: `Kundennummer ${kunde.kundennummer}${kunde.ansprechpartner ? ` · ${kunde.ansprechpartner}` : ""}`,
       children: [

src/app/(dashboard)/kunden/export/route.ts

@@ -1,6 +1,7 @@
 import { csvAntwort, csvDatei } from "@/lib/csv";
 import { formatDatum, formatEuro } from "@/lib/format";
 import { Bericht, pdfAntwort, Tabelle } from "@/server/pdf/dokument";
+import { einstellungen } from "@/server/einstellungen";
 import {
   kundenListe,
   offeneRechnungspunkteProKunde,
@@ -30,8 +31,12 @@ export async function GET(request: Request) {
   const datum = new Date().toISOString().slice(0, 10);
 
   if (format === "pdf") {
+    const { firmaName, firmaAnschrift, firmaEmail, zeitzone } = await einstellungen();
+    const firmaAngaben = { name: firmaName, anschrift: firmaAnschrift, email: firmaEmail, zeitzone };
+
     return pdfAntwort(
       Bericht({
+      firma: firmaAngaben,
         titel: "Kundenübersicht",
         untertitel: `${zeilen.length} Kunden`,
         quer: true,

src/app/(dashboard)/layout.tsx

@@ -1,9 +1,7 @@
-import { cookies } from "next/headers";
-import { redirect } from "next/navigation";
 import { Footer } from "@/components/layout/Footer";
 import { Header } from "@/components/layout/Header";
 import { Sidebar } from "@/components/layout/Sidebar";
-import { SITZUNGS_COOKIE, sitzungLesen } from "@/lib/sitzung";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { kennzahlen, offeneAlerts, suchIndex } from "@/server/queries/hosts";
 
 /**
@@ -13,9 +11,9 @@ import { kennzahlen, offeneAlerts, suchIndex } from "@/server/queries/hosts";
 export const dynamic = "force-dynamic";
 
 export default async function DashboardLayout({ children }: { children: React.ReactNode }) {
-  // Der Schutz liegt in proxy.ts; hier wird zusätzlich geprüft, damit kein Zustand ohne Benutzer entsteht.
+  // Der Schutz liegt in proxy.ts; hier wird zusätzlich geprüft, damit kein Zustand ohne Benutzer
-  const sitzung = await sitzungLesen((await cookies()).get(SITZUNGS_COOKIE)?.value);
+  // entsteht – und weil hier Rolle und Kundenbindung herkommen.
-  if (!sitzung) redirect("/login");
+  const sitzung = await sitzungErforderlich();
 
   const [zahlen, alerts, suche] = await Promise.all([kennzahlen(), offeneAlerts(), suchIndex()]);
 
@@ -31,12 +29,14 @@ export default async function DashboardLayout({ children }: { children: React.Re
         }))}
         suchEintraege={suche}
         benutzer={sitzung.name}
+        rolle={sitzung.rolle}
       />
       <Sidebar
         hostsAnzahl={zahlen.hostsGesamt}
         offeneRechnungspunkte={zahlen.offeneRechnungspunkte}
         offeneWarnungen={zahlen.offeneAlerts}
         benutzer={sitzung.name}
+        rolle={sitzung.rolle}
       />
       <main className="app-main">{children}</main>
       <Footer />

src/app/(dashboard)/rechnungen/[id]/page.tsx

@@ -9,6 +9,7 @@ import { CopyableCode } from "@/components/ui/CopyableCode";
 import { PRODUKT_TEXT } from "@/lib/anzeige";
 import { formatDatum, formatEuro } from "@/lib/format";
 import { laufzeitBestaetigenAktion, laufzeitVerwerfenAktion } from "@/server/actions/rechnungen";
+import { einstellungen, faelligkeitsVorschlag } from "@/server/einstellungen";
 import { laufzeitDetail } from "@/server/queries/rechnungen";
 
 export async function generateMetadata({ params }: { params: Promise<{ id: string }> }) {
@@ -28,6 +29,12 @@ export default async function LaufzeitSeite({ params }: { params: Promise<{ id:
   const verkaufBetrag = laufzeit.kundenPosition ? Number(laufzeit.kundenPosition.nettoBetrag) : null;
   const marge = einkaufBetrag !== null && verkaufBetrag !== null ? verkaufBetrag - einkaufBetrag : null;
 
+  // Vorgaben aus den Einstellungen füllen leere Felder vor (#025).
+  const [vorgaben, faelligVorschlag] = await Promise.all([einstellungen(), faelligkeitsVorschlag()]);
+  const verkaufVorschlag =
+    verkaufBetrag ??
+    (einkaufBetrag === null ? null : Math.round(einkaufBetrag * (1 + vorgaben.margeProzent / 100) * 100) / 100);
+
   const zeitraum = `${formatDatum(laufzeit.start)} – ${formatDatum(laufzeit.ende)}`;
 
   return (
@@ -148,9 +155,9 @@ export default async function LaufzeitSeite({ params }: { params: Promise<{ id:
                   werte={{
                     nummer: einkauf?.nummer ?? null,
                     datum: einkauf?.datum.toISOString() ?? null,
-                    faelligAm: einkauf?.faelligAm?.toISOString() ?? null,
+                    faelligAm: einkauf?.faelligAm?.toISOString() ?? faelligVorschlag,
                     nettoBetrag: einkaufBetrag,
-                    ustSatz: Number(einkauf?.ustSatz ?? 19),
+                    ustSatz: Number(einkauf?.ustSatz ?? vorgaben.steuersatz),
                     rabatt:
                       einkauf?.rabatt === null || einkauf?.rabatt === undefined
                         ? null
@@ -179,8 +186,8 @@ export default async function LaufzeitSeite({ params }: { params: Promise<{ id:
                     erstellt: verkauf?.erstellt ?? false,
                     nummer: verkauf?.nummer ?? null,
                     datum: verkauf?.datum?.toISOString() ?? null,
-                    nettoBetrag: verkaufBetrag,
+                    nettoBetrag: verkaufVorschlag,
-                    ustSatz: Number(verkauf?.ustSatz ?? 19),
+                    ustSatz: Number(verkauf?.ustSatz ?? vorgaben.steuersatz),
                     bezahlt: verkauf?.bezahlt ?? false,
                     bezahltAm: verkauf?.bezahltAm?.toISOString() ?? null,
                     anhangId: verkauf?.anhangId ?? null,

src/app/(dashboard)/rechnungen/export/route.ts

@@ -2,6 +2,7 @@ import { csvAntwort, csvDatei } from "@/lib/csv";
 import { formatDatum, formatEuro } from "@/lib/format";
 import { Bericht, pdfAntwort, Tabelle } from "@/server/pdf/dokument";
 import { rechnungsListe, type RechnungsFilter } from "@/server/queries/rechnungen";
+import { einstellungen } from "@/server/einstellungen";
 
 export const dynamic = "force-dynamic";
 
@@ -21,8 +22,12 @@ export async function GET(request: Request) {
   const zeitraum = filter.jahr ? `Jahr ${filter.jahr}` : "alle Jahre";
 
   if (format === "pdf") {
+    const { firmaName, firmaAnschrift, firmaEmail, zeitzone } = await einstellungen();
+    const firmaAngaben = { name: firmaName, anschrift: firmaAnschrift, email: firmaEmail, zeitzone };
+
     return pdfAntwort(
       Bericht({
+      firma: firmaAngaben,
         titel: "Rechnungsliste",
         untertitel: `${zeilen.length} Laufzeiten · ${zeitraum}`,
         quer: true,

src/app/agent.sh/route.ts

@@ -4,6 +4,6 @@ export const dynamic = "force-dynamic";
 
 /** Aktuelles Agent-Skript, wird vom Installer und vom Update-Mechanismus geladen. */
 export async function GET(request: Request) {
-  const inhalt = await skriptLaden("proxledger-agent.sh", basisUrl(request));
+  const inhalt = await skriptLaden("proxledger-agent.sh", await basisUrl(request));
   return skriptAntwort(inhalt, "proxledger-agent.sh");
 }

src/app/api/auth/anmelden/route.ts

@@ -1,7 +1,9 @@
 import { cookies, headers } from "next/headers";
+import { eigeneAdresse } from "@/lib/adresse";
 import { clientIp } from "@/lib/ratelimit";
 import { cookieOptionen, SITZUNGS_COOKIE, sitzungErzeugen } from "@/lib/sitzung";
 import { AnmeldeFehler, mitPasswortAnmelden } from "@/server/auth/benutzer";
+import { einstellungen } from "@/server/einstellungen";
 
 export const dynamic = "force-dynamic";
 
@@ -9,8 +11,35 @@ export const dynamic = "force-dynamic";
  * Anmeldung als gewöhnliches Formular. Bewusst kein Server-Action-Weg: So funktioniert die
  * Anmeldung auch ohne JavaScript, und das Sitzungs-Cookie hängt an einer normalen Antwort.
  */
+/**
+ * Prüft, ob das Formular von der eigenen Oberfläche kam.
+ *
+ * Ohne diese Prüfung könnte eine fremde Seite ein Anmeldeformular auf dieses Dashboard abschicken
+ * und das Opfer unbemerkt in ein untergeschobenes Konto anmelden (Login-CSRF, OWASP A01).
+ * Server Actions in Next.js prüfen das selbst; dieser Endpunkt ist ein gewöhnliches Formular
+ * und muss es daher selbst tun.
+ */
+export function herkunftStimmt(request: Request): boolean {
+  const herkunft = request.headers.get("origin");
+  // Formulare ohne Origin (etwa curl oder alte Browser) werden nicht ausgeschlossen –
+  // der Schutz richtet sich gegen fremde Seiten, die immer einen Origin senden.
+  if (!herkunft) return true;
+
+  const erlaubt = new Set<string>();
+  if (process.env.APP_URL) erlaubt.add(new URL(process.env.APP_URL).host);
+  const gastgeber = request.headers.get("x-forwarded-host") ?? request.headers.get("host");
+  if (gastgeber) erlaubt.add(gastgeber);
+
+  try {
+    return erlaubt.has(new URL(herkunft).host);
+  } catch {
+    return false;
+  }
+}
+
 export async function POST(request: Request) {
   const formular = await request.formData();
+  const { dashboardUrl } = await einstellungen();
   const email = formular.get("email")?.toString().trim() ?? "";
   const passwort = formular.get("passwort")?.toString() ?? "";
   const zielEingabe = formular.get("ziel")?.toString() || "/";
@@ -18,12 +47,16 @@ export async function POST(request: Request) {
   const ziel = zielEingabe.startsWith("/") && !zielEingabe.startsWith("//") ? zielEingabe : "/";
 
   function zurueckZurAnmeldung(meldung: string) {
-    const adresse = new URL("/login", request.url);
+    const adresse = eigeneAdresse(request, "/login", dashboardUrl);
     adresse.searchParams.set("fehler", meldung);
     if (ziel !== "/") adresse.searchParams.set("ziel", ziel);
     return Response.redirect(adresse, 303);
   }
 
+  if (!herkunftStimmt(request)) {
+    return zurueckZurAnmeldung("Die Anmeldung kam nicht von dieser Adresse.");
+  }
+
   if (!email || !passwort) {
     return zurueckZurAnmeldung("E-Mail-Adresse und Passwort eingeben.");
   }
@@ -32,15 +65,19 @@ export async function POST(request: Request) {
     const kopfzeilen = await headers();
     const benutzer = await mitPasswortAnmelden(email, passwort, clientIp(kopfzeilen));
 
-    const token = await sitzungErzeugen({
+    const { sitzungsdauerStunden } = await einstellungen();
-      benutzerId: benutzer.id,
+    const token = await sitzungErzeugen(
-      email: benutzer.email,
+      {
-      name: benutzer.name,
+        benutzerId: benutzer.id,
-      herkunft: "passwort",
+        email: benutzer.email,
-    });
+        name: benutzer.name,
-    (await cookies()).set(SITZUNGS_COOKIE, token, cookieOptionen());
+        herkunft: "passwort",
+      },
+      sitzungsdauerStunden,
+    );
+    (await cookies()).set(SITZUNGS_COOKIE, token, cookieOptionen(sitzungsdauerStunden));
 
-    return Response.redirect(new URL(ziel, request.url), 303);
+    return Response.redirect(eigeneAdresse(request, ziel, dashboardUrl), 303);
   } catch (fehler) {
     if (fehler instanceof AnmeldeFehler) return zurueckZurAnmeldung(fehler.message);
     console.error("Anmeldung fehlgeschlagen:", fehler);

src/app/api/auth/oidc/callback/route.ts

@@ -1,7 +1,9 @@
 import { cookies } from "next/headers";
+import { eigeneAdresse } from "@/lib/adresse";
 import { cookieOptionen, SITZUNGS_COOKIE, sitzungErzeugen } from "@/lib/sitzung";
 import { mitOidcAnmelden } from "@/server/auth/benutzer";
 import { anmeldungAbschliessen, oidcEinstellungen } from "@/server/auth/oidc";
+import { einstellungen as systemEinstellungen } from "@/server/einstellungen";
 
 export const dynamic = "force-dynamic";
 
@@ -17,25 +19,31 @@ export async function GET(request: Request) {
     speicher.delete(name);
   }
 
+  const { dashboardUrl } = await systemEinstellungen();
+
   if (!einstellungen || !pruefwert || !zustand) {
-    return Response.redirect(new URL("/login?fehler=oidc", request.url), 302);
+    return Response.redirect(eigeneAdresse(request, "/login?fehler=oidc", dashboardUrl), 302);
   }
 
   try {
     const angaben = await anmeldungAbschliessen(einstellungen, new URL(request.url), pruefwert, zustand);
     const benutzer = await mitOidcAnmelden(angaben.subject, angaben.email, angaben.name);
 
-    const token = await sitzungErzeugen({
+    const { sitzungsdauerStunden } = await systemEinstellungen();
-      benutzerId: benutzer.id,
+    const token = await sitzungErzeugen(
-      email: benutzer.email,
+      {
-      name: benutzer.name,
+        benutzerId: benutzer.id,
-      herkunft: "oidc",
+        email: benutzer.email,
-    });
+        name: benutzer.name,
-    speicher.set(SITZUNGS_COOKIE, token, cookieOptionen());
+        herkunft: "oidc",
+      },
+      sitzungsdauerStunden,
+    );
+    speicher.set(SITZUNGS_COOKIE, token, cookieOptionen(sitzungsdauerStunden));
 
-    return Response.redirect(new URL(ziel.startsWith("/") ? ziel : "/", request.url), 302);
+    return Response.redirect(eigeneAdresse(request, ziel.startsWith("/") ? ziel : "/", dashboardUrl), 302);
   } catch (fehler) {
     console.error("OIDC-Rückkehr fehlgeschlagen:", fehler);
-    return Response.redirect(new URL("/login?fehler=oidc", request.url), 302);
+    return Response.redirect(eigeneAdresse(request, "/login?fehler=oidc", dashboardUrl), 302);
   }
 }

src/app/api/auth/passkey/anmelden/route.ts

@@ -0,0 +1,64 @@
+import { cookies } from "next/headers";
+import { cookieOptionen, SITZUNGS_COOKIE, sitzungErzeugen, ueberHttps } from "@/lib/sitzung";
+import { prisma } from "@/lib/db";
+import { protokolliere } from "@/server/audit";
+import { anmeldungPruefen, anmeldungVorbereiten, herkunft } from "@/server/auth/passkeys";
+import { einstellungen } from "@/server/einstellungen";
+
+export const dynamic = "force-dynamic";
+
+const CHALLENGE_COOKIE = "pl_passkey_anmeldung";
+
+function challengeOptionen() {
+  return {
+    httpOnly: true,
+    sameSite: "strict" as const,
+    secure: ueberHttps(),
+    path: "/",
+    maxAge: 300,
+  };
+}
+
+/** Schritt 1: Aufgabe für die Anmeldung erzeugen – ohne Benutzernamen, der Browser wählt den Schlüssel. */
+export async function GET(request: Request) {
+  const optionen = await anmeldungVorbereiten(await herkunft(request));
+  (await cookies()).set(CHALLENGE_COOKIE, optionen.challenge, challengeOptionen());
+  return Response.json(optionen);
+}
+
+/** Schritt 2: Antwort prüfen und die Sitzung anlegen. */
+export async function POST(request: Request) {
+  const speicher = await cookies();
+  const challenge = speicher.get(CHALLENGE_COOKIE)?.value;
+  if (!challenge) {
+    return Response.json({ fehler: "Die Aufgabe ist abgelaufen. Bitte erneut versuchen." }, { status: 400 });
+  }
+
+  try {
+    const antwort = await request.json();
+    const benutzer = await anmeldungPruefen(antwort, challenge, await herkunft(request));
+
+    const { sitzungsdauerStunden } = await einstellungen();
+    const token = await sitzungErzeugen(
+      {
+        benutzerId: benutzer.id,
+        email: benutzer.email,
+        name: benutzer.name,
+        herkunft: "passkey",
+      },
+      sitzungsdauerStunden,
+    );
+    speicher.set(SITZUNGS_COOKIE, token, cookieOptionen(sitzungsdauerStunden));
+
+    await prisma.benutzer.update({ where: { id: benutzer.id }, data: { letzterLoginAm: new Date() } });
+    await protokolliere("anmeldung.erfolgreich", "Benutzer", benutzer.id, { weg: "passkey" });
+
+    return Response.json({ erfolg: true });
+  } catch (fehler) {
+    console.error("Passkey-Anmeldung fehlgeschlagen:", fehler);
+    // Bewusst unscharf: Ob es den Passkey gibt, geht einen Unbekannten nichts an.
+    return Response.json({ fehler: "Anmeldung mit diesem Passkey nicht möglich." }, { status: 400 });
+  } finally {
+    speicher.delete(CHALLENGE_COOKIE);
+  }
+}

src/app/api/auth/passkey/registrieren/route.ts

@@ -0,0 +1,63 @@
+import { cookies } from "next/headers";
+import { ueberHttps } from "@/lib/sitzung";
+import { protokolliere } from "@/server/audit";
+import { angemeldet } from "@/server/auth/sitzungspflicht";
+import { herkunft, registrierungAbschliessen, registrierungVorbereiten } from "@/server/auth/passkeys";
+
+export const dynamic = "force-dynamic";
+
+/** Die Aufgabe („challenge“) darf nur für diesen Browser und nur kurz gelten. */
+const CHALLENGE_COOKIE = "pl_passkey_registrierung";
+
+function challengeOptionen() {
+  return {
+    httpOnly: true,
+    sameSite: "strict" as const,
+    secure: ueberHttps(),
+    path: "/",
+    maxAge: 300,
+  };
+}
+
+/** Schritt 1: Aufgabe erzeugen. */
+export async function GET(request: Request) {
+  const benutzer = await angemeldet();
+  if (!benutzer) return new Response("Nicht angemeldet", { status: 401 });
+
+  const optionen = await registrierungVorbereiten(benutzer.benutzerId, await herkunft(request));
+  (await cookies()).set(CHALLENGE_COOKIE, optionen.challenge, challengeOptionen());
+
+  return Response.json(optionen);
+}
+
+/** Schritt 2: Antwort des Browsers prüfen und den Passkey hinterlegen. */
+export async function POST(request: Request) {
+  const benutzer = await angemeldet();
+  if (!benutzer) return new Response("Nicht angemeldet", { status: 401 });
+
+  const speicher = await cookies();
+  const challenge = speicher.get(CHALLENGE_COOKIE)?.value;
+  if (!challenge) return Response.json({ fehler: "Die Aufgabe ist abgelaufen. Bitte erneut versuchen." }, { status: 400 });
+
+  try {
+    const { antwort, bezeichnung } = await request.json();
+    const passkey = await registrierungAbschliessen(
+      benutzer.benutzerId,
+      antwort,
+      challenge,
+      await herkunft(request),
+      typeof bezeichnung === "string" ? bezeichnung : "Passkey",
+    );
+
+    await protokolliere("passkey.angelegt", "Passkey", passkey.id, { bezeichnung: passkey.bezeichnung });
+    return Response.json({ erfolg: true, bezeichnung: passkey.bezeichnung });
+  } catch (fehler) {
+    console.error("Passkey-Registrierung fehlgeschlagen:", fehler);
+    return Response.json(
+      { fehler: fehler instanceof Error ? fehler.message : "Der Passkey ließ sich nicht hinterlegen." },
+      { status: 400 },
+    );
+  } finally {
+    speicher.delete(CHALLENGE_COOKIE);
+  }
+}

src/app/install.sh/route.ts

@@ -4,6 +4,6 @@ export const dynamic = "force-dynamic";
 
 /** Installationsskript für den One-Liner `curl -fsSL <url>/install.sh | bash -s -- --token …`. */
 export async function GET(request: Request) {
-  const inhalt = await skriptLaden("install.sh", basisUrl(request));
+  const inhalt = await skriptLaden("install.sh", await basisUrl(request));
   return skriptAntwort(inhalt, "install.sh");
 }

src/components/auth/PasskeyAnmeldung.tsx

@@ -0,0 +1,66 @@
+"use client";
+
+import { startAuthentication } from "@simplewebauthn/browser";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+
+/**
+ * Anmeldung per Passkey. Der Knopf erscheint immer; ob ein Passkey vorliegt, weiß erst der Browser –
+ * und das darf die Seite auch nicht vorher verraten (sonst ließen sich Konten ausspähen).
+ */
+export function PasskeyAnmeldung({ ziel }: { ziel: string }) {
+  const router = useRouter();
+  const [laeuft, setLaeuft] = useState(false);
+  const [fehler, setFehler] = useState<string | null>(null);
+
+  async function anmelden() {
+    setLaeuft(true);
+    setFehler(null);
+
+    try {
+      const optionen = await fetch("/api/auth/passkey/anmelden").then((antwort) => antwort.json());
+      const antwort = await startAuthentication({ optionsJSON: optionen });
+
+      const ergebnis = await fetch("/api/auth/passkey/anmelden", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(antwort),
+      }).then((a) => a.json());
+
+      if (ergebnis.erfolg) {
+        router.push(ziel.startsWith("/") ? ziel : "/");
+        router.refresh();
+      } else {
+        setFehler(ergebnis.fehler ?? "Anmeldung nicht möglich.");
+      }
+    } catch (fehler) {
+      setFehler(
+        fehler instanceof Error && fehler.name === "NotAllowedError"
+          ? "Abgebrochen."
+          : "Mit diesem Gerät geht es nicht. Passkeys brauchen HTTPS.",
+      );
+    } finally {
+      setLaeuft(false);
+    }
+  }
+
+  return (
+    <>
+      {fehler ? (
+        <div className="alert alert-danger py-2" role="alert">
+          {fehler}
+        </div>
+      ) : null}
+
+      <button
+        type="button"
+        className="btn btn-outline-primary w-100 pl-touch-target mb-3"
+        onClick={anmelden}
+        disabled={laeuft}
+      >
+        <i className="bi bi-fingerprint me-1" aria-hidden="true" />
+        {laeuft ? "Warte auf den Browser …" : "Mit Passkey anmelden"}
+      </button>
+    </>
+  );
+}

src/components/auth/PasskeyVerwaltung.tsx

@@ -0,0 +1,153 @@
+"use client";
+
+import { startRegistration } from "@simplewebauthn/browser";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+import { Card } from "@/components/ui/Card";
+import { formatDatumZeit } from "@/lib/format";
+import { passkeyLoeschen } from "@/server/actions/passkeys";
+
+export interface PasskeyZeile {
+  id: string;
+  bezeichnung: string;
+  erstelltAm: Date;
+  zuletztAm: Date | null;
+}
+
+export function PasskeyVerwaltung({
+  passkeys,
+  moeglich,
+  adresse,
+}: {
+  passkeys: PasskeyZeile[];
+  moeglich: boolean;
+  adresse: string;
+}) {
+  const router = useRouter();
+  const [bezeichnung, setBezeichnung] = useState("");
+  const [meldung, setMeldung] = useState<{ art: "fehler" | "erfolg"; text: string } | null>(null);
+  const [laeuft, setLaeuft] = useState(false);
+
+  async function registrieren() {
+    setLaeuft(true);
+    setMeldung(null);
+
+    try {
+      const optionen = await fetch("/api/auth/passkey/registrieren").then((antwort) => antwort.json());
+      // Hier öffnet der Browser seine eigene Abfrage (Fingerabdruck, Gesicht, PIN oder Sicherheitsschlüssel).
+      const antwort = await startRegistration({ optionsJSON: optionen });
+
+      const ergebnis = await fetch("/api/auth/passkey/registrieren", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ antwort, bezeichnung }),
+      }).then((a) => a.json());
+
+      if (ergebnis.fehler) {
+        setMeldung({ art: "fehler", text: ergebnis.fehler });
+      } else {
+        setMeldung({ art: "erfolg", text: `„${ergebnis.bezeichnung}“ ist hinterlegt.` });
+        setBezeichnung("");
+        router.refresh();
+      }
+    } catch (fehler) {
+      // Abbruch durch den Benutzer ist kein Fehler, sieht aber genauso aus – deshalb neutral formulieren.
+      setMeldung({
+        art: "fehler",
+        text:
+          fehler instanceof Error && fehler.name === "NotAllowedError"
+            ? "Abgebrochen oder abgelehnt."
+            : "Der Passkey konnte nicht angelegt werden.",
+      });
+    } finally {
+      setLaeuft(false);
+    }
+  }
+
+  return (
+    <>
+      <Card titel="Neuen Passkey anlegen" rahmen="primary">
+        {!moeglich ? (
+          <div className="alert alert-warning mb-3">
+            <strong>Über diese Adresse geht es nicht.</strong> Passkeys verlangen HTTPS; nur{" "}
+            <code>localhost</code> ist ausgenommen. Aufgerufen wurde <code>{adresse}</code>. Richten Sie
+            einen Reverse Proxy mit Zertifikat ein und tragen Sie die Adresse unter{" "}
+            <em>Einstellungen → System</em> ein.
+          </div>
+        ) : null}
+
+        {meldung ? (
+          <div className={`alert ${meldung.art === "fehler" ? "alert-danger" : "alert-success"}`}>
+            {meldung.text}
+          </div>
+        ) : null}
+
+        <div className="row g-3 align-items-end">
+          <div className="col-12 col-md-5">
+            <label className="form-label" htmlFor="passkey-name">
+              Bezeichnung
+            </label>
+            <input
+              className="form-control"
+              id="passkey-name"
+              value={bezeichnung}
+              onChange={(e) => setBezeichnung(e.target.value)}
+              placeholder="z. B. Arbeitsrechner oder Telefon"
+              disabled={!moeglich}
+            />
+            <div className="form-text">Hilft später beim Wiedererkennen, wenn mehrere hinterlegt sind.</div>
+          </div>
+          <div className="col-12 col-md-4">
+            <button type="button" className="btn btn-primary" onClick={registrieren} disabled={!moeglich || laeuft}>
+              <i className="bi bi-fingerprint me-2" aria-hidden="true" />
+              {laeuft ? "Warte auf den Browser …" : "Passkey anlegen"}
+            </button>
+          </div>
+        </div>
+      </Card>
+
+      <Card titel={`Hinterlegte Passkeys (${passkeys.length})`} rahmen="keiner">
+        {passkeys.length === 0 ? (
+          <p className="text-body-secondary mb-0">
+            Noch keiner. Ohne Passkey bleibt die Anmeldung per Passwort oder OIDC – beides funktioniert
+            weiterhin.
+          </p>
+        ) : (
+          <div className="table-responsive">
+            <table className="table align-middle">
+              <thead>
+                <tr>
+                  <th scope="col">Bezeichnung</th>
+                  <th scope="col">Angelegt</th>
+                  <th scope="col">Zuletzt benutzt</th>
+                  <th scope="col" className="text-end">
+                    Aktion
+                  </th>
+                </tr>
+              </thead>
+              <tbody>
+                {passkeys.map((passkey) => (
+                  <tr key={passkey.id}>
+                    <td className="fw-semibold">{passkey.bezeichnung}</td>
+                    <td className="small">{formatDatumZeit(passkey.erstelltAm)}</td>
+                    <td className="small">
+                      {passkey.zuletztAm ? formatDatumZeit(passkey.zuletztAm) : "noch nie"}
+                    </td>
+                    <td className="text-end">
+                      <form action={passkeyLoeschen}>
+                        <input type="hidden" name="id" value={passkey.id} />
+                        <button type="submit" className="btn btn-sm btn-outline-danger">
+                          Entfernen
+                        </button>
+                      </form>
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        )}
+      </Card>
+    </>
+  );
+}

src/components/einstellungen/BenutzerVerwaltung.tsx

@@ -0,0 +1,316 @@
+"use client";
+
+import { useActionState, useState } from "react";
+import { Card } from "@/components/ui/Card";
+import type { Rolle } from "@/generated/prisma/enums";
+import { formatDatumZeit } from "@/lib/format";
+import { PASSWORT_MINDESTLAENGE } from "@/lib/passwort";
+import {
+  type AktionsErgebnis,
+  benutzerAnlegen,
+  benutzerLoeschen,
+  benutzerSpeichern,
+  benutzerSperreUmschalten,
+} from "@/server/actions/benutzer";
+import { ROLLEN_BESCHREIBUNG, ROLLEN_TEXT } from "@/server/auth/rollen";
+
+export interface BenutzerZeile {
+  id: string;
+  email: string;
+  name: string;
+  rolle: Rolle;
+  kundeId: string | null;
+  kundeName: string | null;
+  aktiv: boolean;
+  hatPasswort: boolean;
+  hatOidc: boolean;
+  passkeys: number;
+  letzterLoginAm: Date | null;
+}
+
+const LEER: AktionsErgebnis = {};
+const ROLLEN: Rolle[] = ["ADMIN", "TECHNIKER", "KUNDE"];
+
+function RollenFelder({
+  eintrag,
+  kunden,
+  fehler,
+}: {
+  eintrag?: BenutzerZeile;
+  kunden: { id: string; name: string }[];
+  fehler: Record<string, string>;
+}) {
+  const [rolle, setRolle] = useState<Rolle>(eintrag?.rolle ?? "TECHNIKER");
+
+  return (
+    <>
+      <div className="col-12 col-md-3">
+        <label className="form-label" htmlFor={`rolle-${eintrag?.id ?? "neu"}`}>
+          Rolle
+        </label>
+        <select
+          className="form-select"
+          id={`rolle-${eintrag?.id ?? "neu"}`}
+          name="rolle"
+          defaultValue={rolle}
+          onChange={(e) => setRolle(e.target.value as Rolle)}
+        >
+          {ROLLEN.map((wert) => (
+            <option key={wert} value={wert}>
+              {ROLLEN_TEXT[wert]}
+            </option>
+          ))}
+        </select>
+        <div className="form-text">{ROLLEN_BESCHREIBUNG[rolle]}</div>
+      </div>
+
+      {/* Der Kunde zählt nur für ein Kundenkonto – deshalb erscheint das Feld auch nur dann. */}
+      {rolle === "KUNDE" ? (
+        <div className="col-12 col-md-3">
+          <label className="form-label" htmlFor={`kunde-${eintrag?.id ?? "neu"}`}>
+            Kunde
+          </label>
+          <select
+            className="form-select"
+            id={`kunde-${eintrag?.id ?? "neu"}`}
+            name="kundeId"
+            defaultValue={eintrag?.kundeId ?? ""}
+          >
+            <option value="">– bitte wählen –</option>
+            {kunden.map((kunde) => (
+              <option key={kunde.id} value={kunde.id}>
+                {kunde.name}
+              </option>
+            ))}
+          </select>
+          {fehler.kundeId ? <div className="invalid-feedback d-block">{fehler.kundeId}</div> : null}
+        </div>
+      ) : null}
+    </>
+  );
+}
+
+function NeuFormular({ kunden }: { kunden: { id: string; name: string }[] }) {
+  const [ergebnis, aktion, laeuft] = useActionState(benutzerAnlegen, LEER);
+  const fehler = ergebnis.felder ?? {};
+
+  return (
+    <Card titel="Benutzer anlegen" rahmen="primary">
+      <form action={aktion} className="row g-3 align-items-start">
+        {ergebnis.fehler ? <div className="alert alert-danger">{ergebnis.fehler}</div> : null}
+        {ergebnis.erfolg ? <div className="alert alert-success">{ergebnis.erfolg}</div> : null}
+
+        <div className="col-12 col-md-3">
+          <label className="form-label" htmlFor="neu-name">
+            Name
+          </label>
+          <input className="form-control" id="neu-name" name="name" required />
+          {fehler.name ? <div className="invalid-feedback d-block">{fehler.name}</div> : null}
+        </div>
+
+        <div className="col-12 col-md-3">
+          <label className="form-label" htmlFor="neu-email">
+            E-Mail
+          </label>
+          <input type="email" className="form-control" id="neu-email" name="email" required />
+          {fehler.email ? <div className="invalid-feedback d-block">{fehler.email}</div> : null}
+        </div>
+
+        <RollenFelder kunden={kunden} fehler={fehler} />
+
+        <div className="col-12 col-md-3">
+          <label className="form-label" htmlFor="neu-passwort">
+            Passwort
+          </label>
+          <input
+            type="password"
+            className="form-control"
+            id="neu-passwort"
+            name="passwort"
+            minLength={PASSWORT_MINDESTLAENGE}
+            autoComplete="new-password"
+          />
+          <div className="form-text">
+            Leer lassen, wenn sich das Konto nur über OIDC oder einen Passkey anmelden soll.
+          </div>
+          {fehler.passwort ? <div className="invalid-feedback d-block">{fehler.passwort}</div> : null}
+        </div>
+
+        <div className="col-12">
+          <button type="submit" className="btn btn-primary" disabled={laeuft}>
+            {laeuft ? "Wird angelegt …" : "Benutzer anlegen"}
+          </button>
+        </div>
+      </form>
+    </Card>
+  );
+}
+
+function Zeile({
+  eintrag,
+  kunden,
+  ichSelbst,
+}: {
+  eintrag: BenutzerZeile;
+  kunden: { id: string; name: string }[];
+  ichSelbst: boolean;
+}) {
+  const [ergebnis, aktion, laeuft] = useActionState(benutzerSpeichern, LEER);
+  const [offen, setOffen] = useState(false);
+  const fehler = ergebnis.felder ?? {};
+
+  const anmeldewege = [
+    eintrag.hatPasswort ? "Passwort" : null,
+    eintrag.hatOidc ? "OIDC" : null,
+    eintrag.passkeys > 0 ? `${eintrag.passkeys} Passkey${eintrag.passkeys === 1 ? "" : "s"}` : null,
+  ].filter(Boolean);
+
+  return (
+    <>
+      <tr>
+        <td>
+          <button type="button" className="btn btn-link p-0 text-start" onClick={() => setOffen(!offen)}>
+            <span className="fw-semibold">{eintrag.name}</span>
+          </button>
+          {ichSelbst ? <span className="badge text-bg-secondary ms-2">Sie</span> : null}
+          <div className="small text-body-secondary">{eintrag.email}</div>
+        </td>
+        <td>
+          {ROLLEN_TEXT[eintrag.rolle]}
+          {eintrag.kundeName ? <div className="small text-body-secondary">{eintrag.kundeName}</div> : null}
+        </td>
+        <td className="small">
+          {anmeldewege.length > 0 ? anmeldewege.join(" · ") : <span className="text-danger">kein Zugang</span>}
+        </td>
+        <td className="small">
+          {eintrag.letzterLoginAm ? formatDatumZeit(eintrag.letzterLoginAm) : "noch nie"}
+        </td>
+        <td>
+          {eintrag.aktiv ? (
+            <span className="badge text-bg-success">aktiv</span>
+          ) : (
+            <span className="badge text-bg-danger">gesperrt</span>
+          )}
+        </td>
+        <td className="text-end">
+          <div className="d-flex gap-2 justify-content-end">
+            <button type="button" className="btn btn-sm btn-outline-secondary" onClick={() => setOffen(!offen)}>
+              {offen ? "Schließen" : "Bearbeiten"}
+            </button>
+            {!ichSelbst ? (
+              <>
+                <form action={benutzerSperreUmschalten}>
+                  <input type="hidden" name="id" value={eintrag.id} />
+                  <button type="submit" className="btn btn-sm btn-outline-warning">
+                    {eintrag.aktiv ? "Sperren" : "Freigeben"}
+                  </button>
+                </form>
+                <form action={benutzerLoeschen}>
+                  <input type="hidden" name="id" value={eintrag.id} />
+                  <button type="submit" className="btn btn-sm btn-outline-danger">
+                    Löschen
+                  </button>
+                </form>
+              </>
+            ) : null}
+          </div>
+        </td>
+      </tr>
+
+      {offen ? (
+        <tr>
+          <td colSpan={6} className="bg-body-tertiary">
+            <form action={aktion} className="row g-3 align-items-start">
+              <input type="hidden" name="id" value={eintrag.id} />
+              {ergebnis.fehler ? <div className="alert alert-danger">{ergebnis.fehler}</div> : null}
+              {ergebnis.erfolg ? <div className="alert alert-success">{ergebnis.erfolg}</div> : null}
+
+              <div className="col-12 col-md-3">
+                <label className="form-label" htmlFor={`name-${eintrag.id}`}>
+                  Name
+                </label>
+                <input className="form-control" id={`name-${eintrag.id}`} name="name" defaultValue={eintrag.name} />
+              </div>
+
+              <div className="col-12 col-md-3">
+                <label className="form-label" htmlFor={`email-${eintrag.id}`}>
+                  E-Mail
+                </label>
+                <input
+                  type="email"
+                  className="form-control"
+                  id={`email-${eintrag.id}`}
+                  name="email"
+                  defaultValue={eintrag.email}
+                />
+              </div>
+
+              <RollenFelder eintrag={eintrag} kunden={kunden} fehler={fehler} />
+
+              <div className="col-12 col-md-3">
+                <label className="form-label" htmlFor={`passwort-${eintrag.id}`}>
+                  Neues Passwort
+                </label>
+                <input
+                  type="password"
+                  className="form-control"
+                  id={`passwort-${eintrag.id}`}
+                  name="passwort"
+                  minLength={PASSWORT_MINDESTLAENGE}
+                  autoComplete="new-password"
+                />
+                <div className="form-text">Leer lassen heißt: unverändert. Ein neues beendet alle Sitzungen.</div>
+              </div>
+
+              <div className="col-12">
+                <button type="submit" className="btn btn-primary" disabled={laeuft}>
+                  {laeuft ? "Wird gespeichert …" : "Speichern"}
+                </button>
+              </div>
+            </form>
+          </td>
+        </tr>
+      ) : null}
+    </>
+  );
+}
+
+export function BenutzerVerwaltung({
+  benutzer,
+  kunden,
+  ichId,
+}: {
+  benutzer: BenutzerZeile[];
+  kunden: { id: string; name: string }[];
+  ichId: string;
+}) {
+  return (
+    <>
+      <NeuFormular kunden={kunden} />
+
+      <Card titel={`Benutzer (${benutzer.length})`} rahmen="keiner">
+        <div className="table-responsive">
+          <table className="table align-middle">
+            <thead>
+              <tr>
+                <th scope="col">Name</th>
+                <th scope="col">Rolle</th>
+                <th scope="col">Anmeldung</th>
+                <th scope="col">Zuletzt angemeldet</th>
+                <th scope="col">Zustand</th>
+                <th scope="col" className="text-end">
+                  Aktionen
+                </th>
+              </tr>
+            </thead>
+            <tbody>
+              {benutzer.map((eintrag) => (
+                <Zeile key={eintrag.id} eintrag={eintrag} kunden={kunden} ichSelbst={eintrag.id === ichId} />
+              ))}
+            </tbody>
+          </table>
+        </div>
+      </Card>
+    </>
+  );
+}

src/components/einstellungen/SystemFormular.tsx

@@ -0,0 +1,358 @@
+"use client";
+
+import { useActionState } from "react";
+import { Card } from "@/components/ui/Card";
+import { type AktionsErgebnis, einstellungenSpeichernAktion } from "@/server/actions/einstellungen";
+import type { Einstellungen } from "@/server/einstellungen";
+
+const LEER: AktionsErgebnis = {};
+
+function Feld({
+  name,
+  beschriftung,
+  hinweis,
+  fehler,
+  children,
+}: {
+  name: string;
+  beschriftung: string;
+  hinweis?: string;
+  fehler?: string;
+  children: React.ReactNode;
+}) {
+  return (
+    <div className="mb-3">
+      <label className="form-label" htmlFor={name}>
+        {beschriftung}
+      </label>
+      {children}
+      {hinweis ? <div className="form-text">{hinweis}</div> : null}
+      {fehler ? <div className="invalid-feedback d-block">{fehler}</div> : null}
+    </div>
+  );
+}
+
+export function SystemFormular({ werte, appUrl }: { werte: Einstellungen; appUrl: string }) {
+  const [ergebnis, aktion, laeuft] = useActionState(einstellungenSpeichernAktion, LEER);
+  const fehler = ergebnis.felder ?? {};
+
+  return (
+    <form action={aktion}>
+      {ergebnis.fehler ? <div className="alert alert-danger">{ergebnis.fehler}</div> : null}
+      {ergebnis.erfolg ? <div className="alert alert-success">{ergebnis.erfolg}</div> : null}
+
+      <div className="row g-4">
+        <div className="col-12 col-xl-6">
+          <Card titel="Adresse und Agent" rahmen="primary">
+            <Feld
+              name="dashboardUrl"
+              beschriftung="Adresse des Dashboards"
+              hinweis={`Steht im Installations-Einzeiler und in Benachrichtigungen. Leer lassen heißt: aus der Umgebung (${appUrl || "nicht gesetzt"}).`}
+              fehler={fehler.dashboardUrl}
+            >
+              <input
+                type="url"
+                className="form-control"
+                id="dashboardUrl"
+                name="dashboardUrl"
+                defaultValue={werte.dashboardUrl}
+                placeholder="https://proxledger.example.de"
+              />
+            </Feld>
+
+            <Feld
+              name="agentRhythmus"
+              beschriftung="Wie oft meldet ein Host?"
+              hinweis="Gilt für neu installierte Agents; bestehende übernehmen es bei der nächsten Installation."
+            >
+              <select className="form-select" id="agentRhythmus" name="agentRhythmus" defaultValue={werte.agentRhythmus}>
+                <option value="taeglich">täglich</option>
+                <option value="zwoelfstuendlich">alle 12 Stunden</option>
+                <option value="stuendlich">stündlich</option>
+              </select>
+            </Feld>
+
+            <Feld
+              name="agentStreuungStunden"
+              beschriftung="Zufällige Verzögerung (Stunden)"
+              hinweis="Verteilt die Meldungen, damit nicht alle Hosts gleichzeitig anklopfen."
+              fehler={fehler.agentStreuungStunden}
+            >
+              <input
+                type="number"
+                min={0}
+                max={12}
+                className="form-control"
+                id="agentStreuungStunden"
+                name="agentStreuungStunden"
+                defaultValue={werte.agentStreuungStunden}
+              />
+            </Feld>
+
+            <div className="form-check">
+              <input
+                type="checkbox"
+                className="form-check-input pl-touch-target"
+                id="agentAutoUpdate"
+                name="agentAutoUpdate"
+                value="an"
+                defaultChecked={werte.agentAutoUpdate}
+              />
+              <label className="form-check-label" htmlFor="agentAutoUpdate">
+                Agents dürfen sich selbst aktualisieren
+              </label>
+              <div className="form-text">
+                Der Agent lädt bei einer neueren Fassung das Skript vom Dashboard nach.
+              </div>
+            </div>
+          </Card>
+        </div>
+
+        <div className="col-12 col-xl-6">
+          <Card titel="Kaufmännisches" rahmen="info">
+            <Feld name="waehrung" beschriftung="Währung">
+              <select className="form-select" id="waehrung" name="waehrung" defaultValue={werte.waehrung}>
+                <option value="EUR">Euro (€)</option>
+                <option value="CHF">Schweizer Franken (CHF)</option>
+              </select>
+            </Feld>
+
+            <Feld
+              name="steuersatz"
+              beschriftung="Steuersatz in Prozent"
+              hinweis="Vorgabe für neue Rechnungspositionen."
+              fehler={fehler.steuersatz}
+            >
+              <input
+                type="number"
+                step="0.1"
+                min={0}
+                max={100}
+                className="form-control"
+                id="steuersatz"
+                name="steuersatz"
+                defaultValue={werte.steuersatz}
+              />
+            </Feld>
+
+            <Feld
+              name="zahlungszielTage"
+              beschriftung="Zahlungsziel in Tagen"
+              hinweis="Setzt das Fälligkeitsdatum neuer Rechnungen vor."
+              fehler={fehler.zahlungszielTage}
+            >
+              <input
+                type="number"
+                min={0}
+                max={120}
+                className="form-control"
+                id="zahlungszielTage"
+                name="zahlungszielTage"
+                defaultValue={werte.zahlungszielTage}
+              />
+            </Feld>
+
+            <Feld
+              name="margeProzent"
+              beschriftung="Aufschlag in Prozent"
+              hinweis="Vorschlag für den Verkaufspreis, ausgehend vom Einkaufspreis bei Proxmox."
+              fehler={fehler.margeProzent}
+            >
+              <input
+                type="number"
+                step="0.5"
+                min={0}
+                max={500}
+                className="form-control"
+                id="margeProzent"
+                name="margeProzent"
+                defaultValue={werte.margeProzent}
+              />
+            </Feld>
+          </Card>
+        </div>
+
+        <div className="col-12 col-xl-6">
+          <Card titel="Sicherheit" rahmen="danger">
+            <Feld
+              name="sitzungsdauerStunden"
+              beschriftung="Sitzungsdauer in Stunden"
+              hinweis="Nach dieser Zeit ist eine neue Anmeldung nötig."
+              fehler={fehler.sitzungsdauerStunden}
+            >
+              <input
+                type="number"
+                min={1}
+                max={168}
+                className="form-control"
+                id="sitzungsdauerStunden"
+                name="sitzungsdauerStunden"
+                defaultValue={werte.sitzungsdauerStunden}
+              />
+            </Feld>
+
+            <Feld
+              name="anmeldeversuche"
+              beschriftung="Anmeldeversuche je Viertelstunde"
+              fehler={fehler.anmeldeversuche}
+            >
+              <input
+                type="number"
+                min={3}
+                max={50}
+                className="form-control"
+                id="anmeldeversuche"
+                name="anmeldeversuche"
+                defaultValue={werte.anmeldeversuche}
+              />
+            </Feld>
+
+            <Feld
+              name="oidcDomaenen"
+              beschriftung="Erlaubte E-Mail-Domänen für OIDC"
+              hinweis="Mehrere durch Komma trennen, etwa „wilde-server.de, kunde.de“. Leer heißt: alle."
+            >
+              <input
+                type="text"
+                className="form-control"
+                id="oidcDomaenen"
+                name="oidcDomaenen"
+                defaultValue={werte.oidcDomaenen}
+                placeholder="firma.de"
+              />
+            </Feld>
+
+            <div className="form-check mb-3">
+              <input
+                type="checkbox"
+                className="form-check-input pl-touch-target"
+                id="oidcKontenAnlegen"
+                name="oidcKontenAnlegen"
+                value="an"
+                defaultChecked={werte.oidcKontenAnlegen}
+              />
+              <label className="form-check-label" htmlFor="oidcKontenAnlegen">
+                Unbekannte OIDC-Anmeldungen legen ein Konto an
+              </label>
+              <div className="form-text">
+                Aus heißt: Nur wer hier schon ein Konto hat, kommt herein – auch wenn die Anmeldung
+                beim Identitätsanbieter klappt.
+              </div>
+            </div>
+
+            <Feld
+              name="oidcStandardRolle"
+              beschriftung="Rolle für neue OIDC-Konten"
+              hinweis="Gilt nur für Konten, die bei der ersten Anmeldung automatisch entstehen."
+            >
+              <select
+                className="form-select"
+                id="oidcStandardRolle"
+                name="oidcStandardRolle"
+                defaultValue={werte.oidcStandardRolle}
+              >
+                <option value="TECHNIKER">Techniker</option>
+                <option value="KUNDE">Kunde</option>
+                <option value="ADMIN">Administrator</option>
+              </select>
+            </Feld>
+
+            <Feld
+              name="aufbewahrungReportsTage"
+              beschriftung="Reports aufbewahren (Tage)"
+              hinweis="0 heißt: unbegrenzt. Der aktuelle Stand jedes Hosts bleibt immer erhalten."
+              fehler={fehler.aufbewahrungReportsTage}
+            >
+              <input
+                type="number"
+                min={0}
+                max={3650}
+                className="form-control"
+                id="aufbewahrungReportsTage"
+                name="aufbewahrungReportsTage"
+                defaultValue={werte.aufbewahrungReportsTage}
+              />
+            </Feld>
+
+            <Feld
+              name="aufbewahrungAuditTage"
+              beschriftung="Protokoll aufbewahren (Tage)"
+              hinweis="0 heißt: unbegrenzt."
+              fehler={fehler.aufbewahrungAuditTage}
+            >
+              <input
+                type="number"
+                min={0}
+                max={3650}
+                className="form-control"
+                id="aufbewahrungAuditTage"
+                name="aufbewahrungAuditTage"
+                defaultValue={werte.aufbewahrungAuditTage}
+              />
+            </Feld>
+          </Card>
+        </div>
+
+        <div className="col-12 col-xl-6">
+          <Card titel="Firma und Darstellung" rahmen="keiner">
+            <Feld
+              name="firmaName"
+              beschriftung="Firmenname"
+              hinweis="Erscheint im Kopf der erzeugten PDF-Rechnungen."
+            >
+              <input
+                type="text"
+                className="form-control"
+                id="firmaName"
+                name="firmaName"
+                defaultValue={werte.firmaName}
+              />
+            </Feld>
+
+            <Feld name="firmaAnschrift" beschriftung="Anschrift">
+              <textarea
+                className="form-control"
+                id="firmaAnschrift"
+                name="firmaAnschrift"
+                rows={3}
+                defaultValue={werte.firmaAnschrift}
+              />
+            </Feld>
+
+            <Feld name="firmaEmail" beschriftung="E-Mail-Adresse" fehler={fehler.firmaEmail}>
+              <input
+                type="email"
+                className="form-control"
+                id="firmaEmail"
+                name="firmaEmail"
+                defaultValue={werte.firmaEmail}
+              />
+            </Feld>
+
+            <Feld
+              name="zeitzone"
+              beschriftung="Zeitzone"
+              hinweis="Gilt für PDF, CSV-Ausgaben und Benachrichtigungen."
+              fehler={fehler.zeitzone}
+            >
+              <input
+                type="text"
+                className="form-control"
+                id="zeitzone"
+                name="zeitzone"
+                defaultValue={werte.zeitzone}
+                placeholder="Europe/Berlin"
+              />
+            </Feld>
+          </Card>
+        </div>
+      </div>
+
+      <div className="mb-4">
+        <button type="submit" className="btn btn-primary" disabled={laeuft}>
+          {laeuft ? "Wird gespeichert …" : "Einstellungen speichern"}
+        </button>
+      </div>
+    </form>
+  );
+}

src/components/layout/Header.tsx

@@ -3,6 +3,8 @@
 import Link from "next/link";
 import { useCallback, useEffect, useState, useSyncExternalStore } from "react";
 import { SearchDialog, type SuchEintrag } from "./SearchDialog";
+import type { Rolle } from "@/generated/prisma/enums";
+import { ROLLEN_TEXT } from "@/server/auth/rollen";
 
 export interface KopfleistenAlert {
   id: string;
@@ -33,10 +35,12 @@ export function Header({
   alerts,
   suchEintraege,
   benutzer,
+  rolle,
 }: {
   alerts: KopfleistenAlert[];
   suchEintraege: SuchEintrag[];
   benutzer: string;
+  rolle: Rolle;
 }) {
   const [sucheOffen, setSucheOffen] = useState(false);
   const [glockeOffen, setGlockeOffen] = useState(false);
@@ -209,10 +213,12 @@ export function Header({
               <span className="d-none d-sm-inline">{benutzer}</span>
             </button>
             <div className={`dropdown-menu dropdown-menu-end shadow ${benutzerOffen ? "show" : ""}`}>
-              <span className="dropdown-header">Angemeldet als {benutzer}</span>
+              <span className="dropdown-header">
+                Angemeldet als {benutzer} · {ROLLEN_TEXT[rolle]}
+              </span>
               <div className="dropdown-divider" />
-              <Link href="/einstellungen/system" className="dropdown-item">
+              <Link href="/einstellungen/passkeys" className="dropdown-item">
-                Einstellungen
+                Meine Passkeys
               </Link>
               <a className="dropdown-item" href="/api/auth/abmelden">
                 Abmelden

src/components/layout/Sidebar.tsx

@@ -4,6 +4,8 @@ import Link from "next/link";
 import { usePathname, useRouter } from "next/navigation";
 import { useState } from "react";
 import { LogoMitSchriftzug } from "@/components/Logo";
+import type { Rolle } from "@/generated/prisma/enums";
+import { darf } from "@/server/auth/rollen";
 
 interface MenuEintrag {
   href: string;
@@ -17,11 +19,13 @@ export function Sidebar({
   offeneRechnungspunkte,
   offeneWarnungen,
   benutzer,
+  rolle,
 }: {
   hostsAnzahl: number;
   offeneRechnungspunkte: number;
   offeneWarnungen: number;
   benutzer: string;
+  rolle: Rolle;
 }) {
   const pathname = usePathname();
   const router = useRouter();
@@ -35,7 +39,7 @@ export function Sidebar({
       icon: "bi-hdd-stack",
       badge: { text: String(hostsAnzahl), klasse: "pl-bg-info" },
     },
-    { href: "/kunden", titel: "Kunden", icon: "bi-people" },
+    ...(rolle === "KUNDE" ? [] : [{ href: "/kunden", titel: "Kunden", icon: "bi-people" }]),
     {
       href: "/rechnungen",
       titel: "Rechnungen",
@@ -54,12 +58,24 @@ export function Sidebar({
     },
   ];
 
+  // Das Menü zeigt nur, was die Rolle auch darf. Der Schutz liegt trotzdem in den Seiten
+  // und Aktionen selbst – ein ausgeblendeter Eintrag ist keine Zugriffskontrolle (#027).
   const einstellungen: MenuEintrag[] = [
-    { href: "/einstellungen/tokens", titel: "Agent-Tokens", icon: "bi-key" },
+    ...(darf(rolle, "betrieb")
-    { href: "/einstellungen/warnregeln", titel: "Warnregeln", icon: "bi-shield-exclamation" },
+      ? [
-    { href: "/einstellungen/benachrichtigungen", titel: "Benachrichtigungen", icon: "bi-bell" },
+          { href: "/einstellungen/tokens", titel: "Agent-Tokens", icon: "bi-key" },
-    { href: "/einstellungen/audit", titel: "Protokoll", icon: "bi-list-check" },
+          { href: "/einstellungen/warnregeln", titel: "Warnregeln", icon: "bi-shield-exclamation" },
-    { href: "/einstellungen/system", titel: "System", icon: "bi-sliders" },
+          { href: "/einstellungen/benachrichtigungen", titel: "Benachrichtigungen", icon: "bi-bell" },
+        ]
+      : []),
+    ...(darf(rolle, "verwaltung")
+      ? [
+          { href: "/einstellungen/benutzer", titel: "Benutzer", icon: "bi-person-gear" },
+          { href: "/einstellungen/audit", titel: "Protokoll", icon: "bi-list-check" },
+          { href: "/einstellungen/system", titel: "System", icon: "bi-sliders" },
+        ]
+      : []),
+    { href: "/einstellungen/passkeys", titel: "Meine Passkeys", icon: "bi-fingerprint" },
   ];
 
   function istAktiv(href: string) {

src/lib/adresse.ts

@@ -0,0 +1,45 @@
+/**
+ * Ermittelt die Adresse, unter der das Dashboard **von außen** erreichbar ist.
+ *
+ * Im Container ist `request.url` die interne Adresse (`http://<container-id>:3000`). Eine Weiterleitung
+ * dorthin führt im Browser ins Leere – genau das passierte nach der Anmeldung im Docker-Stapel.
+ *
+ * Reihenfolge: eingetragene Adresse → `APP_URL` → Kopfzeilen des Reverse Proxy → Anfrage selbst.
+ * Die Kopfzeilen stehen bewusst hinter den konfigurierten Werten: Sie kommen vom Client und lassen
+ * sich fälschen; für eine Weiterleitung auf die eigene Seite ist das unkritisch, als erste Wahl aber
+ * unnötig.
+ */
+export function oeffentlicheBasis(request: Request, eingetragen?: string): URL {
+  if (eingetragen) {
+    try {
+      return new URL(eingetragen);
+    } catch {
+      // Unbrauchbarer Eintrag: weiter mit den übrigen Quellen.
+    }
+  }
+
+  if (process.env.APP_URL) {
+    try {
+      return new URL(process.env.APP_URL);
+    } catch {
+      // ebenso
+    }
+  }
+
+  const gastgeber = request.headers.get("x-forwarded-host") ?? request.headers.get("host");
+  if (gastgeber) {
+    const schema = request.headers.get("x-forwarded-proto") ?? new URL(request.url).protocol.replace(":", "");
+    try {
+      return new URL(`${schema}://${gastgeber}`);
+    } catch {
+      // ebenso
+    }
+  }
+
+  return new URL(request.url);
+}
+
+/** Baut eine Adresse auf derselben Installation – für Weiterleitungen nach der Anmeldung. */
+export function eigeneAdresse(request: Request, pfad: string, eingetragen?: string): URL {
+  return new URL(pfad, oeffentlicheBasis(request, eingetragen));
+}

src/lib/geheimnisse.ts

@@ -0,0 +1,67 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "node:crypto";
+
+/**
+ * Verschlüsselt einzelne Werte (SMTP-Passwort, Webhook-Geheimnis) mit AES-256-GCM.
+ * Der Schlüssel wird aus `APP_SECRET` abgeleitet – wer eine Sicherung der Datenbank liest,
+ * bekommt damit noch keine Zugangsdaten.
+ *
+ * Format: `plx1:<nonce>:<authTag>:<chiffrat>`, alle Teile base64url.
+ * Werte ohne dieses Präfix gelten als Klartext aus der Zeit vor der Verschlüsselung und
+ * werden beim nächsten Speichern umgeschlüsselt.
+ */
+
+const PRAEFIX = "plx1";
+const SALZ = "proxledger-geheimnisse-v1";
+
+export class GeheimnisFehler extends Error {}
+
+function schluessel(): Buffer {
+  const geheimnis = process.env.APP_SECRET;
+  if (!geheimnis || geheimnis.length < 32) {
+    throw new GeheimnisFehler("APP_SECRET fehlt oder ist zu kurz (mindestens 32 Zeichen).");
+  }
+  return scryptSync(geheimnis, SALZ, 32);
+}
+
+export function verschluesseln(klartext: string): string {
+  if (klartext === "") return "";
+
+  const nonce = randomBytes(12);
+  const chiffre = createCipheriv("aes-256-gcm", schluessel(), nonce);
+  const daten = Buffer.concat([chiffre.update(klartext, "utf8"), chiffre.final()]);
+
+  return [
+    PRAEFIX,
+    nonce.toString("base64url"),
+    chiffre.getAuthTag().toString("base64url"),
+    daten.toString("base64url"),
+  ].join(":");
+}
+
+export function istVerschluesselt(wert: string): boolean {
+  return wert.startsWith(`${PRAEFIX}:`);
+}
+
+/**
+ * Entschlüsselt einen Wert. Unverschlüsselte Werte kommen unverändert zurück –
+ * so funktionieren bestehende Installationen ohne Wartungsschritt weiter.
+ */
+export function entschluesseln(wert: string): string {
+  if (!wert || !istVerschluesselt(wert)) return wert;
+
+  const [, nonce, authTag, daten] = wert.split(":");
+  if (!nonce || !authTag || !daten) {
+    throw new GeheimnisFehler("Der gespeicherte Wert ist unvollständig.");
+  }
+
+  try {
+    const chiffre = createDecipheriv("aes-256-gcm", schluessel(), Buffer.from(nonce, "base64url"));
+    chiffre.setAuthTag(Buffer.from(authTag, "base64url"));
+    return Buffer.concat([chiffre.update(Buffer.from(daten, "base64url")), chiffre.final()]).toString("utf8");
+  } catch {
+    // Häufigste Ursache: APP_SECRET wurde geändert.
+    throw new GeheimnisFehler(
+      "Der Wert lässt sich nicht entschlüsseln. Wurde APP_SECRET geändert? Dann die Zugangsdaten neu eintragen.",
+    );
+  }
+}

src/lib/passwort.ts

@@ -0,0 +1,2 @@
+/** Mindestlänge für Passwörter: lieber lang als kompliziert. */
+export const PASSWORT_MINDESTLAENGE = 12;

src/lib/sitzung.ts

@@ -6,14 +6,20 @@ import { SignJWT, jwtVerify } from "jose";
  */
 
 export const SITZUNGS_COOKIE = "pl_sitzung";
+/** Rückfall, solange nichts in den Einstellungen steht (#025). */
 export const SITZUNGSDAUER_STUNDEN = 12;
 
+/** Eine gelesene Sitzung weiß zusätzlich, wann sie ausgestellt wurde – nötig für den Widerruf. */
+export interface GeleseneSitzung extends Sitzung {
+  ausgestelltAm: Date;
+}
+
 export interface Sitzung {
   benutzerId: string;
   email: string;
   name: string;
   /** Woher die Anmeldung stammt – für das Audit-Log und die Anzeige. */
-  herkunft: "passwort" | "oidc";
+  herkunft: "passwort" | "oidc" | "passkey";
 }
 
 function schluessel(): Uint8Array {
@@ -26,18 +32,21 @@ function schluessel(): Uint8Array {
   return new TextEncoder().encode(geheimnis);
 }
 
-export async function sitzungErzeugen(sitzung: Sitzung): Promise<string> {
+export async function sitzungErzeugen(
+  sitzung: Sitzung,
+  dauerStunden: number = SITZUNGSDAUER_STUNDEN,
+): Promise<string> {
   return new SignJWT({ ...sitzung })
     .setProtectedHeader({ alg: "HS256" })
     .setSubject(sitzung.benutzerId)
     .setIssuedAt()
     .setIssuer("proxledger")
-    .setExpirationTime(`${SITZUNGSDAUER_STUNDEN}h`)
+    .setExpirationTime(`${dauerStunden}h`)
     .sign(schluessel());
 }
 
 /** Prüft das Token; bei ungültiger Signatur oder Ablauf kommt null zurück. */
-export async function sitzungLesen(token: string | undefined): Promise<Sitzung | null> {
+export async function sitzungLesen(token: string | undefined): Promise<GeleseneSitzung | null> {
   if (!token) return null;
   try {
     const { payload } = await jwtVerify(token, schluessel(), { issuer: "proxledger" });
@@ -46,7 +55,9 @@ export async function sitzungLesen(token: string | undefined): Promise<Sitzung |
       benutzerId: payload.benutzerId,
       email: payload.email,
       name: typeof payload.name === "string" ? payload.name : payload.email,
-      herkunft: payload.herkunft === "oidc" ? "oidc" : "passwort",
+      herkunft:
+        payload.herkunft === "oidc" || payload.herkunft === "passkey" ? payload.herkunft : "passwort",
+      ausgestelltAm: new Date((payload.iat ?? 0) * 1000),
     };
   } catch {
     return null;
@@ -64,12 +75,12 @@ export function ueberHttps(): boolean {
   return process.env.NODE_ENV === "production";
 }
 
-export function cookieOptionen() {
+export function cookieOptionen(dauerStunden: number = SITZUNGSDAUER_STUNDEN) {
   return {
     httpOnly: true,
     sameSite: "lax" as const,
     secure: ueberHttps(),
     path: "/",
-    maxAge: SITZUNGSDAUER_STUNDEN * 3600,
+    maxAge: dauerStunden * 3600,
   };
 }

src/proxy.ts

@@ -23,19 +23,62 @@ const OEFFENTLICH = [
   "/manifest.webmanifest",
 ];
 
+/**
+ * Content-Security-Policy je Anfrage, mit frischem Nonce.
+ *
+ * `strict-dynamic` heißt: Nur Skripte mit diesem Nonce dürfen laufen (und was sie selbst nachladen).
+ * Damit läuft eingeschleustes `<script>` aus der Datenbank oder einer Proxmox-Ausgabe nicht mehr –
+ * die zweite Verteidigungslinie hinter der Maskierung durch React (OWASP A03).
+ *
+ * `style-src` erlaubt bewusst `unsafe-inline`: Bootstrap und AdminLTE setzen Stile direkt am Element,
+ * und ein Stil kann keinen Code ausführen.
+ */
+function richtlinie(nonce: string): string {
+  const entwicklung = process.env.NODE_ENV !== "production";
+  return [
+    "default-src 'self'",
+    // In der Entwicklung braucht der Hot-Reload eval; im Betrieb nicht.
+    `script-src 'self' 'nonce-${nonce}' 'strict-dynamic'${entwicklung ? " 'unsafe-eval'" : ""}`,
+    "style-src 'self' 'unsafe-inline'",
+    "img-src 'self' data:",
+    "font-src 'self'",
+    // Verbindungen nur zur eigenen Herkunft; in der Entwicklung zusätzlich der Hot-Reload.
+    `connect-src 'self'${entwicklung ? " ws: wss:" : ""}`,
+    "object-src 'none'",
+    "base-uri 'self'",
+    "form-action 'self'",
+    "frame-ancestors 'none'",
+    ...(entwicklung ? [] : ["upgrade-insecure-requests"]),
+  ].join("; ");
+}
+
+function mitRichtlinie(request: NextRequest, antwort?: NextResponse): NextResponse {
+  const nonce = crypto.randomUUID().replaceAll("-", "");
+  const csp = richtlinie(nonce);
+
+  // Next.js versieht seine eigenen Skripte mit diesem Nonce, sobald es ihn in der Anfrage findet.
+  const kopfzeilen = new Headers(request.headers);
+  kopfzeilen.set("x-nonce", nonce);
+  kopfzeilen.set("Content-Security-Policy", csp);
+
+  const ergebnis = antwort ?? NextResponse.next({ request: { headers: kopfzeilen } });
+  ergebnis.headers.set("Content-Security-Policy", csp);
+  return ergebnis;
+}
+
 export async function proxy(request: NextRequest) {
   const pfad = request.nextUrl.pathname;
 
   if (OEFFENTLICH.some((eintrag) => pfad === eintrag || pfad.startsWith(`${eintrag}/`))) {
-    return NextResponse.next();
+    return mitRichtlinie(request);
   }
 
   const sitzung = await sitzungLesen(request.cookies.get(SITZUNGS_COOKIE)?.value);
-  if (sitzung) return NextResponse.next();
+  if (sitzung) return mitRichtlinie(request);
 
   const ziel = new URL("/login", request.url);
   if (pfad !== "/") ziel.searchParams.set("ziel", `${pfad}${request.nextUrl.search}`);
-  return NextResponse.redirect(ziel);
+  return mitRichtlinie(request, NextResponse.redirect(ziel));
 }
 
 export const config = {

src/server/actions/alerts.ts

@@ -3,6 +3,7 @@
 import { revalidatePath } from "next/cache";
 import { prisma } from "@/lib/db";
 import { protokolliere } from "@/server/audit";
+import { sichtbarerKunde, sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { alertsAbgleichen } from "@/server/alerts/abgleich";
 import { REGELN } from "@/server/alerts/regeln";
 import type { AktionsErgebnis } from "./kunden";
@@ -15,16 +16,26 @@ function neuLaden() {
 
 /** Warnung quittieren: sie bleibt offen, ist aber als gesehen markiert. */
 export async function alertQuittieren(formular: FormData) {
+  await sitzungErforderlich("mitarbeiten");
   const id = formular.get("id")?.toString();
   if (!id) return;
 
-  await prisma.alert.update({ where: { id }, data: { quittiertAm: new Date() } });
+  // Ein Kundenkonto darf nur eigene Warnungen quittieren. Bedingung und Schreiben in einem
+  // Schritt: So kann zwischen Prüfung und Änderung nichts dazwischenkommen.
+  const nurKunde = await sichtbarerKunde();
+  const ergebnis = await prisma.alert.updateMany({
+    where: { id, ...(nurKunde ? { host: { kundeId: nurKunde } } : {}) },
+    data: { quittiertAm: new Date() },
+  });
+  if (ergebnis.count === 0) return;
+
   await protokolliere("alert.quittiert", "Alert", id, {});
   neuLaden();
 }
 
 /** Warnung von Hand schließen; taucht der Fall weiter auf, öffnet der nächste Abgleich sie erneut. */
 export async function alertSchliessen(formular: FormData) {
+  await sitzungErforderlich("fachlichSchreiben");
   const id = formular.get("id")?.toString();
   if (!id) return;
 
@@ -35,6 +46,7 @@ export async function alertSchliessen(formular: FormData) {
 
 /** Auswertung sofort anstoßen, ohne auf den Worker zu warten. */
 export async function alertsJetztPruefen(): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("betrieb");
   const ergebnis = await alertsAbgleichen();
   neuLaden();
   return {
@@ -47,6 +59,7 @@ export async function warnregelnSpeichern(
   _vorher: AktionsErgebnis,
   formular: FormData,
 ): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("betrieb");
   for (const regel of REGELN) {
     const aktiv = formular.get(`aktiv:${regel.name}`) === "on";
     const schwellwerte: Record<string, number | number[]> = {};

src/server/actions/benachrichtigungen.ts

@@ -2,7 +2,9 @@
 
 import { revalidatePath } from "next/cache";
 import { prisma } from "@/lib/db";
+import { verschluesseln } from "@/lib/geheimnisse";
 import { protokolliere } from "@/server/audit";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import type { EmailKonfiguration, WebhookKonfiguration } from "@/server/notifications/kanaele";
 import { testNachricht } from "@/server/notifications/nachrichten";
 import { ueberEinenKanalSenden, zusammenfassungSenden } from "@/server/notifications/versand";
@@ -21,6 +23,7 @@ export async function emailKanalSpeichern(
   _vorher: AktionsErgebnis,
   formular: FormData,
 ): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("betrieb");
   const id = formular.get("id")?.toString() || null;
   const host = formular.get("host")?.toString().trim() ?? "";
   const port = Number(formular.get("port") ?? 587);
@@ -45,8 +48,9 @@ export async function emailKanalSpeichern(
     port,
     secure: port === 465,
     benutzer: formular.get("benutzer")?.toString().trim() ?? "",
-    // Leeres Feld heißt „unverändert“ – so muss das Passwort nicht erneut eingegeben werden.
+    // Leeres Feld heißt „unverändert“; das gespeicherte Passwort bleibt dann wie es ist.
-    passwort: passwortEingabe || (bisher?.passwort ?? ""),
+    // Neue Eingaben werden verschlüsselt abgelegt (#021).
+    passwort: passwortEingabe ? verschluesseln(passwortEingabe) : (bisher?.passwort ?? ""),
     absender: formular.get("absender")?.toString().trim() ?? "",
     empfaenger,
   };
@@ -76,6 +80,7 @@ export async function webhookKanalSpeichern(
   _vorher: AktionsErgebnis,
   formular: FormData,
 ): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("betrieb");
   const id = formular.get("id")?.toString() || null;
   const url = formular.get("url")?.toString().trim() ?? "";
 
@@ -90,7 +95,7 @@ export async function webhookKanalSpeichern(
 
   const konfiguration: WebhookKonfiguration = {
     url,
-    geheimnis: geheimnisEingabe || bisher?.geheimnis,
+    geheimnis: geheimnisEingabe ? verschluesseln(geheimnisEingabe) : bisher?.geheimnis,
   };
 
   const daten = {
@@ -114,6 +119,7 @@ export async function webhookKanalSpeichern(
 }
 
 export async function kanalLoeschen(formular: FormData) {
+  await sitzungErforderlich("betrieb");
   const id = formular.get("id")?.toString();
   if (!id) return;
 
@@ -124,6 +130,7 @@ export async function kanalLoeschen(formular: FormData) {
 
 /** Verschickt eine Testnachricht über einen Kanal. */
 export async function testSenden(formular: FormData): Promise<void> {
+  await sitzungErforderlich("betrieb");
   const id = formular.get("id")?.toString();
   if (!id) return;
 
@@ -138,6 +145,7 @@ export async function testSenden(formular: FormData): Promise<void> {
 
 /** Zeitraum der Zusammenfassung speichern (täglich, wöchentlich oder aus). */
 export async function zusammenfassungSpeichern(formular: FormData) {
+  await sitzungErforderlich("betrieb");
   const zeitraum = formular.get("zeitraum")?.toString() ?? "aus";
 
   await prisma.einstellung.upsert({
@@ -152,6 +160,7 @@ export async function zusammenfassungSpeichern(formular: FormData) {
 
 /** Zusammenfassung sofort verschicken – praktisch zum Ausprobieren. */
 export async function zusammenfassungJetztSenden(formular: FormData): Promise<void> {
+  await sitzungErforderlich("betrieb");
   const zeitraum = formular.get("zeitraum")?.toString() === "woechentlich" ? "woechentlich" : "taeglich";
   await zusammenfassungSenden(zeitraum);
   neuLaden();

src/server/actions/benutzer.ts

@@ -0,0 +1,165 @@
+"use server";
+
+import { hash } from "@node-rs/argon2";
+import { revalidatePath } from "next/cache";
+import { z } from "zod";
+import { prisma } from "@/lib/db";
+import { PASSWORT_MINDESTLAENGE } from "@/lib/passwort";
+import { protokolliere } from "@/server/audit";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
+
+export interface AktionsErgebnis {
+  fehler?: string;
+  felder?: Record<string, string>;
+  erfolg?: string;
+}
+
+const benutzerSchema = z
+  .object({
+    email: z.string().email("Keine gültige E-Mail-Adresse."),
+    name: z.string().min(2, "Bitte einen Namen angeben."),
+    rolle: z.enum(["ADMIN", "TECHNIKER", "KUNDE"]),
+    kundeId: z.string().nullable(),
+    passwort: z
+      .union([z.string().min(PASSWORT_MINDESTLAENGE, `Mindestens ${PASSWORT_MINDESTLAENGE} Zeichen.`), z.literal("")])
+      .default(""),
+  })
+  .refine((werte) => werte.rolle !== "KUNDE" || werte.kundeId !== null, {
+    message: "Ein Kundenkonto braucht einen Kunden.",
+    path: ["kundeId"],
+  });
+
+function felderAus(fehler: z.ZodError): Record<string, string> {
+  const felder: Record<string, string> = {};
+  for (const eintrag of fehler.issues) {
+    const feld = eintrag.path[0];
+    if (typeof feld === "string" && !felder[feld]) felder[feld] = eintrag.message;
+  }
+  return felder;
+}
+
+function lesen(formular: FormData) {
+  const rolle = formular.get("rolle")?.toString() ?? "TECHNIKER";
+  return {
+    email: formular.get("email")?.toString().trim().toLowerCase() ?? "",
+    name: formular.get("name")?.toString().trim() ?? "",
+    rolle,
+    // Der Kunde zählt nur bei einem Kundenkonto; sonst wird er bewusst verworfen.
+    kundeId: rolle === "KUNDE" ? formular.get("kundeId")?.toString() || null : null,
+    passwort: formular.get("passwort")?.toString() ?? "",
+  };
+}
+
+export async function benutzerAnlegen(
+  _vorher: AktionsErgebnis,
+  formular: FormData,
+): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("verwaltung");
+
+  const ergebnis = benutzerSchema.safeParse(lesen(formular));
+  if (!ergebnis.success) return { fehler: "Bitte die Angaben prüfen.", felder: felderAus(ergebnis.error) };
+
+  const { email, name, rolle, kundeId, passwort } = ergebnis.data;
+
+  if (await prisma.benutzer.findUnique({ where: { email } })) {
+    return { fehler: "Diese E-Mail-Adresse ist schon vergeben.", felder: { email: "Schon vergeben." } };
+  }
+
+  // Ohne Passwort entsteht ein Konto, das sich nur über OIDC oder einen Passkey anmelden kann.
+  await prisma.benutzer.create({
+    data: {
+      email,
+      name,
+      rolle,
+      kundeId,
+      passwortHash: passwort ? await hash(passwort) : null,
+    },
+  });
+
+  await protokolliere("benutzer.angelegt", "Benutzer", email, { rolle, kundeId, mitPasswort: Boolean(passwort) });
+  revalidatePath("/einstellungen/benutzer");
+
+  return { erfolg: `${name} wurde angelegt.` };
+}
+
+export async function benutzerSpeichern(
+  _vorher: AktionsErgebnis,
+  formular: FormData,
+): Promise<AktionsErgebnis> {
+  const ich = await sitzungErforderlich("verwaltung");
+
+  const id = formular.get("id")?.toString();
+  if (!id) return { fehler: "Benutzer nicht gefunden." };
+
+  const ergebnis = benutzerSchema.safeParse(lesen(formular));
+  if (!ergebnis.success) return { fehler: "Bitte die Angaben prüfen.", felder: felderAus(ergebnis.error) };
+
+  const { email, name, rolle, kundeId, passwort } = ergebnis.data;
+
+  // Wer sich selbst die Administratorrolle nimmt, sperrt sich aus der Verwaltung aus.
+  if (id === ich.benutzerId && rolle !== "ADMIN") {
+    return { fehler: "Die eigene Administratorrolle lässt sich nicht entziehen." };
+  }
+
+  const andere = await prisma.benutzer.findUnique({ where: { email } });
+  if (andere && andere.id !== id) {
+    return { fehler: "Diese E-Mail-Adresse gehört schon zu einem anderen Konto." };
+  }
+
+  await prisma.benutzer.update({
+    where: { id },
+    data: {
+      email,
+      name,
+      rolle,
+      kundeId,
+      // Ein neues Passwort beendet bestehende Sitzungen – sonst liefe ein geklautes Token weiter.
+      ...(passwort ? { passwortHash: await hash(passwort), sitzungenUngueltigAb: new Date() } : {}),
+    },
+  });
+
+  await protokolliere("benutzer.geaendert", "Benutzer", id, { rolle, kundeId, passwortGesetzt: Boolean(passwort) });
+  revalidatePath("/einstellungen/benutzer");
+
+  return { erfolg: "Gespeichert." };
+}
+
+export async function benutzerSperreUmschalten(formular: FormData) {
+  const ich = await sitzungErforderlich("verwaltung");
+
+  const id = formular.get("id")?.toString();
+  if (!id) return;
+  if (id === ich.benutzerId) return; // sich selbst auszusperren hilft niemandem
+
+  const benutzer = await prisma.benutzer.findUnique({ where: { id }, select: { aktiv: true } });
+  if (!benutzer) return;
+
+  await prisma.benutzer.update({
+    where: { id },
+    data: {
+      aktiv: !benutzer.aktiv,
+      // Beim Sperren laufende Sitzungen sofort beenden.
+      ...(benutzer.aktiv ? { sitzungenUngueltigAb: new Date() } : {}),
+    },
+  });
+
+  await protokolliere(benutzer.aktiv ? "benutzer.gesperrt" : "benutzer.freigegeben", "Benutzer", id, {});
+  revalidatePath("/einstellungen/benutzer");
+}
+
+export async function benutzerLoeschen(formular: FormData) {
+  const ich = await sitzungErforderlich("verwaltung");
+
+  const id = formular.get("id")?.toString();
+  if (!id || id === ich.benutzerId) return;
+
+  // Der letzte Administrator bleibt stehen – sonst kommt niemand mehr in die Verwaltung.
+  const admins = await prisma.benutzer.count({ where: { rolle: "ADMIN", aktiv: true } });
+  const betroffen = await prisma.benutzer.findUnique({ where: { id }, select: { rolle: true, email: true } });
+  if (!betroffen) return;
+  if (betroffen.rolle === "ADMIN" && admins <= 1) return;
+
+  await prisma.benutzer.delete({ where: { id } });
+  await protokolliere("benutzer.geloescht", "Benutzer", id, { email: betroffen.email });
+  revalidatePath("/einstellungen/benutzer");
+}

src/server/actions/einstellungen.ts

@@ -0,0 +1,76 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { protokolliere } from "@/server/audit";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
+import { einstellungen, einstellungenSchema, einstellungenSpeichern } from "@/server/einstellungen";
+
+export interface AktionsErgebnis {
+  fehler?: string;
+  felder?: Record<string, string>;
+  erfolg?: string;
+}
+
+const zahl = (formular: FormData, feld: string) => {
+  const roh = formular.get(feld)?.toString().replace(",", ".").trim();
+  return roh === undefined || roh === "" ? undefined : Number(roh);
+};
+
+const text = (formular: FormData, feld: string) => formular.get(feld)?.toString().trim() ?? "";
+const schalter = (formular: FormData, feld: string) => formular.get(feld) === "an";
+
+export async function einstellungenSpeichernAktion(
+  _zustand: AktionsErgebnis,
+  formular: FormData,
+): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("verwaltung");
+
+  const vorher = await einstellungen();
+
+  const ergebnis = einstellungenSchema.safeParse({
+    dashboardUrl: text(formular, "dashboardUrl"),
+    agentRhythmus: text(formular, "agentRhythmus") || vorher.agentRhythmus,
+    agentStreuungStunden: zahl(formular, "agentStreuungStunden"),
+    agentAutoUpdate: schalter(formular, "agentAutoUpdate"),
+
+    waehrung: text(formular, "waehrung") || vorher.waehrung,
+    steuersatz: zahl(formular, "steuersatz"),
+    zahlungszielTage: zahl(formular, "zahlungszielTage"),
+    margeProzent: zahl(formular, "margeProzent"),
+
+    sitzungsdauerStunden: zahl(formular, "sitzungsdauerStunden"),
+    anmeldeversuche: zahl(formular, "anmeldeversuche"),
+    oidcDomaenen: text(formular, "oidcDomaenen"),
+    oidcKontenAnlegen: schalter(formular, "oidcKontenAnlegen"),
+    oidcStandardRolle: text(formular, "oidcStandardRolle") || vorher.oidcStandardRolle,
+    aufbewahrungReportsTage: zahl(formular, "aufbewahrungReportsTage"),
+    aufbewahrungAuditTage: zahl(formular, "aufbewahrungAuditTage"),
+
+    firmaName: text(formular, "firmaName"),
+    firmaAnschrift: text(formular, "firmaAnschrift"),
+    firmaEmail: text(formular, "firmaEmail"),
+    zeitzone: text(formular, "zeitzone") || vorher.zeitzone,
+  });
+
+  if (!ergebnis.success) {
+    const felder: Record<string, string> = {};
+    for (const fehler of ergebnis.error.issues) {
+      const feld = fehler.path[0];
+      if (typeof feld === "string" && !felder[feld]) felder[feld] = fehler.message;
+    }
+    return { fehler: "Bitte die markierten Felder prüfen.", felder };
+  }
+
+  await einstellungenSpeichern(ergebnis.data);
+
+  // Nur die geänderten Felder ins Protokoll – sonst steht bei jedem Speichern alles darin.
+  const geaendert = Object.fromEntries(
+    Object.entries(ergebnis.data).filter(
+      ([feld, wert]) => wert !== vorher[feld as keyof typeof vorher],
+    ),
+  );
+  await protokolliere("einstellungen.gespeichert", "Einstellung", "system", geaendert);
+
+  revalidatePath("/einstellungen/system");
+  return { erfolg: "Einstellungen gespeichert." };
+}

src/server/actions/host-detail.ts

@@ -3,6 +3,7 @@
 import { revalidatePath } from "next/cache";
 import { prisma } from "@/lib/db";
 import { protokolliere } from "@/server/audit";
+import { sichtbarerKunde, sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import type { AktionsErgebnis } from "./kunden";
 
 /** Speichert Notizen und Tags eines Hosts. */
@@ -10,9 +11,20 @@ export async function hostNotizenSpeichern(
   _vorher: AktionsErgebnis,
   formular: FormData,
 ): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("mitarbeiten");
   const hostId = formular.get("hostId")?.toString();
   if (!hostId) return { fehler: "Host nicht gefunden." };
 
+  // Kundenkonten dürfen Notizen pflegen – aber nur an den eigenen Hosts.
+  const nurKunde = await sichtbarerKunde();
+  if (nurKunde) {
+    const eigener = await prisma.host.findFirst({
+      where: { id: hostId, kundeId: nurKunde },
+      select: { id: true },
+    });
+    if (!eigener) return { fehler: "Dieser Host gehört nicht zu Ihrem Zugang." };
+  }
+
   const notizen = formular.get("notizen")?.toString().trim() || null;
   const tags = (formular.get("tags")?.toString() ?? "")
     .split(",")
@@ -39,6 +51,7 @@ export async function hostNotizenSpeichern(
 
 /** Ordnet einen einzelnen Host einem Kunden zu (aus der Detailansicht heraus). */
 export async function hostKundeSetzen(formular: FormData) {
+  await sitzungErforderlich("fachlichSchreiben");
   const hostId = formular.get("hostId")?.toString();
   const kundeId = formular.get("kundeId")?.toString() || null;
   const standortId = formular.get("standortId")?.toString() || null;

src/server/actions/hosts.ts

@@ -3,11 +3,13 @@
 import { revalidatePath } from "next/cache";
 import { prisma } from "@/lib/db";
 import { protokolliere } from "@/server/audit";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import { hostsZuweisenService, ZuweisungsFehler } from "@/server/services/zuweisung";
 import type { AktionsErgebnis } from "./kunden";
 
 /** Weist mehrere Hosts in einem Schritt einem Kunden zu. */
 export async function hostsZuweisen(_vorher: AktionsErgebnis, formular: FormData): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("fachlichSchreiben");
   const hostIds = formular.getAll("hostId").map(String).filter(Boolean);
   const kundeId = formular.get("kundeId")?.toString() || null;
   const standortId = formular.get("standortId")?.toString() || null;
@@ -30,6 +32,7 @@ export async function hostsZuweisen(_vorher: AktionsErgebnis, formular: FormData
 
 /** Hebt die Zuordnung eines einzelnen Hosts auf. */
 export async function hostZuordnungAufheben(formular: FormData) {
+  await sitzungErforderlich("fachlichSchreiben");
   const hostId = formular.get("hostId")?.toString();
   if (!hostId) return;
 

src/server/actions/kunden.ts

@@ -5,6 +5,7 @@ import { redirect } from "next/navigation";
 import { z } from "zod";
 import { prisma } from "@/lib/db";
 import { protokolliere } from "@/server/audit";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 
 export interface AktionsErgebnis {
   fehler?: string;
@@ -28,6 +29,7 @@ const kundeSchema = z.object({
 
 /** Legt einen Kunden an oder ändert ihn; `id` im Formular entscheidet darüber. */
 export async function kundeSpeichern(_vorher: AktionsErgebnis, formular: FormData): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("fachlichSchreiben");
   const id = leerZuNull(formular.get("id"));
   const eingabe = kundeSchema.safeParse({
     name: formular.get("name")?.toString().trim() ?? "",
@@ -66,6 +68,7 @@ export async function kundeSpeichern(_vorher: AktionsErgebnis, formular: FormDat
 }
 
 export async function kundeLoeschen(formular: FormData) {
+  await sitzungErforderlich("fachlichSchreiben");
   const id = formular.get("id")?.toString();
   if (!id) return;
 
@@ -91,6 +94,7 @@ export async function standortSpeichern(
   _vorher: AktionsErgebnis,
   formular: FormData,
 ): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("fachlichSchreiben");
   const id = leerZuNull(formular.get("id"));
   const eingabe = standortSchema.safeParse({
     kundeId: formular.get("kundeId")?.toString() ?? "",
@@ -116,6 +120,7 @@ export async function standortSpeichern(
 }
 
 export async function standortLoeschen(formular: FormData) {
+  await sitzungErforderlich("fachlichSchreiben");
   const id = formular.get("id")?.toString();
   const kundeId = formular.get("kundeId")?.toString();
   if (!id) return;

src/server/actions/passkeys.ts

@@ -0,0 +1,20 @@
+"use server";
+
+import { revalidatePath } from "next/cache";
+import { prisma } from "@/lib/db";
+import { protokolliere } from "@/server/audit";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
+
+/** Entfernt einen eigenen Passkey. Fremde bleiben unberührt – auch für Administratoren. */
+export async function passkeyLoeschen(formular: FormData) {
+  const ich = await sitzungErforderlich();
+
+  const id = formular.get("id")?.toString();
+  if (!id) return;
+
+  const ergebnis = await prisma.passkey.deleteMany({ where: { id, benutzerId: ich.benutzerId } });
+  if (ergebnis.count === 0) return;
+
+  await protokolliere("passkey.entfernt", "Passkey", id, {});
+  revalidatePath("/einstellungen/passkeys");
+}

src/server/actions/rechnungen.ts

@@ -2,6 +2,7 @@
 
 import { revalidatePath } from "next/cache";
 import { anhangSpeichern, UploadFehler } from "@/lib/uploads";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import {
   einkaufBezahltSetzen,
   kundenrechnungErfassen,
@@ -48,6 +49,7 @@ async function ausfuehren(arbeit: () => Promise<string | void>): Promise<Aktions
 }
 
 export async function laufzeitBestaetigenAktion(formular: FormData) {
+  await sitzungErforderlich("fachlichSchreiben");
   const id = formular.get("laufzeitId")?.toString();
   if (!id) return;
   await laufzeitBestaetigen(id);
@@ -55,6 +57,7 @@ export async function laufzeitBestaetigenAktion(formular: FormData) {
 }
 
 export async function laufzeitVerwerfenAktion(formular: FormData) {
+  await sitzungErforderlich("fachlichSchreiben");
   const id = formular.get("laufzeitId")?.toString();
   if (!id) return;
   await laufzeitVerwerfen(id);
@@ -63,6 +66,7 @@ export async function laufzeitVerwerfenAktion(formular: FormData) {
 
 /** Häkchen aus der Rechnungstabelle. */
 export async function statusUmschalten(formular: FormData): Promise<void> {
+  await sitzungErforderlich("fachlichSchreiben");
   const laufzeitId = formular.get("laufzeitId")?.toString();
   const feld = formular.get("feld")?.toString();
   const wert = formular.get("wert")?.toString() === "true";
@@ -84,6 +88,7 @@ export async function proxmoxRechnungSpeichern(
   _vorher: AktionsErgebnis,
   formular: FormData,
 ): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("fachlichSchreiben");
   const laufzeitId = formular.get("laufzeitId")?.toString();
   if (!laufzeitId) return { fehler: "Laufzeit fehlt." };
 
@@ -101,7 +106,7 @@ export async function proxmoxRechnungSpeichern(
       datum: rechnungsdatum,
       faelligAm: datum(formular.get("faelligAm")),
       nettoBetrag: netto,
-      ustSatz: betrag(formular.get("ustSatz")) ?? 19,
+      ustSatz: betrag(formular.get("ustSatz")) ?? undefined,
       rabatt: betrag(formular.get("rabatt")),
       zahlungsart: formular.get("zahlungsart")?.toString().trim() || null,
       bezahlt: formular.get("bezahlt") === "on",
@@ -121,6 +126,7 @@ export async function kundenrechnungSpeichern(
   _vorher: AktionsErgebnis,
   formular: FormData,
 ): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("fachlichSchreiben");
   const laufzeitId = formular.get("laufzeitId")?.toString();
   if (!laufzeitId) return { fehler: "Laufzeit fehlt." };
 
@@ -133,7 +139,7 @@ export async function kundenrechnungSpeichern(
       nummer: formular.get("nummer")?.toString().trim() || null,
       datum: datum(formular.get("datum")),
       nettoBetrag: betrag(formular.get("nettoBetrag")),
-      ustSatz: betrag(formular.get("ustSatz")) ?? 19,
+      ustSatz: betrag(formular.get("ustSatz")) ?? undefined,
       bezahlt: formular.get("bezahlt") === "on",
       bezahltAm: datum(formular.get("bezahltAm")),
       anhangId,
@@ -151,6 +157,7 @@ export async function laufzeitAnlegenAktion(
   _vorher: AktionsErgebnis,
   formular: FormData,
 ): Promise<AktionsErgebnis> {
+  await sitzungErforderlich("fachlichSchreiben");
   const hostId = formular.get("hostId")?.toString();
   const key = formular.get("key")?.toString().trim();
   const start = datum(formular.get("start"));

src/server/actions/tokens.ts

@@ -4,6 +4,7 @@ import { revalidatePath } from "next/cache";
 import { prisma } from "@/lib/db";
 import { erzeugeToken } from "@/lib/tokens";
 import { protokolliere } from "@/server/audit";
+import { sitzungErforderlich } from "@/server/auth/sitzungspflicht";
 import type { AktionsErgebnis } from "./kunden";
 
 export interface TokenErgebnis extends AktionsErgebnis {
@@ -16,6 +17,7 @@ export async function enrollmentTokenErzeugen(
   _vorher: TokenErgebnis,
   formular: FormData,
 ): Promise<TokenErgebnis> {
+  await sitzungErforderlich("betrieb");
   const bezeichnung = formular.get("bezeichnung")?.toString().trim() || null;
   const kundeId = formular.get("kundeId")?.toString() || null;
   const standortId = formular.get("standortId")?.toString() || null;
@@ -58,6 +60,7 @@ export async function enrollmentTokenErzeugen(
 }
 
 export async function enrollmentTokenWiderrufen(formular: FormData) {
+  await sitzungErforderlich("betrieb");
   const id = formular.get("id")?.toString();
   if (!id) return;
 
@@ -67,6 +70,7 @@ export async function enrollmentTokenWiderrufen(formular: FormData) {
 }
 
 export async function hostTokenWiderrufen(formular: FormData) {
+  await sitzungErforderlich("betrieb");
   const id = formular.get("id")?.toString();
   const hostId = formular.get("hostId")?.toString();
   if (!id) return;

src/server/agent/http.ts

@@ -4,7 +4,7 @@ import { tokenAusHeader } from "@/lib/tokens";
 import { AgentApiFehler } from "./service";
 
 /** Version des Agent-Skripts, die das Dashboard ausliefert (siehe #005). */
-export const AGENT_VERSION = "0.2.0";
+export const AGENT_VERSION = "0.2.1";
 
 export function fehlerAntwort(status: number, code: string, nachricht: string, extra?: HeadersInit) {
   return Response.json({ ok: false, code, fehler: nachricht }, { status, headers: extra });

src/server/agent/schema.ts

@@ -36,6 +36,7 @@ export const reportSchema = z.object({
       ips: z.array(z.string().max(64)).max(32).nullish(),
       clusterName: nullbarerText,
       nodeName: nullbarerText,
+      clusterMitglieder: z.array(z.string().max(255)).max(64).nullish(),
       kernel: nullbarerText,
       uptimeSekunden: z.number().int().nonnegative().nullish(),
       cpuModell: nullbarerText,