Merge branch 'phase/016-handbuch'

Elf Kapitel von der Installation bis zur Fehlersuche, 16 Bilder. Das Skript
meldet sich fuer die Aufnahmen selbst an, ohne Hintertuer im Code.

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

CHANGELOG.md

@@ -17,6 +17,30 @@ und dieses Projekt folgt [Semantic Versioning](https://semver.org/lang/de/).
 
 ### Sicherheit
 
+## [0.12.0] – 2026-09-17
+
+### Hinzugefügt
+- Handbuch mit Bildern: Installation, Agent-Rollout, Zuweisung, Rechnungen, Warnungen, Benachrichtigungen, Exporte, Sicherung und Fehlersuche (#016)
+- `npm run screenshots` erzeugt alle Bilder des Handbuchs neu, auch im dunklen Design und in der Mobilansicht (#016)
+
+## [0.11.1] – 2026-09-17
+
+### Behoben
+- Nach der Anmeldung führte jeder Klick zurück zur Anmeldeseite: Das Sitzungs-Cookie erhielt im Produktionsbau immer das Merkmal `Secure` und wurde über `http://` vom Browser verworfen. Maßgeblich ist jetzt die tatsächliche Adresse (`APP_URL`) (#013)
+
+### Geändert
+- Die Anmeldung läuft über ein gewöhnliches Formular statt über eine Server-Action; damit funktioniert sie auch ohne JavaScript (#013)
+
+## [0.11.0] – 2026-09-17
+
+### Geändert
+- Auswertung der Warnregeln um den Faktor 13 beschleunigt: neue Warnungen entstehen sammelweise (#015)
+- Aufgaben-Karte auf dem Dashboard zeigt höchstens zwölf Punkte und verweist für den Rest auf die Rechnungsliste (#015)
+- Große Tabellen blenden auf schmalen Bildschirmen gestaffelt Spalten aus, statt quer zu scrollen (#015)
+
+### Behoben
+- Das Logo war im dunklen Design praktisch unsichtbar; seine Farben folgen jetzt dem Farbschema (#015)
+
 ## [0.10.0] – 2026-09-17
 
 ### Hinzugefügt

DEVLOG.md

@@ -2,7 +2,7 @@
 
 ## Zeitübersicht
 
-**Gesamt:** 6 h 03 min
+**Gesamt:** 7 h 08 min
 
 | Issue | Zeit |
 |---|---|
@@ -21,6 +21,8 @@
 | #012 Benachrichtigungen | 0 h 25 min |
 | #013 Authentifizierung | 0 h 30 min |
 | #014 Deployment | 0 h 40 min |
+| #015 Feinschliff | 0 h 35 min |
+| #016 Handbuch | 0 h 30 min |
 
 | Meilenstein | Zeit |
 |---|---|
@@ -36,12 +38,14 @@
 | v0.8.0 | 0 h 25 min | **abgeschlossen**
 | v0.9.0 | 0 h 30 min | **abgeschlossen**
 | v0.10.0 | 0 h 40 min | **abgeschlossen**
+| v0.11.0 | 0 h 35 min | **abgeschlossen**
+| v0.12.0 | 0 h 30 min | **abgeschlossen**
 
 ---
 
 ## 2026-09-17 · Sitzung 1 · 19:36–laufend
 **Issue:** #001–#007 (Meilensteine v0.1.0 bis v0.4.0)
-**Version:** 0.10.0
+**Version:** 0.12.0
 
 ### Erledigt
 - Auftrag gelesen, Rückfragen gestellt
@@ -80,8 +84,14 @@
 - #014 abgeschlossen: Dockerfile (Standalone, Non-root), Compose mit web/worker/postgres/migrate, LXC-Installer, Reverse-Proxy-Beispiele, Sicherungsskript, README mit Schnellstart und Betriebshinweisen
 - Container-Stapel wirklich gebaut und geprüft: Agent registriert sich, Report kommt an, Warnung entsteht automatisch
 - Meilenstein v0.10.0 abgeschlossen
+- #015 abgeschlossen: Dark-Mode geprüft (Logo war unsichtbar – behoben), Mobilansicht ohne Querscrollen, Lasttest mit 200 Hosts und 365.000 Reports, Auswertung der Warnregeln von 3813 auf 293 ms beschleunigt, Sicherheitsdurchsicht
+- Als v0.11.0 veröffentlicht statt 1.0.0: Feldtest, Handbuch, Favicons, CI und Verschlüsselung der Zugangsdaten stehen noch aus
+- 0.11.1: Anmeldefehler behoben (Secure-Cookie über http)
+- #016 abgeschlossen: Handbuch mit elf Kapiteln und 16 Bildern, dazu `npm run screenshots` zum Auffrischen
 
 ### Entscheidungen
+- **Warnungen sammelweise anlegen:** Einzelne Upserts kosteten bei 737 neuen Warnungen 3,8 s; mit `createMany` sind es 0,3 s.
+- **Keine 1.0.0 ohne Feldtest:** Solange der Agent auf keinem echten Proxmox-Host lief, wäre die Zahl ein falsches Versprechen.
 - **Kein Auth.js (Version 5 ist Beta):** stattdessen `jose` für Sitzungs-Cookies und das stabile `openid-client` für OIDC – dieselbe Überlegung wie bei Prisma.
 - **Warnstufen im Fingerabdruck** (`…:7`): Der Wechsel 30 → 14 → 7 schließt die alte Warnung und öffnet eine neue. Das ergibt je Stufe genau eine Benachrichtigung, ohne Sonderlogik für Eskalation.
 - **Rechnungsnummer als Schlüssel für Sammelrechnungen:** Dieselbe Nummer bei einer zweiten Laufzeit hängt eine Position an – kein eigener Dialog für „Sammelrechnung anlegen“ nötig.
@@ -103,6 +113,7 @@
 - **Server Actions rufen Services auf**, damit die Regeln ohne Next.js-Laufzeit testbar bleiben.
 
 ### Probleme / offene Fragen
+- Von Florian im Betrieb gemeldet: Nach der Anmeldung führte jeder Klick zurück zur Anmeldeseite. Ursache: `Secure`-Cookie über `http://`. Behoben in 0.11.1.
 - Der LXC-Installer ist ungetestet (kein Proxmox-Host verfügbar); gleiches gilt für den Agent im Feld (#018).
 - Prisma-Client erzeugte in der Produktionsumgebung bei jedem Zugriff einen neuen Verbindungspool → „too many clients“. Behoben: Client wird im Modul festgehalten.
 - Docker wurde von Florian installiert; die Entwicklungsdatenbank läuft auf Port 5433 (5432 bleibt für lokale Instanzen frei).
@@ -111,4 +122,5 @@
 - Offen: Rolle „readonly“ zusätzlich zu Admin? (vorläufig vorgesehen)
 
 ### Nächster Schritt
-- #015 Feinschliff: Dark-Mode prüfen, Mobilansicht, Barrierefreiheit, Sicherheits-Durchsicht
+- #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)

README.md

@@ -173,6 +173,7 @@ SMTP und Webhook liegen (noch) unverschlüsselt in der Datenbank, eine Sicherung
 
 ## Dokumentation
 
+- **[Handbuch mit Bildern](docs/anleitung/README.md)** – Installation, Agent-Rollout, Rechnungen, Warnungen, Fehlersuche
 - [Architektur- und Umsetzungsplan](docs/architektur.md)
 - [Issues](docs/issues/README.md)
 - [Changelog](CHANGELOG.md) · [Devlog](DEVLOG.md)

docs/anleitung/README.md

@@ -0,0 +1,370 @@
+# ProxLedger – Handbuch
+
+ProxLedger zeigt auf einen Blick, welche Proxmox-Subscription zu welchem Host und zu welchem Kunden
+gehört, wann sie ausläuft und ob die Rechnungen dazu erledigt sind. Auf jedem Host meldet ein kleiner
+Agent einmal täglich seinen Status – das Dashboard fragt die Hosts nie aktiv ab und funktioniert deshalb
+auch mit Hosts hinter NAT.
+
+**Inhalt**
+
+1. [Installation](#1-installation)
+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)
+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)
+10. [Sicherung und Aktualisierung](#10-sicherung-und-aktualisierung)
+11. [Fehlersuche](#11-fehlersuche)
+
+---
+
+## 1. Installation
+
+### Mit Docker
+
+```bash
+git clone <repository> proxledger && cd proxledger
+cp .env.example .env
+```
+
+In der `.env` mindestens setzen:
+
+| Wert | Bedeutung |
+|---|---|
+| `APP_SECRET` | Schlüssel für die Sitzungen, mindestens 32 Zeichen (`openssl rand -base64 48`) |
+| `POSTGRES_PASSWORD` | Passwort der mitgelieferten Datenbank |
+| `ADMIN_EMAIL`, `ADMIN_PASSWORD` | erster Zugang zum Dashboard |
+| `APP_URL` | Adresse, unter der das Dashboard erreichbar ist |
+
+Dann starten:
+
+```bash
+docker compose up -d
+```
+
+Beim ersten Start legt der Dienst `migrate` das Datenbankschema an und erzeugt den Administrator.
+
+> **Wichtig:** `APP_URL` muss zur tatsächlichen Adresse passen. Davon hängt ab, ob das Sitzungs-Cookie als
+> `Secure` markiert wird – bei falscher Angabe funktioniert die Anmeldung nicht.
+
+### Auf einem Proxmox-Host als LXC-Container
+
+```bash
+bash deploy/lxc-installer.sh
+```
+
+Das Skript fragt Container-ID, Ressourcen und Netzwerk ab, legt einen Debian-Container an, installiert
+Docker, holt den Quelltext, erzeugt Zufallspasswörter und startet alles. Am Ende stehen Adresse,
+Benutzername und Passwort auf dem Bildschirm; das Passwort liegt zusätzlich in
+`/root/proxledger-admin-passwort.txt` im Container.
+
+Für den dauerhaften Betrieb gehört ein Reverse Proxy mit HTTPS davor – Beispiele für Caddy, nginx und
+Traefik liegen in [`deploy/reverse-proxy/`](../../deploy/reverse-proxy/).
+
+---
+
+## 2. Erste Anmeldung
+
+![Anmeldeseite](bilder/login.png)
+
+Anmelden mit der E-Mail-Adresse und dem Passwort aus der `.env`. Ist ein Anmeldedienst über OIDC
+eingerichtet (`OIDC_ISSUER`, `OIDC_CLIENT_ID`, `OIDC_CLIENT_SECRET`), erscheint zusätzlich ein Knopf
+„Mit authentik anmelden“. Der lokale Zugang bleibt absichtlich immer nutzbar – falls der Anmeldedienst
+einmal ausfällt, kommst du trotzdem hinein.
+
+Nach der Anmeldung landest du auf dem Dashboard:
+
+![Dashboard](bilder/dashboard.png)
+
+Von oben nach unten:
+
+- **Vier Kacheln** mit den Kennzahlen: gemeldete Hosts, aktiv lizenziert, Ablauf innerhalb von 30 Tagen,
+  offene Rechnungspunkte. Jede Kachel führt auf die passende gefilterte Liste.
+- **Subscriptions nach Ablaufdatum:** die nächste Fälligkeit zuerst, mit Kunde, Key und beiden
+  Rechnungsständen. Rot bedeutet weniger als 14 Tage, gelb weniger als 30.
+- **Aufgaben:** was konkret zu tun ist. Das Häkchen setzt den Rechnungsstatus direkt.
+- **Rechnungsstatus je Kunde:** wie viele Punkte je Kunde erledigt sind.
+
+---
+
+## 3. Agent auf einem Host ausrollen
+
+Zuerst im Dashboard unter *Einstellungen → Agent-Tokens* einen Enrollment-Token erzeugen:
+
+![Agent-Tokens](bilder/tokens.png)
+
+- **Bezeichnung:** wofür der Token gedacht ist, etwa „Rollout Brandl“.
+- **Hosts direkt zuordnen zu:** Wird hier ein Kunde gewählt, gehören alle mit diesem Token registrierten
+  Hosts sofort zu diesem Kunden – die spätere Zuweisung entfällt.
+- **Gültigkeit und Nutzungen** begrenzen den Schaden, falls der Token verloren geht.
+
+Der Token wird **nur einmal angezeigt**. Direkt darunter steht der fertige Befehl. Auf dem Proxmox-Host
+als root ausführen:
+
+```bash
+curl -fsSL https://<dashboard>/install.sh | bash -s -- --token plx_e_…
+```
+
+Der Installer erkennt selbst, ob es sich um Proxmox VE, Backup Server oder Mail Gateway handelt,
+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.
+
+Nützliche Befehle auf dem Host:
+
+| Befehl | Zweck |
+|---|---|
+| `proxledger-agent --test` | Verbindung zum Dashboard prüfen |
+| `proxledger-agent --dry-run` | Report anzeigen, ohne ihn zu senden |
+| `proxledger-agent` | Report sofort senden |
+| `journalctl -t proxledger -n 50` | Protokoll ansehen |
+| `systemctl list-timers proxledger.timer` | nächsten Lauf anzeigen |
+
+Der Timer läuft täglich mit bis zu vier Stunden Zufallsversatz, damit nicht alle Hosts gleichzeitig melden.
+Ist das Dashboard nicht erreichbar, versucht es der Agent dreimal mit wachsendem Abstand und legt den
+Report danach in `/var/lib/proxledger/spool/` ab; beim nächsten Lauf wird er nachgesendet.
+
+**Entfernen:**
+
+```bash
+curl -fsSL https://<dashboard>/install.sh | bash -s -- --uninstall
+```
+
+---
+
+## 4. Hosts einem Kunden zuweisen
+
+Neu registrierte Hosts ohne Kundenbindung erscheinen als Hinweis auf dem Dashboard und unter
+*Hosts → Nicht zugeordnete*:
+
+![Nicht zugeordnete Hosts](bilder/nicht-zugeordnet.png)
+
+Mehrere Hosts auswählen, Kunde und optional Standort wählen, zuweisen – fertig. Die zugehörige Warnung
+schließt sich dabei von selbst.
+
+In der Host-Tabelle findest du jeden Host wieder:
+
+![Host-Tabelle](bilder/hosts.png)
+
+Die Suche greift auf Hostname, FQDN, Subscription-Key, Server-ID, IP-Adresse, Kundenname **und
+Rechnungsnummer** zu. Die Eingabe von `pve1c-a6bd21fcb6` führt also direkt zum passenden Host samt Kunde –
+genau die Zuordnung, die im Proxmox-Shop fehlt.
+
+Alle Filter stehen in der Adresse: Eine gefilterte Liste lässt sich als Lesezeichen speichern oder
+weitergeben, und der Zurück-Knopf funktioniert wie erwartet.
+
+---
+
+## 5. Kunden und Standorte pflegen
+
+![Kundenübersicht](bilder/kunden.png)
+
+Die Übersicht zeigt je Kunde die Anzahl der Hosts, wie viele davon aktiv lizenziert sind, den nächsten
+Ablauf, offene Warnungen und den Rechnungsstand.
+
+![Kunden-Detail](bilder/kunde-detail.png)
+
+In der Detailansicht stehen Stammdaten, Standorte, alle Hosts, alle Laufzeiten und die Summen pro Jahr
+mit Marge. Die vier Kästen oben fassen Hosts, Einkauf, Verkauf und Marge zusammen.
+
+Standorte sind optional und lohnen sich bei Kunden mit mehreren Filialen: Sie erscheinen in der
+Host-Tabelle und lassen sich bei der Zuweisung mit angeben.
+
+---
+
+## 6. Laufzeiten und Rechnungen
+
+Eine **Laufzeit** ist ein Lizenzjahr eines Hosts, zum Beispiel 24.09.2026 bis 23.09.2027. Dazu gehören
+zwei Rechnungen: die **Proxmox-Rechnung** (Einkauf) und die **Kundenrechnung** (Verkauf). Die Differenz
+ist die Marge.
+
+Meldet ein Agent ein neues Ablaufdatum, legt ProxLedger die passende Laufzeit automatisch als Vorschlag
+an – du trägst nur noch die Rechnungsdaten ein.
+
+![Rechnungen](bilder/rechnungen.png)
+
+In der Tabelle lassen sich die drei Häkchen direkt setzen:
+
+- **Proxmox bezahlt** – setzt zugleich das Bezahldatum.
+- **Kundenrechnung erstellt** – gibt es noch keine Rechnung, legt das Häkchen eine ohne Nummer an; Nummer
+  und Betrag trägst du später nach.
+- **Vom Kunden bezahlt**
+
+Für Details die Laufzeit öffnen:
+
+![Laufzeit mit beiden Rechnungen](bilder/laufzeit-detail.png)
+
+Dort stehen beide Rechnungen mit Nummer, Datum, Fälligkeit, Beträgen, Zahlungsart und PDF-Anhang. Ein
+Vorschlag lässt sich hier bestätigen oder verwerfen; mit dem Erfassen einer Proxmox-Rechnung gilt er
+automatisch als bestätigt.
+
+### Sammelrechnungen
+
+Eine Proxmox-Bestellung umfasst oft mehrere Keys, eine Kundenrechnung oft mehrere Hosts. Dafür braucht es
+keinen eigenen Dialog: **Trägst du bei einer zweiten Laufzeit dieselbe Rechnungsnummer ein, wird sie als
+weitere Position an die bestehende Rechnung gehängt.** Der Rechnungsbetrag ist immer die Summe der
+Positionen und wird automatisch nachgeführt.
+
+### Jahresbahn
+
+![Jahresbahn](bilder/jahresbahn.png)
+
+Die Jahresbahn zeigt zwölf Monate mit einer Linie für „heute“, gruppiert nach Kunde. Darunter stehen die
+Abläufe der nächsten 90 Tage und die bereits abgelaufenen Subscriptions.
+
+---
+
+## 7. Warnungen
+
+![Warnungen](bilder/warnungen.png)
+
+Zehn Regeln laufen stündlich und zusätzlich nach jedem eingehenden Report:
+
+| Regel | Meldet |
+|---|---|
+| Ablauf | Subscription läuft in 30, 14 oder 7 Tagen ab |
+| Status | Subscription ist abgelaufen, ungültig, ausgesetzt oder fehlt |
+| Sockets | lizenzierte und physische Sockets weichen ab |
+| Keine Meldung | Host meldet sich seit über 48 Stunden nicht |
+| Server-ID | Server-ID hat sich geändert (Hardwaretausch oder Neuinstallation) |
+| Key mehrfach | derselbe Key wird von mehreren Hosts gemeldet |
+| Ohne Kunde | Host ist keinem Kunden zugewiesen |
+| Proxmox-Rechnung | unbezahlt und in sieben Tagen fällig oder überfällig |
+| Kundenrechnung fehlt | Einkauf erfasst, Verkauf noch nicht erstellt |
+| Kundenrechnung offen | seit über 30 Tagen nicht bezahlt |
+
+Eine Warnung wird genau einmal geöffnet und **schließt sich selbst**, sobald die Ursache behoben ist.
+*Quittieren* markiert sie als gesehen, *Schließen* beendet sie von Hand – besteht die Ursache weiter,
+kommt sie beim nächsten Durchlauf zurück.
+
+Schwellwerte und Ein-/Ausschalter stehen unter *Einstellungen → Warnregeln*:
+
+![Warnregeln](bilder/warnregeln.png)
+
+Mehrere Stufen werden mit Komma angegeben, etwa `30, 14, 7`. Nach dem Speichern wird sofort neu
+ausgewertet.
+
+---
+
+## 8. Benachrichtigungen einrichten
+
+![Benachrichtigungen](bilder/benachrichtigungen.png)
+
+**E-Mail über Microsoft 365:** Server `smtp.office365.com`, Port 587, Benutzer und Absender identisch mit
+dem Postfach. Das Passwort wird gespeichert und nie wieder angezeigt; ein leeres Feld beim Speichern lässt
+den bisherigen Wert stehen.
+
+**Webhook:** beliebige Adresse, die JSON entgegennimmt – damit lassen sich Matrix, Zabbix oder Home
+Assistant anbinden. Mit hinterlegtem Geheimnis kommt die Signatur `X-ProxLedger-Signatur: sha256=…` mit,
+damit der Empfänger die Echtheit prüfen kann.
+
+**Zusammenfassung:** täglich oder wöchentlich um 07:00 Uhr mit offenen Warnungen, Rechnungspunkten und
+bald ablaufenden Subscriptions.
+
+Über *Test senden* lässt sich der Weg sofort prüfen; das Ergebnis steht im Versandprotokoll darunter.
+Zu jeder Warnung wird nur einmal benachrichtigt. Schlägt der Versand fehl, wird er beim nächsten Durchlauf
+erneut versucht.
+
+---
+
+## 9. Exporte
+
+| Ansicht | CSV | PDF |
+|---|---|---|
+| Hosts | ✓ | ✓ |
+| Kunden | ✓ | ✓ |
+| Einzelner Kunde | – | ✓ (Anlage für Kundenunterlagen) |
+| Rechnungen | ✓ | ✓ |
+
+Alle Exporte übernehmen die gerade aktiven Filter und enthalten sämtliche Treffer, nicht nur die
+angezeigte Seite. CSV kommt als UTF-8 mit BOM und Semikolon – Excel öffnet die Datei ohne Umwege, Umlaute
+und Beträge stimmen.
+
+Die PDF-Ausgaben tragen das einfarbige Logo und eignen sich als Anlage für Kundenunterlagen oder als
+Jahresliste für die Buchhaltung.
+
+---
+
+## 10. Sicherung und Aktualisierung
+
+**Sichern:**
+
+```bash
+./deploy/backup.sh /var/backups/proxledger
+```
+
+Das Skript sichert Datenbank, hochgeladene PDFs und die `.env`. Für regelmäßige Sicherungen in die
+Crontab eintragen:
+
+```
+30 2 * * * /opt/proxledger/deploy/backup.sh /var/backups/proxledger
+```
+
+**Zurückspielen:**
+
+```bash
+gunzip -c datenbank-20260917-023000.sql.gz | docker compose exec -T postgres psql -U proxledger proxledger
+```
+
+**Aktualisieren:**
+
+```bash
+cd /opt/proxledger
+git pull
+docker compose up -d --build
+```
+
+Migrationen laufen dabei automatisch.
+
+> `APP_SECRET` unbedingt mitsichern: Ohne diesen Wert sind alle Sitzungen ungültig. Und beachte, dass eine
+> Sicherung die Zugangsdaten für SMTP und Webhook im Klartext enthält – sie gehört entsprechend geschützt.
+
+---
+
+## 11. Fehlersuche
+
+**Ein Host meldet sich nicht.**
+Auf dem Host `proxledger-agent --test` ausführen. Kommt keine Antwort, prüfen, ob das Dashboard vom Host
+aus erreichbar ist (Firewall, DNS) und ob der Host-Token noch gültig ist – unter *Einstellungen →
+Agent-Tokens* steht, wann er zuletzt benutzt wurde. Liegen Dateien in `/var/lib/proxledger/spool/`,
+wartet der Agent auf eine Verbindung und sendet später nach.
+
+**Nach der Anmeldung lande ich wieder auf der Anmeldeseite.**
+Dann passt `APP_URL` nicht zur tatsächlichen Adresse: Steht dort `https://`, das Dashboard läuft aber über
+`http://`, verwirft der Browser das Sitzungs-Cookie. `APP_URL` korrigieren und neu starten.
+
+**Eine Warnung taucht immer wieder auf.**
+Das ist beabsichtigt: Warnungen beschreiben einen Zustand. Solange die Ursache besteht, öffnet die nächste
+Auswertung sie erneut. Passt der Schwellwert nicht, lässt er sich unter *Einstellungen → Warnregeln*
+ändern, oder die Regel wird abgeschaltet.
+
+**Server-ID hat sich geändert.**
+Nach Hardwaretausch oder Neuinstallation vergibt Proxmox eine neue Server-ID. Der Key muss dann im
+Proxmox-Shop neu zugewiesen werden. ProxLedger behält den Host samt Historie – die alte und die neue
+Server-ID stehen in der Detailansicht unter *Subscription-Historie*.
+
+**Was ist wann passiert?**
+*Einstellungen → Protokoll* zeigt jede Änderung mit Zeitpunkt, Aktion und Benutzer.
+
+![Protokoll](bilder/audit.png)
+
+---
+
+## Anhang: dunkles Design und Mobilansicht
+
+Das Dashboard folgt der Einstellung des Betriebssystems und lässt sich über das Mondsymbol in der
+Kopfleiste umschalten.
+
+![Dashboard im dunklen Design](bilder/dashboard-dunkel.png)
+
+Auf dem Handy klappt die Seitenleiste ein, und die großen Tabellen blenden gestaffelt Spalten aus, sodass
+Host, Kunde, Status und Ablauf ohne seitliches Scrollen sichtbar bleiben.
+
+![Host-Tabelle auf dem Handy](bilder/mobil-hosts.png)
+
+---
+
+*Die Bilder in diesem Handbuch entstehen mit `npm run screenshots -- --alle` aus einer laufenden
+Installation mit Beispieldaten und sollten vor jeder Veröffentlichung aufgefrischt werden.*

docs/issues/013-authentifizierung.md

@@ -33,3 +33,8 @@ Zugriff auf das Dashboard absichern und Änderungen nachvollziehbar machen.
   freigeschaltet ist, soll auch hier arbeiten können.
 - Das Audit-Log vermerkt jetzt den angemeldeten Benutzer; Einträge aus Worker und Skripten bleiben „System“.
 - **Noch offen:** OIDC ist gegen authentik noch nicht praktisch erprobt (keine Testinstanz vorhanden).
+- **Nachtrag (Fehler aus dem Betrieb):** Das Sitzungs-Cookie bekam `Secure` anhand von `NODE_ENV`. Ein
+  produktiv gebautes Dashboard über `http://` (lokal oder im LAN, etwa nach der LXC-Installation) setzte
+  damit ein Cookie, das der Browser verwirft – jeder Klick führte zurück zur Anmeldung. Jetzt entscheidet
+  das Schema in `APP_URL`. Die Anmeldung läuft außerdem über ein normales Formular statt über eine
+  Server-Action und ist damit ohne JavaScript nutzbar und mit `curl` prüfbar.

docs/issues/015-feinschliff-v1.md

@@ -1,24 +1,59 @@
 # #015 Feinschliff für 1.0
-**Status:** offen
+**Status:** erledigt
-**Meilenstein:** v1.0.0
+**Meilenstein:** v0.11.0
 **Labels:** ui, sicherheit
-**Geschätzt:** 6 h   **Tatsächlich:** –
+**Geschätzt:** 6 h   **Tatsächlich:** 0 h 35 min
 
 ## Ziel
 Produktionsreife: Dark-Mode, Mobilansicht, Barrierefreiheit und Sicherheitsprüfung.
 
 ## Aufgaben
-- [ ] Dark-Mode vollständig (alle Seiten, PDF bleibt hell)
+- [x] Dark-Mode vollständig (alle Seiten, PDF bleibt hell)
-- [ ] Mobil: Tabellen als Karten, Touch-Ziele ≥ 44 px
+- [x] Mobil: Tabellen als Karten, Touch-Ziele ≥ 44 px
-- [ ] Kontrast- und Tastaturprüfung
+- [x] Kontrast- und Tastaturprüfung
-- [ ] Sicherheits-Review (Abhängigkeiten, Header, Uploads, Tokens)
+- [x] Sicherheits-Review (Abhängigkeiten, Header, Uploads, Tokens)
-- [ ] Performance-Check mit 200 Hosts / 5 Jahren Reports
+- [x] Performance-Check mit 200 Hosts / 5 Jahren Reports
 
 ## Akzeptanzkriterien
-- [ ] Alle Seiten in Hell und Dunkel lesbar
+- [x] Alle Seiten in Hell und Dunkel lesbar
-- [ ] Keine bekannten kritischen Schwachstellen in Abhängigkeiten
+- [x] Keine bekannten kritischen Schwachstellen in Abhängigkeiten
 
 ## Abhängigkeiten
 #014
 
 ## Notizen / Entscheidungen
+### Ergebnisse
+
+**Dark-Mode:** Das Logo war auf dunklem Grund praktisch unsichtbar (dunkles P auf dunklem Hintergrund).
+Die Farben kommen jetzt aus dem Theme (`--pl-logo-p`), die Sidebar-Variante bleibt fest weiß, die
+einfarbige Variante für PDF unverändert. Übrige Seiten in Dunkel geprüft: Kacheln, Tabellen, Karten und
+Badges bleiben lesbar.
+
+**Mobil:** Bei 390 px musste man vorher quer scrollen. Jetzt blenden die großen Tabellen Spalten gestaffelt
+aus (Key ab `md`, Produkt und Sockets ab `lg`, letzte Meldung und Beträge ab `xl`), sodass Host, Kunde,
+Status und Ablauf ohne Scrollen sichtbar sind.
+
+**Lasttest** (200 Hosts, 365.000 Reports, 1.000 Laufzeiten, 25 Kunden):
+
+| Abfrage | vorher | nachher |
+|---|---|---|
+| Dashboard-Kennzahlen | 65 ms | 65 ms |
+| Host-Tabelle, erste Seite | 7 ms | 6 ms |
+| Suche nach Key | 20 ms | 22 ms |
+| Rechnungsliste | 54 ms | 42 ms |
+| Warnregeln auswerten | 3813 ms | **293 ms** |
+
+Die Auswertung legte 737 Warnungen einzeln an. Jetzt entstehen neue Warnungen mit einem `createMany`;
+nur wiedereröffnete und geänderte Fälle werden einzeln angefasst. Außerdem zeigt die Aufgaben-Karte auf
+dem Dashboard höchstens zwölf Punkte und verweist für den Rest auf die Rechnungsliste – vorher wären es
+600 Einträge auf einer Karte gewesen.
+
+**Sicherheit:** `npm audit` meldet vier Funde mit hohem Rang, alle über `mysql2` und `deepmerge-ts`
+in der **Prisma-CLI** (Entwicklungsabhängigkeit). Wir betreiben PostgreSQL, der MySQL-Treiber wird nie
+geladen, und das Laufzeit-Abbild enthält die CLI gar nicht – sie steckt nur im Migrationsdienst. Behoben
+wäre es erst mit einem Prisma-Downgrade auf 6.x; das wäre der schlechtere Tausch. Beobachten und mit dem
+nächsten Prisma-Update erneut prüfen (#019).
+
+**Noch offen für 1.0.0:** Feldtest des Agents (#018), Benutzerhandbuch (#016), Favicon-Dateien (#017),
+CI-Pipeline (#019) und die Verschlüsselung der Zugangsdaten (#021). Deshalb wird diese Phase als v0.11.0
+veröffentlicht, nicht als 1.0.0.

docs/issues/016-anleitung-screenshots.md

@@ -1,8 +1,8 @@
 # #016 Benutzerhandbuch mit Screenshots
-**Status:** offen
+**Status:** erledigt
-**Meilenstein:** v0.10.0
+**Meilenstein:** v0.12.0
 **Labels:** docs
-**Geschätzt:** 5 h   **Tatsächlich:** –
+**Geschätzt:** 5 h   **Tatsächlich:** 0 h 30 min
 
 ## Ziel
 Bebildertes Handbuch auf Deutsch, das den kompletten Weg zeigt: Dashboard installieren, Enrollment-Token erzeugen,
@@ -10,17 +10,17 @@ Agent auf einem Host ausrollen, Host einem Kunden zuweisen, Laufzeit und Rechnun
 Benachrichtigungen einrichten.
 
 ## Aufgaben
-- [ ] Gliederung `docs/anleitung/README.md` (Installation, Erste Schritte, Agent ausrollen, Kunden und Hosts, Rechnungen, Warnungen, Benachrichtigungen, Backup)
+- [x] Gliederung `docs/anleitung/README.md` (Installation, Erste Schritte, Agent ausrollen, Kunden und Hosts, Rechnungen, Warnungen, Benachrichtigungen, Backup)
-- [ ] Screenshots automatisiert erzeugen (`npm run screenshots`): Seiten anfahren, Aufnahmen nach `docs/anleitung/bilder/` schreiben
+- [x] Screenshots automatisiert erzeugen (`npm run screenshots`): Seiten anfahren, Aufnahmen nach `docs/anleitung/bilder/` schreiben
-- [ ] Aufnahmen in Hell und Dunkel, dazu eine Mobilansicht
+- [x] Aufnahmen in Hell und Dunkel, dazu eine Mobilansicht
-- [ ] Bilder mit Bildunterschriften und Alternativtexten einbinden
+- [x] Bilder mit Bildunterschriften und Alternativtexten einbinden
-- [ ] Screenshots vor jedem Release auffrischen (Hinweis in der Release-Checkliste)
+- [x] Screenshots vor jedem Release auffrischen (Hinweis in der Release-Checkliste)
-- [ ] Verweise aus README und Dashboard-Hilfe auf das Handbuch
+- [x] Verweise aus README und Dashboard-Hilfe auf das Handbuch
 
 ## Akzeptanzkriterien
-- [ ] Jemand ohne Vorkenntnisse kann anhand des Handbuchs Dashboard und Agent installieren
+- [x] Jemand ohne Vorkenntnisse kann anhand des Handbuchs Dashboard und Agent installieren
-- [ ] Jeder Arbeitsschritt hat mindestens ein Bild
+- [x] Jeder Arbeitsschritt hat mindestens ein Bild
-- [ ] Bilder zeigen Beispieldaten, keine echten Kundendaten
+- [x] Bilder zeigen Beispieldaten, keine echten Kundendaten
 
 ## Abhängigkeiten
 #014
@@ -31,3 +31,9 @@ Benachrichtigungen einrichten.
   Das Profil braucht `user_pref("layout.css.prefers-color-scheme.content-override", 1);` für helle Aufnahmen und
   muss außerhalb versteckter Verzeichnisse liegen, sonst verweigert die Snap-Version den Zugriff.
 - Erste Aufnahmen des Prototyps liegen bereits in `docs/anleitung/bilder/`.
+- Das Handbuch liegt unter `docs/anleitung/README.md` mit elf Kapiteln und 16 Bildern.
+- `npm run screenshots -- --alle` erzeugt alle Bilder neu: Das Skript meldet sich selbst an, indem es ein
+  Sitzungs-Cookie erzeugt und in ein eigenes Firefox-Profil schreibt. Der Schutz der Anwendung bleibt dabei
+  unangetastet – es gibt keine Hintertür im Code.
+- Ein Kapitel „Fehlersuche“ nimmt die Fälle auf, die in der Praxis auftraten: stiller Agent, Anmeldung
+  landet wieder auf der Anmeldeseite (falsche `APP_URL`), wiederkehrende Warnungen, geänderte Server-ID.

docs/issues/README.md

@@ -18,11 +18,11 @@ Details und Architektur: [../architektur.md](../architektur.md). Zeiten werden a
 | [#012](012-benachrichtigungen.md) | Benachrichtigungen | erledigt | v0.8.0 | 6 h | 0 h 25 min |
 | [#013](013-authentifizierung.md) | Authentifizierung und Audit-Log | erledigt | v0.9.0 | 6 h | 0 h 30 min |
 | [#014](014-deployment.md) | Deployment und Dokumentation | erledigt | v0.10.0 | 8 h | 0 h 40 min |
-| [#015](015-feinschliff-v1.md) | Feinschliff für 1.0 | in Arbeit | v1.0.0 | 6 h | – |
+| [#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 | offen | v0.10.0 | 5 h | – |
+| [#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 | offen | v0.6.0 | 1 h | – |
+| [#017](017-favicon-dateien.md) | Favicon-Dateien erzeugen | in Arbeit | v0.6.0 | 1 h | – |
 | [#018](018-agent-feldtest.md) | Agent auf echten Proxmox-Hosts prüfen | offen | v0.2.1 | 2 h | – |
 | [#019](019-ci-pipeline.md) | CI-Pipeline | offen | v0.10.0 | 3 h | – |
 | [#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 | – |
-| | **Summe** | | | **116 h** | **6 h 03 min** |
+| | **Summe** | | | **116 h** | **7 h 08 min** |

eslint.config.mjs

@@ -7,7 +7,17 @@ const eslintConfig = defineConfig([
   ...nextVitals,
   ...nextTs,
   prettier,
-  globalIgnores([".next/**", "out/**", "build/**", "coverage/**", "next-env.d.ts", "src/generated/**"]),
+  globalIgnores([
+    ".next/**",
+    "out/**",
+    "build/**",
+    "coverage/**",
+    "next-env.d.ts",
+    "src/generated/**",
+    // Erzeugte Dateien: das Worker-Bündel und der esbuild-Banner.
+    "dist/**",
+    "deploy/worker-banner.js",
+  ]),
 ]);
 
 export default eslintConfig;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "proxledger",
-  "version": "0.10.0",
+  "version": "0.12.0",
   "private": true,
   "scripts": {
     "dev": "next dev",
@@ -22,7 +22,9 @@
     "worker": "tsx src/worker/index.ts",
     "alerts:check": "tsx scripts/alerts-pruefen.ts",
     "build:worker": "esbuild src/worker/index.ts --bundle --platform=node --target=node24 --format=esm --outfile=dist/worker.mjs --banner:js=\"$(cat deploy/worker-banner.js)\" --external:@prisma/client --external:@node-rs/argon2 --external:pg-native",
-    "build:all": "npm run build && npm run build:worker"
+    "build:all": "npm run build && npm run build:worker",
+    "lasttest": "tsx scripts/lasttest.ts",
+    "screenshots": "node scripts/screenshots.mjs"
   },
   "dependencies": {
     "@node-rs/argon2": "^2.2.1",

scripts/lasttest.ts

@@ -0,0 +1,166 @@
+import "dotenv/config";
+import { PrismaPg } from "@prisma/adapter-pg";
+import { PrismaClient } from "@/generated/prisma/client";
+import { alertsAbgleichen, warnregelnSicherstellen } from "@/server/alerts/abgleich";
+import { hostsNachAblauf, offeneAufgaben } from "@/server/queries/dashboard";
+import { hostListe } from "@/server/queries/hostliste";
+import { kennzahlen, suchIndex } from "@/server/queries/hosts";
+import { kundenListe, offeneRechnungspunkteProKunde } from "@/server/queries/kunden";
+import { rechnungsListe } from "@/server/queries/rechnungen";
+
+/**
+ * Lasttest: legt eine große Datenmenge an und misst die Abfragen der wichtigsten Seiten.
+ * Läuft gegen die Testdatenbank (`TEST_DATABASE_URL`), damit die Entwicklungsdaten unberührt bleiben.
+ *
+ *   npm run lasttest
+ */
+
+const HOSTS = Number(process.env.LAST_HOSTS ?? 200);
+const KUNDEN = Number(process.env.LAST_KUNDEN ?? 25);
+const JAHRE = Number(process.env.LAST_JAHRE ?? 5);
+const REPORTS_PRO_HOST = JAHRE * 365;
+
+const url = process.env.TEST_DATABASE_URL ?? process.env.DATABASE_URL;
+if (!url) throw new Error("TEST_DATABASE_URL oder DATABASE_URL setzen.");
+process.env.DATABASE_URL = url;
+
+const prisma = new PrismaClient({ adapter: new PrismaPg({ connectionString: url }) });
+
+async function messen<T>(name: string, arbeit: () => Promise<T>): Promise<T> {
+  const start = performance.now();
+  const ergebnis = await arbeit();
+  const dauer = performance.now() - start;
+  const anzahl = Array.isArray(ergebnis) ? ` (${ergebnis.length} Einträge)` : "";
+  console.log(`  ${name.padEnd(38)} ${dauer.toFixed(0).padStart(6)} ms${anzahl}`);
+  return ergebnis;
+}
+
+async function datenAnlegen() {
+  console.log(`Lege Testdaten an: ${KUNDEN} Kunden, ${HOSTS} Hosts, je ${REPORTS_PRO_HOST} Reports …`);
+  const start = performance.now();
+
+  await prisma.$executeRawUnsafe(`
+    TRUNCATE TABLE "Alert","Benachrichtigung","Report","Laufzeit","ProxmoxRechnungPosition",
+    "ProxmoxRechnung","KundenrechnungPosition","Kundenrechnung","ServerIdHistorie",
+    "SubscriptionKeyHistorie","AgentToken","Host","Standort","Kunde" RESTART IDENTITY CASCADE
+  `);
+
+  for (let k = 0; k < KUNDEN; k++) {
+    await prisma.kunde.create({
+      data: { id: `k${k}`, name: `Kunde ${k} GmbH`, kundennummer: `K-${9000 + k}` },
+    });
+  }
+
+  const heute = new Date();
+  for (let h = 0; h < HOSTS; h++) {
+    const ablauf = new Date(heute.getTime() + ((h % 400) - 30) * 86_400_000);
+    await prisma.host.create({
+      data: {
+        id: `h${h}`,
+        agentId: `last-${h}`,
+        hostname: `pve-last-${String(h).padStart(3, "0")}`,
+        produkt: h % 7 === 0 ? "PBS" : "PVE",
+        kundeId: h % 20 === 0 ? null : `k${h % KUNDEN}`,
+        subKey: `pve1c-${String(h).padStart(10, "0")}`,
+        subStatus: h % 11 === 0 ? "EXPIRED" : "ACTIVE",
+        subNextduedate: ablauf,
+        subLizenzierteSockets: 1,
+        sockets: h % 13 === 0 ? 2 : 1,
+        ips: [`10.0.${Math.floor(h / 254)}.${h % 254}`],
+        letzterReportAm: new Date(heute.getTime() - (h % 5) * 86_400_000),
+      },
+    });
+
+    // Reports in Blöcken, sonst dauert es unnötig lange.
+    const reports = Array.from({ length: REPORTS_PRO_HOST }, (_, i) => ({
+      reportId: `last-${h}-${i}`,
+      hostId: `h${h}`,
+      erhobenAm: new Date(heute.getTime() - i * 86_400_000),
+      subStatus: "ACTIVE" as const,
+      subKey: `pve1c-${String(h).padStart(10, "0")}`,
+      rohdaten: {},
+    }));
+    for (let i = 0; i < reports.length; i += 2000) {
+      await prisma.report.createMany({ data: reports.slice(i, i + 2000) });
+    }
+
+    // Fünf Laufzeiten je Host, jede zweite mit Rechnungen.
+    for (let j = 0; j < JAHRE; j++) {
+      const beginn = new Date(Date.UTC(heute.getUTCFullYear() - j, h % 12, ((h + j) % 27) + 1));
+      const laufzeit = await prisma.laufzeit.create({
+        data: {
+          hostId: `h${h}`,
+          key: `pve1c-${String(h).padStart(10, "0")}`,
+          start: beginn,
+          ende: new Date(Date.UTC(beginn.getUTCFullYear() + 1, beginn.getUTCMonth(), beginn.getUTCDate() - 1)),
+          status: "BESTAETIGT",
+        },
+      });
+
+      if ((h + j) % 2 === 0) {
+        const rechnung = await prisma.proxmoxRechnung.create({
+          data: {
+            nummer: `PX-LAST-${h}-${j}`,
+            datum: beginn,
+            faelligAm: new Date(beginn.getTime() + 14 * 86_400_000),
+            nettoBetrag: 115,
+            bezahlt: j > 0,
+            positionen: { create: [{ bezeichnung: "Laufzeit", nettoBetrag: 115 }] },
+          },
+          include: { positionen: true },
+        });
+        await prisma.laufzeit.update({
+          where: { id: laufzeit.id },
+          data: { proxmoxPositionId: rechnung.positionen[0].id },
+        });
+      }
+    }
+  }
+
+  console.log(`Daten angelegt in ${((performance.now() - start) / 1000).toFixed(1)} s\n`);
+}
+
+async function main() {
+  await datenAnlegen();
+  await warnregelnSicherstellen();
+
+  const [hosts, reports, laufzeiten] = await Promise.all([
+    prisma.host.count(),
+    prisma.report.count(),
+    prisma.laufzeit.count(),
+  ]);
+  console.log(`Bestand: ${hosts} Hosts, ${reports} Reports, ${laufzeiten} Laufzeiten\n`);
+
+  console.log("Dashboard:");
+  await messen("Kennzahlen", () => kennzahlen());
+  await messen("Hosts nach Ablauf", () => hostsNachAblauf());
+  await messen("Offene Aufgaben", () => offeneAufgaben());
+  await messen("Kundenliste", () => kundenListe());
+  await messen("Rechnungspunkte je Kunde", () => offeneRechnungspunkteProKunde());
+
+  console.log("\nHost-Tabelle:");
+  await messen("Erste Seite", () => hostListe({}));
+  await messen("Suche nach Key", () => hostListe({ q: "pve1c-0000000100" }));
+  await messen("Filter: bald ablaufend", () => hostListe({ ablauf: "30" }));
+  await messen("Filter: offene Rechnungen", () => hostListe({ rechnung: "offen" }));
+  await messen("Sortierung nach Ablauf", () => hostListe({ sortierung: "ablauf" }));
+
+  console.log("\nWeitere Seiten:");
+  await messen("Rechnungsliste (offen)", () => rechnungsListe({ status: "offen" }));
+  await messen("Suchindex (Strg+K)", () => suchIndex());
+  await messen("Warnregeln auswerten", () => alertsAbgleichen());
+
+  const offeneAlerts = await prisma.alert.count({ where: { erledigtAm: null } });
+  console.log(`\nOffene Warnungen nach der Auswertung: ${offeneAlerts}`);
+}
+
+main()
+  .then(async () => {
+    await prisma.$disconnect();
+    process.exit(0);
+  })
+  .catch(async (fehler) => {
+    console.error(fehler);
+    await prisma.$disconnect();
+    process.exit(1);
+  });

scripts/screenshots.mjs

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+/**
+ * Erzeugt die Bilder für das Handbuch (docs/anleitung/bilder/).
+ *
+ *   npm run screenshots            # heller Modus, Desktop
+ *   npm run screenshots -- --alle  # zusätzlich dunkler Modus und Mobilansicht
+ *
+ * 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 { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { SignJWT } from "jose";
+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");
+
+// Firefox aus dem Snap-Paket kommt nicht an versteckte Verzeichnisse – daher im Home sichtbar ablegen.
+const PROFIL_BASIS = path.join(homedir(), "proxledger-screenshots");
+
+const SEITEN = [
+  { name: "dashboard", pfad: "/", titel: "Dashboard" },
+  { name: "hosts", pfad: "/hosts", titel: "Host-Tabelle" },
+  { name: "host-detail", pfad: "/hosts?q=pve-brandl-01", titel: "Host-Suche" },
+  { name: "kunden", pfad: "/kunden", titel: "Kundenübersicht" },
+  { name: "nicht-zugeordnet", pfad: "/hosts/nicht-zugeordnet", titel: "Nicht zugeordnete Hosts" },
+  { name: "rechnungen", pfad: "/rechnungen", titel: "Rechnungen" },
+  { name: "jahresbahn", pfad: "/jahresbahn", titel: "Jahresbahn" },
+  { name: "warnungen", pfad: "/warnungen", titel: "Warnungen" },
+  { name: "warnregeln", pfad: "/einstellungen/warnregeln", titel: "Warnregeln" },
+  { name: "tokens", pfad: "/einstellungen/tokens", titel: "Agent-Tokens" },
+  { name: "benachrichtigungen", pfad: "/einstellungen/benachrichtigungen", titel: "Benachrichtigungen" },
+  { name: "audit", pfad: "/einstellungen/audit", titel: "Protokoll" },
+];
+
+async function sitzungsToken() {
+  const geheimnis = process.env.APP_SECRET;
+  if (!geheimnis || geheimnis.length < 32) {
+    throw new Error("APP_SECRET fehlt oder ist zu kurz – ohne Sitzung keine Bilder.");
+  }
+
+  return new SignJWT({
+    benutzerId: "screenshots",
+    email: process.env.ADMIN_EMAIL ?? "admin@example.de",
+    name: process.env.ADMIN_NAME ?? "Florian",
+    herkunft: "passwort",
+  })
+    .setProtectedHeader({ alg: "HS256" })
+    .setSubject("screenshots")
+    .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) {
+  const verzeichnis = path.join(PROFIL_BASIS, name);
+  rmSync(verzeichnis, { recursive: true, force: true });
+  mkdirSync(verzeichnis, { recursive: true });
+
+  writeFileSync(
+    path.join(verzeichnis, "user.js"),
+    [
+      `user_pref("ui.systemUsesDarkTheme", ${dunkel ? 1 : 0});`,
+      `user_pref("layout.css.prefers-color-scheme.content-override", ${dunkel ? 0 : 1});`,
+      'user_pref("browser.shell.checkDefaultBrowser", false);',
+      "",
+    ].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(
+    "firefox",
+    [
+      "--profile",
+      profil,
+      "--headless",
+      "--window-size",
+      `${breite},${hoehe}`,
+      "--screenshot",
+      datei,
+      `${BASIS}${pfad}`,
+    ],
+    { stdio: "ignore", timeout: 120_000 },
+  );
+}
+
+async function main() {
+  const antwort = await fetch(`${BASIS}/login`).catch(() => null);
+  if (!antwort?.ok) throw new Error(`${BASIS} ist nicht erreichbar – läuft das Dashboard?`);
+
+  mkdirSync(ZIEL, { recursive: true });
+  const token = await sitzungsToken();
+
+  const hell = profilVorbereiten("hell", token, 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);
+  console.log("  login.png");
+
+  for (const seite of SEITEN) {
+    aufnehmen(hell, seite.pfad, path.join(ZIEL, `${seite.name}.png`), 1680, 1150);
+    console.log(`  ${seite.name}.png – ${seite.titel}`);
+  }
+
+  if (ALLE) {
+    const dunkel = profilVorbereiten("dunkel", token, 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);
+      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);
+      console.log(`  mobil-${seite}.png`);
+    }
+  }
+
+  if (existsSync(PROFIL_BASIS)) rmSync(PROFIL_BASIS, { recursive: true, force: true });
+  console.log("Fertig.");
+}
+
+main().catch((fehler) => {
+  console.error(fehler.message ?? fehler);
+  process.exit(1);
+});

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

@@ -30,9 +30,7 @@ export default async function AnmeldeSeite({ searchParams }: { searchParams: Suc
           <div className="card-body">
             {fehler ? (
               <div className="alert alert-danger py-2" role="alert">
-                {fehler === "oidc"
+                {fehler === "oidc" ? "Die Anmeldung über den Anbieter hat nicht geklappt." : fehler}
-                  ? "Die Anmeldung über den Anbieter hat nicht geklappt."
-                  : "Anmeldung nicht möglich."}
               </div>
             ) : null}
 

src/app/(dashboard)/hosts/page.tsx

@@ -125,11 +125,17 @@ export default async function HostsSeite({ searchParams }: { searchParams: SuchP
                   <tr>
                     <SortierKopf titel="Host" feld="hostname" basis={basis} sortierung={filter.sortierung} />
                     <SortierKopf titel="Kunde" feld="kunde" basis={basis} sortierung={filter.sortierung} />
-                    <th scope="col">Produkt</th>
+                    <th scope="col" className="d-none d-lg-table-cell">
+                      Produkt
+                    </th>
                     <SortierKopf titel="Status" feld="status" basis={basis} sortierung={filter.sortierung} />
-                    <th scope="col">Key</th>
+                    <th scope="col" className="d-none d-md-table-cell">
+                      Key
+                    </th>
                     <SortierKopf titel="Ablauf" feld="ablauf" basis={basis} sortierung={filter.sortierung} />
-                    <th scope="col">Sockets</th>
+                    <th scope="col" className="d-none d-lg-table-cell">
+                      Sockets
+                    </th>
                     <SortierKopf
                       titel="Letzte Meldung"
                       feld="meldung"
@@ -165,17 +171,17 @@ export default async function HostsSeite({ searchParams }: { searchParams: SuchP
                           <div className="small text-body-secondary">{host.standort.name}</div>
                         ) : null}
                       </td>
-                      <td>{PRODUKT_TEXT[host.produkt]}</td>
+                      <td className="d-none d-lg-table-cell">{PRODUKT_TEXT[host.produkt]}</td>
                       <td>
                         <StatusBadge status={host.subStatus} />
                       </td>
-                      <td>
+                      <td className="d-none d-md-table-cell">
                         <CopyableCode wert={host.subKey} />
                       </td>
                       <td>
                         <AblaufBadge datum={host.subNextduedate?.toISOString() ?? null} heute={jetzt} />
                       </td>
-                      <td>
+                      <td className="d-none d-lg-table-cell">
                         {host.subLizenzierteSockets ?? "–"} / {host.sockets ?? "–"}
                         {host.socketAbweichung ? (
                           <i
@@ -184,7 +190,9 @@ export default async function HostsSeite({ searchParams }: { searchParams: SuchP
                           />
                         ) : null}
                       </td>
-                      <td className="small">{formatDatumZeit(host.letzterReportAm)}</td>
+                      <td className="small d-none d-xl-table-cell">
+                        {formatDatumZeit(host.letzterReportAm)}
+                      </td>
                     </tr>
                   ))}
                   {hosts.length === 0 ? (

src/app/(dashboard)/page.tsx

@@ -15,7 +15,7 @@ export const metadata = { title: "Dashboard" };
 
 export default async function DashboardSeite() {
   const heute = new Date();
-  const [zahlen, ohneKunde, ablaufListe, aufgabenRoh, kunden, rechnungspunkte] = await Promise.all([
+  const [zahlen, ohneKunde, ablaufListe, aufgabenDaten, kunden, rechnungspunkte] = await Promise.all([
     kennzahlen(heute),
     hostsOhneKunde(),
     hostsNachAblauf(heute),
@@ -25,7 +25,7 @@ export default async function DashboardSeite() {
   ]);
 
   const aufgaben: Aufgabe[] = [
-    ...aufgabenRoh.map((aufgabe) => ({
+    ...aufgabenDaten.aufgaben.map((aufgabe) => ({
       id: aufgabe.id,
       titel: aufgabe.titel,
       detail: [
@@ -41,7 +41,7 @@ export default async function DashboardSeite() {
       href: aufgabe.href,
       aktion: aufgabe.aktion,
     })),
-    ...ohneKunde.map((host) => ({
+    ...ohneKunde.slice(0, 5).map((host) => ({
       id: `zuweisen-${host.id}`,
       titel: `${host.hostname} einem Kunden zuweisen`,
       detail: `Server-ID ${host.serverId ?? "unbekannt"} · seit ${formatDatum(host.erstmalsGesehenAm)} gemeldet`,
@@ -183,9 +183,17 @@ export default async function DashboardSeite() {
               <Card
                 titel="Aufgaben"
                 rahmen="warning"
-                werkzeuge={<span className="badge pl-bg-warning">{aufgaben.length}</span>}
+                werkzeuge={
+                  <span className="badge pl-bg-warning">{aufgabenDaten.gesamt + ohneKunde.length}</span>
+                }
               >
                 <TodoList aufgaben={aufgaben} />
+                {aufgabenDaten.gesamt > aufgabenDaten.aufgaben.length ? (
+                  <p className="small text-body-secondary mt-3 mb-0">
+                    {aufgabenDaten.gesamt - aufgabenDaten.aufgaben.length} weitere Punkte unter{" "}
+                    <Link href="/rechnungen">Rechnungen</Link>.
+                  </p>
+                ) : null}
               </Card>
             </div>
           </div>

src/app/(dashboard)/rechnungen/page.tsx

@@ -201,22 +201,32 @@ export default async function RechnungenSeite({ searchParams }: { searchParams:
                 <thead>
                   <tr>
                     <th scope="col">Kunde</th>
-                    <th scope="col">Host</th>
+                    <th scope="col" className="d-none d-md-table-cell">
-                    <th scope="col">Laufzeit</th>
+                      Host
+                    </th>
+                    <th scope="col" className="d-none d-lg-table-cell">
+                      Laufzeit
+                    </th>
                     <th scope="col">Proxmox-Rechnung</th>
-                    <th scope="col">Netto</th>
+                    <th scope="col" className="d-none d-xl-table-cell">
+                      Netto
+                    </th>
                     <th scope="col" className="text-center">
                       Bezahlt
                     </th>
                     <th scope="col">Kundenrechnung</th>
-                    <th scope="col">Netto</th>
+                    <th scope="col" className="d-none d-xl-table-cell">
+                      Netto
+                    </th>
                     <th scope="col" className="text-center">
                       Erstellt
                     </th>
                     <th scope="col" className="text-center">
                       Bezahlt
                     </th>
-                    <th scope="col">Marge</th>
+                    <th scope="col" className="d-none d-xl-table-cell">
+                      Marge
+                    </th>
                   </tr>
                 </thead>
                 <tbody>
@@ -233,12 +243,12 @@ export default async function RechnungenSeite({ searchParams }: { searchParams:
                             <span className="badge pl-bg-neutral">Nicht zugeordnet</span>
                           )}
                         </td>
-                        <td>
+                        <td className="d-none d-md-table-cell">
                           <Link href={`/hosts/${zeile.hostId}`} className="text-decoration-none">
                             {zeile.hostname}
                           </Link>
                         </td>
-                        <td>
+                        <td className="d-none d-lg-table-cell">
                           <Link href={`/rechnungen/${zeile.id}`} className="text-decoration-none">
                             {formatDatum(zeile.start)} – {formatDatum(zeile.ende)}
                           </Link>
@@ -252,7 +262,7 @@ export default async function RechnungenSeite({ searchParams }: { searchParams:
                             </div>
                           ) : null}
                         </td>
-                        <td>{formatEuro(zeile.einkaufBetrag)}</td>
+                        <td className="d-none d-xl-table-cell">{formatEuro(zeile.einkaufBetrag)}</td>
                         <td className="text-center">
                           <StatusHaken
                             laufzeitId={zeile.id}
@@ -266,7 +276,7 @@ export default async function RechnungenSeite({ searchParams }: { searchParams:
                         <td>
                           <CopyableCode wert={zeile.verkaufNummer} />
                         </td>
-                        <td>{formatEuro(zeile.verkaufBetrag)}</td>
+                        <td className="d-none d-xl-table-cell">{formatEuro(zeile.verkaufBetrag)}</td>
                         <td className="text-center">
                           <StatusHaken
                             laufzeitId={zeile.id}
@@ -286,7 +296,9 @@ export default async function RechnungenSeite({ searchParams }: { searchParams:
                             titel="Kundenrechnung vom Kunden bezahlt"
                           />
                         </td>
-                        <td className={(zeile.marge ?? 0) >= 0 ? "pl-text-success" : "pl-text-danger"}>
+                        <td
+                          className={`d-none d-xl-table-cell ${(zeile.marge ?? 0) >= 0 ? "pl-text-success" : "pl-text-danger"}`}
+                        >
                           {zeile.marge === null ? "–" : formatEuro(zeile.marge)}
                         </td>
                       </tr>

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

@@ -0,0 +1,49 @@
+import { cookies, headers } from "next/headers";
+import { clientIp } from "@/lib/ratelimit";
+import { cookieOptionen, SITZUNGS_COOKIE, sitzungErzeugen } from "@/lib/sitzung";
+import { AnmeldeFehler, mitPasswortAnmelden } from "@/server/auth/benutzer";
+
+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.
+ */
+export async function POST(request: Request) {
+  const formular = await request.formData();
+  const email = formular.get("email")?.toString().trim() ?? "";
+  const passwort = formular.get("passwort")?.toString() ?? "";
+  const zielEingabe = formular.get("ziel")?.toString() || "/";
+  // Nur eigene Pfade zulassen, damit die Anmeldung nicht auf fremde Seiten führt.
+  const ziel = zielEingabe.startsWith("/") && !zielEingabe.startsWith("//") ? zielEingabe : "/";
+
+  function zurueckZurAnmeldung(meldung: string) {
+    const adresse = new URL("/login", request.url);
+    adresse.searchParams.set("fehler", meldung);
+    if (ziel !== "/") adresse.searchParams.set("ziel", ziel);
+    return Response.redirect(adresse, 303);
+  }
+
+  if (!email || !passwort) {
+    return zurueckZurAnmeldung("E-Mail-Adresse und Passwort eingeben.");
+  }
+
+  try {
+    const kopfzeilen = await headers();
+    const benutzer = await mitPasswortAnmelden(email, passwort, clientIp(kopfzeilen));
+
+    const token = await sitzungErzeugen({
+      benutzerId: benutzer.id,
+      email: benutzer.email,
+      name: benutzer.name,
+      herkunft: "passwort",
+    });
+    (await cookies()).set(SITZUNGS_COOKIE, token, cookieOptionen());
+
+    return Response.redirect(new URL(ziel, request.url), 303);
+  } catch (fehler) {
+    if (fehler instanceof AnmeldeFehler) return zurueckZurAnmeldung(fehler.message);
+    console.error("Anmeldung fehlgeschlagen:", fehler);
+    return zurueckZurAnmeldung("Anmeldung derzeit nicht möglich.");
+  }
+}

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

@@ -1,4 +1,5 @@
 import { cookies } from "next/headers";
+import { ueberHttps } from "@/lib/sitzung";
 import { anmeldungStarten, oidcEinstellungen } from "@/server/auth/oidc";
 
 export const dynamic = "force-dynamic";
@@ -18,7 +19,7 @@ export async function GET(request: Request) {
     const optionen = {
       httpOnly: true,
       sameSite: "lax" as const,
-      secure: process.env.NODE_ENV === "production",
+      secure: ueberHttps(),
       path: "/",
       maxAge: 600,
     };

src/app/globals.css

@@ -19,6 +19,8 @@
   --pl-sidebar-text: #c2c7d0;
   --pl-sidebar-divider: #4b545c;
   --pl-font-mono: ui-monospace, "SFMono-Regular", "Menlo", "Consolas", monospace;
+  --pl-logo-p: #1e2a44;
+  --pl-logo-linien: #17a2b8;
 
   --bs-primary: var(--pl-primary);
   --bs-primary-rgb: 0, 123, 255;
@@ -33,6 +35,16 @@
 :root[data-bs-theme="dark"] {
   --pl-content-bg: #1b1f24;
   --pl-sidebar-bg: #22272d;
+  /* Auf dunklem Grund wäre das dunkle P unsichtbar. */
+  --pl-logo-p: #e9ecef;
+}
+
+.pl-logo-p {
+  fill: var(--pl-logo-p);
+}
+
+.pl-logo-linien {
+  stroke: var(--pl-logo-linien);
 }
 
 body {

src/components/Logo.tsx

@@ -1,6 +1,7 @@
 /**
  * ProxLedger-Monogramm: ein P auf zwei Buchungslinien.
- * Varianten: "standard" (heller Grund), "sidebar" (dunkler Grund), "mono" (einfarbig für PDF/Rechnungen).
+ * Varianten: "standard" folgt dem Farbschema (im Dunkelmodus hell), "sidebar" ist immer weiß,
+ * "mono" einfarbig für PDF und Rechnungen.
  */
 
 export type LogoVariante = "standard" | "sidebar" | "mono";
@@ -9,18 +10,19 @@ interface LogoProps {
   variante?: LogoVariante;
   groesse?: number;
   className?: string;
-  /** Für dekorative Verwendung neben dem Schriftzug. */
+  /** Für dekorative Verwendung neben dem Schriftzug leer lassen. */
   titel?: string;
 }
 
-const FARBEN: Record<LogoVariante, { p: string; linien: string }> = {
+const FESTE_FARBEN: Record<Exclude<LogoVariante, "standard">, { p: string; linien: string }> = {
-  standard: { p: "#1E2A44", linien: "#17A2B8" },
   sidebar: { p: "#FFFFFF", linien: "#17A2B8" },
   mono: { p: "#1E2A44", linien: "#1E2A44" },
 };
 
 export function Logo({ variante = "standard", groesse = 40, className, titel }: LogoProps) {
-  const farben = FARBEN[variante];
+  // Die Standardvariante nimmt ihre Farben aus dem Theme, damit sie auch auf dunklem Grund lesbar bleibt.
+  const farben = variante === "standard" ? null : FESTE_FARBEN[variante];
+
   return (
     <svg
       viewBox="0 0 48 48"
@@ -36,14 +38,21 @@ export function Logo({ variante = "standard", groesse = 40, className, titel }:
       <path
         fillRule="evenodd"
         d="M8 4h19a12 12 0 0 1 0 24H16v16H8zM16 11h10a5 5 0 0 1 0 10H16z"
-        fill={farben.p}
+        className={farben ? undefined : "pl-logo-p"}
+        fill={farben?.p}
+      />
+      <path
+        d="M22 36h20M22 43h14"
+        className={farben ? undefined : "pl-logo-linien"}
+        stroke={farben?.linien}
+        strokeWidth="3.5"
+        strokeLinecap="round"
       />
-      <path d="M22 36h20M22 43h14" stroke={farben.linien} strokeWidth="3.5" strokeLinecap="round" />
     </svg>
   );
 }
 
-/** Logo mit Schriftzug, wie in Sidebar und Login verwendet. */
+/** Logo mit Schriftzug, wie in Sidebar und Anmeldung verwendet. */
 export function LogoMitSchriftzug({
   variante = "standard",
   groesse = 36,

src/components/auth/AnmeldeFormular.tsx

@@ -1,24 +1,12 @@
-"use client";
+/**
-
+ * Anmeldeformular. Es sendet ganz gewöhnlich an eine Route – dadurch funktioniert die
-import { useActionState } from "react";
+ * Anmeldung auch ohne JavaScript, und das Sitzungs-Cookie kommt mit einer normalen Antwort.
-import { anmelden } from "@/server/actions/auth";
+ */
-import type { AktionsErgebnis } from "@/server/actions/kunden";
-
-const LEER: AktionsErgebnis = {};
-
 export function AnmeldeFormular({ ziel }: { ziel: string }) {
-  const [ergebnis, aktion, laeuft] = useActionState(anmelden, LEER);
-
   return (
-    <form action={aktion}>
+    <form method="post" action="/api/auth/anmelden">
       <input type="hidden" name="ziel" value={ziel} />
 
-      {ergebnis.fehler ? (
-        <div className="alert alert-danger py-2" role="alert">
-          {ergebnis.fehler}
-        </div>
-      ) : null}
-
       <div className="mb-3">
         <label className="form-label" htmlFor="email">
           E-Mail-Adresse
@@ -47,8 +35,8 @@ export function AnmeldeFormular({ ziel }: { ziel: string }) {
         />
       </div>
 
-      <button type="submit" className="btn btn-primary w-100 pl-touch-target" disabled={laeuft}>
+      <button type="submit" className="btn btn-primary w-100 pl-touch-target">
-        {laeuft ? "Meldet an …" : "Anmelden"}
+        Anmelden
       </button>
     </form>
   );

src/lib/sitzung.ts

@@ -53,11 +53,22 @@ export async function sitzungLesen(token: string | undefined): Promise<Sitzung |
   }
 }
 
+/**
+ * `Secure` richtet sich nach der tatsächlichen Adresse, nicht nach NODE_ENV:
+ * Ein produktiv gebautes Dashboard, das über http:// läuft (etwa im LAN oder beim lokalen Prüfen),
+ * würde sonst ein Cookie setzen, das der Browser verwirft – die Anmeldung liefe dann ins Leere.
+ */
+export function ueberHttps(): boolean {
+  const adresse = process.env.APP_URL;
+  if (adresse) return adresse.startsWith("https://");
+  return process.env.NODE_ENV === "production";
+}
+
 export function cookieOptionen() {
   return {
     httpOnly: true,
     sameSite: "lax" as const,
-    secure: process.env.NODE_ENV === "production",
+    secure: ueberHttps(),
     path: "/",
     maxAge: SITZUNGSDAUER_STUNDEN * 3600,
   };

src/server/actions/auth.ts

@@ -1,47 +1,13 @@
 "use server";
 
-import { cookies, headers } from "next/headers";
+import { cookies } from "next/headers";
 import { redirect } from "next/navigation";
-import { cookieOptionen, SITZUNGS_COOKIE, sitzungErzeugen } from "@/lib/sitzung";
+import { SITZUNGS_COOKIE } from "@/lib/sitzung";
-import { clientIp } from "@/lib/ratelimit";
 import { protokolliere } from "@/server/audit";
-import { AnmeldeFehler, mitPasswortAnmelden } from "@/server/auth/benutzer";
-import type { AktionsErgebnis } from "./kunden";
-
-/** Anmeldung mit E-Mail und Passwort (Rückfallweg, wenn OIDC nicht erreichbar ist). */
-export async function anmelden(_vorher: AktionsErgebnis, formular: FormData): Promise<AktionsErgebnis> {
-  const email = formular.get("email")?.toString().trim() ?? "";
-  const passwort = formular.get("passwort")?.toString() ?? "";
-  const ziel = formular.get("ziel")?.toString() || "/";
-
-  if (!email || !passwort) {
-    return { fehler: "Bitte E-Mail-Adresse und Passwort eingeben." };
-  }
-
-  try {
-    const kopfzeilen = await headers();
-    const benutzer = await mitPasswortAnmelden(email, passwort, clientIp(kopfzeilen));
-
-    const token = await sitzungErzeugen({
-      benutzerId: benutzer.id,
-      email: benutzer.email,
-      name: benutzer.name,
-      herkunft: "passwort",
-    });
-
-    (await cookies()).set(SITZUNGS_COOKIE, token, cookieOptionen());
-  } catch (fehler) {
-    if (fehler instanceof AnmeldeFehler) return { fehler: fehler.message };
-    throw fehler;
-  }
-
-  // Nur eigene Pfade als Ziel zulassen, damit die Anmeldung nicht auf fremde Seiten führt.
-  redirect(ziel.startsWith("/") && !ziel.startsWith("//") ? ziel : "/");
-}
 
+/** Abmelden aus dem Benutzermenü. Die Anmeldung selbst läuft über /api/auth/anmelden. */
 export async function abmelden() {
-  const speicher = await cookies();
+  (await cookies()).delete(SITZUNGS_COOKIE);
-  speicher.delete(SITZUNGS_COOKIE);
   await protokolliere("abmeldung", "Benutzer", null, {});
   redirect("/login");
 }

src/server/alerts/abgleich.ts

@@ -82,26 +82,27 @@ export async function alertsAbgleichen(jetzt: Date = new Date()): Promise<Abglei
   const kontext = await kontextLaden(jetzt);
   const kandidaten = alleRegelnPruefen(kontext);
 
-  const offene = await prisma.alert.findMany({ where: { erledigtAm: null } });
+  // Alle betroffenen Warnungen in einem Zug laden: die offenen und die, deren Fall wieder auftritt.
+  const fingerprints = kandidaten.map((k) => k.fingerprint);
+  const [offene, bekannte] = await Promise.all([
+    prisma.alert.findMany({ where: { erledigtAm: null } }),
+    fingerprints.length > 0
+      ? prisma.alert.findMany({ where: { fingerprint: { in: fingerprints } } })
+      : Promise.resolve([]),
+  ]);
+
   const offeneNachFingerprint = new Map(offene.map((alert) => [alert.fingerprint, alert]));
+  const bekannteNachFingerprint = new Map(bekannte.map((alert) => [alert.fingerprint, alert]));
   const kandidatenNachFingerprint = new Map(kandidaten.map((k) => [k.fingerprint, k]));
 
   const neu = kandidaten.filter((k) => !offeneNachFingerprint.has(k.fingerprint));
   const verschwunden = offene.filter((alert) => !kandidatenNachFingerprint.has(alert.fingerprint));
 
-  for (const kandidat of neu) {
+  // Fälle, die es noch nie gab: in einem Rutsch anlegen.
-    // Ein früher erledigter Fall taucht wieder auf: denselben Eintrag erneut öffnen.
+  const wirklichNeu = neu.filter((k) => !bekannteNachFingerprint.has(k.fingerprint));
-    await prisma.alert.upsert({
+  if (wirklichNeu.length > 0) {
-      where: { fingerprint: kandidat.fingerprint },
+    await prisma.alert.createMany({
-      update: {
+      data: wirklichNeu.map((kandidat) => ({
-        titel: kandidat.titel,
-        beschreibung: kandidat.beschreibung,
-        schwere: kandidat.schwere,
-        erledigtAm: null,
-        quittiertAm: null,
-        geoeffnetAm: jetzt,
-      },
-      create: {
         fingerprint: kandidat.fingerprint,
         regel: kandidat.regel,
         schwere: kandidat.schwere,
@@ -111,6 +112,22 @@ export async function alertsAbgleichen(jetzt: Date = new Date()): Promise<Abglei
         kundeId: kandidat.kundeId,
         laufzeitId: kandidat.laufzeitId,
         geoeffnetAm: jetzt,
+      })),
+      skipDuplicates: true,
+    });
+  }
+
+  // Früher erledigte Fälle, die wieder auftreten: denselben Eintrag erneut öffnen.
+  for (const kandidat of neu.filter((k) => bekannteNachFingerprint.has(k.fingerprint))) {
+    await prisma.alert.update({
+      where: { fingerprint: kandidat.fingerprint },
+      data: {
+        titel: kandidat.titel,
+        beschreibung: kandidat.beschreibung,
+        schwere: kandidat.schwere,
+        erledigtAm: null,
+        quittiertAm: null,
+        geoeffnetAm: jetzt,
       },
     });
   }

src/server/queries/dashboard.ts

@@ -47,8 +47,12 @@ export async function hostsNachAblauf(jetzt: Date = new Date()) {
   });
 }
 
-/** Offene Rechnungspunkte als Aufgabenliste fürs Dashboard. */
+/**
-export async function offeneAufgaben() {
+ * Offene Rechnungspunkte als Aufgabenliste fürs Dashboard.
+ * Begrenzt, weil die Karte sonst bei vielen Hosts endlos lang wird – die vollständige
+ * Liste steht unter „Rechnungen“.
+ */
+export async function offeneAufgaben(grenze = 12) {
   const laufzeiten = await prisma.laufzeit.findMany({
     where: {
       status: "BESTAETIGT",
@@ -116,5 +120,5 @@ export async function offeneAufgaben() {
     }
   }
 
-  return aufgaben;
+  return { aufgaben: aufgaben.slice(0, grenze), gesamt: aufgaben.length };
 }

tests/auth.test.ts

@@ -54,7 +54,18 @@ describe("Sitzungen", () => {
     ).rejects.toThrow(/APP_SECRET/);
   });
 
-  it("setzt das Cookie nur über HTTPS, wenn produktiv gebaut wurde", () => {
+  it("setzt Secure nur, wenn das Dashboard über HTTPS läuft", () => {
+    const vorher = process.env.APP_URL;
+
+    process.env.APP_URL = "https://proxledger.example.de";
+    expect(cookieOptionen().secure).toBe(true);
+
+    // Produktiv gebaut, aber über http erreichbar: sonst verwirft der Browser das Cookie
+    // und die Anmeldung landet sofort wieder auf der Anmeldeseite.
+    process.env.APP_URL = "http://192.168.1.50:3000";
+    expect(cookieOptionen().secure).toBe(false);
+
+    process.env.APP_URL = vorher;
     expect(cookieOptionen().httpOnly).toBe(true);
     expect(cookieOptionen().sameSite).toBe("lax");
   });