Version 2.8.31: Protokollverlauf verlangt keine Bestaetigung mehr

apps/tesm/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tesm"
-version = "2.8.13"
+version = "2.8.31"
 description = "TESM -- Verwaltung und Ueberwachung von PoE-Endgeraeten und Aruba-Switchen"
 requires-python = ">=3.11"
 dependencies = [

apps/tesm/src/tesm/blueprints/dashboard.py

@@ -14,7 +14,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from flask import Blueprint, abort, render_template, request
+from flask import Blueprint, abort, render_template, request, url_for
 from tesm_core.security.sessions import fragment
 from tesm_core.extension import core, db
 
@@ -49,6 +49,13 @@ def _tiles(*, authenticated: bool) -> dict[str, Any]:
     # Einmal je Seitenaufbau, nicht je Kachel: der Port ist fuer alle derselbe,
     # und ohne das Recht wird gar nicht erst nachgesehen.
     vnc_erlaubt = detailed and current_user.has("device_vnc.execute")
+    # Das Fenster setzt eine frische Passwortbestaetigung voraus -- dieselbe
+    # Schwelle wie die Geraeteseite. Fehlt sie, fuehrt der Knopf dorthin: dort
+    # wird danach gefragt, und ein Fenster, das sich mit "bitte erst
+    # bestaetigen" oeffnet, waere ein Klick fuer nichts.
+    from tesm_core.auth.service import reauth_is_fresh
+
+    vnc_fenster = vnc_erlaubt and reauth_is_fresh()
     vnc_port = (
         int(core().settings.get(conn, "vnc_port") or vnc_dienst.STANDARD_PORT)
         if vnc_erlaubt and core().settings.get(conn, "vnc_enabled")
@@ -95,9 +102,16 @@ def _tiles(*, authenticated: bool) -> dict[str, Any]:
                     # Verbindungsversuch je Kachel und Aufbau waere genau die
                     # Art Hintergrundlast, die niemand bestellt hat.
                     "vnc": bool(vnc_port and row["vnc_open"]),
+                    "vnc_quelle": (
+                        url_for("screen.session_json", device_id=int(row["id"]))
+                        if vnc_port and row["vnc_open"]
+                        else ""
+                    ),
                 }
             )
         tiles.append(entry)
+    # Merker fuer die Vorlage: nur mit frischer Bestaetigung gibt es das
+    # Fenster; sonst zeigt die Kachel auf die Seite.
 
     sections = [
         {
@@ -142,6 +156,7 @@ def _tiles(*, authenticated: bool) -> dict[str, Any]:
         "counts": counts,
         "sections": sections,
         "detailed": detailed,
+        "vnc_fenster": vnc_fenster,
         "interval": int(core().settings.get(conn, "monitor_interval_seconds") or 300),
     }
 

apps/tesm/src/tesm/blueprints/devices.py

@@ -318,12 +318,16 @@ def _restart_as_job(extension: Any, conn: Any, device: Any, method: Any):  # typ
     # Der Auftrag laeuft im Hintergrund und meldet sein Ergebnis erst, wenn das
     # Geraet zurueck ist. Der Zustand muss aber sofort umschlagen -- sonst sieht
     # die Uebersicht aus wie eine, in der nichts passiert ist.
+    live = extension.registry.get("live_log")
     with transaction():
-        monitor.mark_restarting(conn, int(device["id"]))
+        monitor.mark_restarting(
+            conn, int(device["id"]), live=live, trigger="manuell", method=method.key
+        )
 
     maintenance_service.start_background(
         maintenance_service.run_reboot,
         database=extension.database,
+        live=live,
         job_id=handle.id,
         device=dict(device),
         username=username,
@@ -374,13 +378,13 @@ def detail(device_id: int):
 
 
 def _vnc_zugang(conn: Any, device: dict[str, Any]) -> vnc.Zugang | None:
-    """Der Bildschirmzugriff dieses Clients -- frisch gefragt, nicht geraten.
+    """Der Bildschirmzugriff dieses Clients -- aus dem, was bekannt ist.
 
-    Die Kacheln der Statusuebersicht nehmen den Stand aus dem letzten
-    Ueberwachungsdurchlauf; hier geht es um **ein** Geraet, also fragt die Seite
-    selbst nach (ein halbe Sekunde Zeitlimit, und nur wenn der Client gerade
-    erreichbar ist). Das Ergebnis wird gleich festgehalten -- dann stimmt auch
-    die Kachel, ohne auf den naechsten Durchlauf zu warten.
+    Diese Seite fragt das Geraet **nicht**. Erreichbarkeit kommt aus dem
+    Ueberwachungsdurchlauf, die Anmeldeverfahren aus der letzten
+    ausdruecklichen Pruefung. Der Grund steht in :func:`vnc.zugang_gemerkt`:
+    jede Messung ist eine angefangene Protokollverhandlung, und ein RealVNC
+    Server zaehlt so etwas mit.
     """
     extension = core()
     if not current_user.has("device_vnc.execute"):
@@ -388,12 +392,7 @@ def _vnc_zugang(conn: Any, device: dict[str, Any]) -> vnc.Zugang | None:
     if not extension.settings.get(conn, "vnc_enabled"):
         return None
     port = int(extension.settings.get(conn, "vnc_port") or vnc.STANDARD_PORT)
-    online = str(device.get("state") or "") == "online" and not device.get("deleted_at")
-    zugang = vnc.zugang(device, port=port, pruefen=online)
-    if online:
-        with transaction():
-            monitor.merke_vnc(conn, int(device["id"]), zugang.erreichbar, zugang.ziel)
-    return zugang
+    return vnc.zugang_gemerkt(device, port=port)
 
 
 @bp.get("/<int:device_id>/vnc")
@@ -416,15 +415,21 @@ def vnc_connection(device_id: int):
     ziel = vnc.ziel(device)
     if not ziel:
         abort(404)
-    with transaction():
-        _audit(
-            conn,
-            "device.vnc_opened",
-            str(device["name"]),
-            f"Verbindungsdatei für {ziel}:{port}",
+    # Kein Eintrag in der Aenderungskette: eine Verbindungsdatei ist derselbe
+    # Vorgang wie die Sitzung im Browser, nur fuer einen Viewer auf dem
+    # Arbeitsplatz -- und sie aendert nichts. Wer zusieht, steht im laufenden
+    # Protokoll; das Aenderungsprotokoll bleibt die Liste der Eingriffe.
+    live = core().registry.get("live_log")
+    if live is not None:
+        live.info(
+            "vnc", f"{current_user.username} lädt die Verbindungsdatei für {device['name']}"
         )
     return Response(
-        vnc.verbindungsdatei(device, port=port),
+        vnc.verbindungsdatei(
+            device,
+            port=port,
+            warnung_aus=bool(extension.settings.get(conn, "vnc_warn_unencrypted_off")),
+        ),
         mimetype="application/octet-stream",
         headers={
             "Content-Disposition": f'attachment; filename="{vnc.dateiname(device)}"',

apps/tesm/src/tesm/blueprints/dhcp.py

@@ -20,7 +20,7 @@ from tesm_core.auth.service import client_ip
 from tesm_core.db import Database
 from tesm_core.extension import core, db, transaction
 
-from ..services import kea
+from ..services import inventory, kea
 from ..permissions import DHCP_PAGE
 
 bp = Blueprint("dhcp", __name__, url_prefix="/dhcp")
@@ -73,6 +73,12 @@ def overview():
     # Zustand aus den laufenden Leases -- wie im Windows-DHCP.
     reservations = kea.annotate_reservations(reservations, leases)
     reserved_ips = {str(entry["ip"]) for entry in reservations}
+    # Wozu es schon einen Client gibt, ist nicht mehr zu uebernehmen -- auch
+    # wenn dessen Adresse (noch) keine Reservierung hat.
+    bekannte_macs = {
+        inventory.normalize_mac(str(zeile["mac"]))
+        for zeile in Database.all(conn, "SELECT mac FROM devices WHERE deleted_at IS NULL")
+    }
 
     return render_template(
         "tesm/dhcp.html",
@@ -90,6 +96,7 @@ def overview():
         manual_reservations=Database.all(conn, "SELECT * FROM dhcp_reservations ORDER BY ip"),
         leases=leases,
         reserved_ips=reserved_ips,
+        bekannte_macs=bekannte_macs,
         networks=networks,
         default_gateway=kea.default_gateway(sysops) if sysops else "",
         service=kea.service_state(sysops) if sysops else {},
@@ -447,6 +454,91 @@ def add_reservation():
     return _write_and_redirect()
 
 
+@bp.post("/lease/adopt")
+# Zwei Rechte, mit Absicht: die Uebernahme ist eine eigene Funktion, das
+# Ergebnis aber ein Client. Wer keine Clients anlegen darf, legt auch hier
+# keine an -- sonst waere diese Schaltflaeche eine Hintertuer an der
+# Geraeteverwaltung vorbei.
+@permission_required("dhcp_lease_adopt.execute", "devices.create")
+def adopt_lease():
+    """Macht aus einer dynamisch vergebenen Adresse einen ueberwachten Client.
+
+    Die Angaben kommen **nicht** aus dem Formular, sondern aus der Lease-Datei:
+    geschickt wird nur die MAC, alles Weitere liest TESM frisch nach. Damit
+    heisst "Uebernahme" auch Uebernahme -- und eine Lease, die zwischen
+    Seitenaufbau und Klick abgelaufen oder umgezogen ist, faellt auf, statt
+    stillschweigend einen falschen Datensatz anzulegen.
+    """
+    extension = core()
+    conn = db()
+    sysops = extension.sysops
+    gesucht = inventory.normalize_mac(request.form.get("mac") or "")
+    leases = kea.read_leases(sysops) if sysops else []
+    lease = next((eintrag for eintrag in leases if eintrag.mac == gesucht), None)
+    if lease is None:
+        flash(
+            "Zu dieser MAC liegt keine Lease mehr vor. Die Liste war nicht mehr aktuell.",
+            "warning",
+        )
+        return redirect(url_for("dhcp.overview"))
+
+    # Nur dynamische. Eine Adresse, die schon reserviert ist, gehoert bereits
+    # zu einem gepflegten Datensatz -- da gibt es nichts zu uebernehmen.
+    networks = kea.detect_networks(sysops) if sysops else []
+    reserviert = {
+        str(eintrag["ip"])
+        for eintrag in kea.collect_reservations(
+            conn, only_networks=kea.configured_networks(conn, networks)
+        )
+    }
+    if lease.address in reserviert:
+        flash(
+            f"{lease.address} ist bereits reserviert – diese Lease ist nicht dynamisch.",
+            "warning",
+        )
+        return redirect(url_for("dhcp.overview"))
+
+    # Der Hostname aus der Lease ist der Name, den das Geraet selbst nennt.
+    # Fehlt er, steht die Adresse da: ein Name wie "Gerät 7" sagt weniger.
+    name = (lease.hostname or "").strip() or f"Client {lease.address}"
+    try:
+        with transaction():
+            device_id = inventory.create_device(
+                conn,
+                name=name,
+                mac=lease.mac,
+                ip=lease.address,
+                switch_id=None,
+                port="",
+                credential_id=None,
+                ssh_port=None,
+                # Ohne Switch und Port gibt es keinen PoE-Neustart. Mit
+                # eingeschaltetem Automatismus schriebe die Ueberwachung bei
+                # jedem Ausfall einen Fehlschlag ins Protokoll, den niemand
+                # abstellen kann. Einschalten kann man ihn, sobald der Port
+                # eingetragen ist.
+                auto_restart=False,
+                actor=current_user.username,
+            )
+    except inventory.ValidationError as exc:
+        flash(str(exc), "danger")
+        return redirect(url_for("dhcp.overview"))
+
+    _audit(
+        "device.created",
+        name,
+        f"aus dynamischer Lease {lease.address} ({lease.mac}) übernommen",
+        severity="notice",
+    )
+    flash(
+        f"{name} wurde als Client übernommen. Switch, Port und Zugangsdaten fehlen noch – "
+        "ohne sie gibt es keinen PoE-Neustart und keine Wartung. Die feste Adresse entsteht "
+        "beim nächsten Schreiben der DHCP-Konfiguration.",
+        "success",
+    )
+    return redirect(url_for("devices.detail", device_id=device_id))
+
+
 @bp.post("/reservation/<int:reservation_id>/delete")
 @permission_required("dhcp_reservations.delete")
 def delete_reservation(reservation_id: int):

apps/tesm/src/tesm/blueprints/logs.py

@@ -66,4 +66,5 @@ def restarts():
         method=method,
         methods=tuple(monitor.METHOD_LABELS.items()),
         method_labels=monitor.METHOD_LABELS,
+        trigger_labels=monitor.TRIGGER_LABELS,
     )

apps/tesm/src/tesm/blueprints/maintenance.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 from flask import Blueprint, abort, flash, jsonify, redirect, render_template, request, url_for
 from tesm_core.security.sessions import fragment
 from tesm_core import audit
-from tesm_core.auth.models import current_user, permission_required
+from tesm_core.auth.models import current_user, permission_required, reauth_required
 from tesm_core.auth.service import client_ip
 from tesm_core.db import Database
 from tesm_core.extension import core, db, transaction
@@ -77,18 +77,20 @@ def _query_devices(conn) -> list[dict]:  # type: ignore[no-untyped-def]
 
 @bp.get("/")
 @permission_required(*SERVICING_PAGE, mode="any")
-def overview():
+def overview():  # noqa: C901 - eine Seite, drei Aufgaben
     conn = db()
     return render_template(
         "tesm/maintenance.html",
         devices=_eligible_devices(conn),
         jobs=service.list_jobs(conn),
+        auftragslage=service.letzter_auftrag_je_geraet(conn),
         category_labels=dict(inventory.CREDENTIAL_CATEGORIES),
         category_effects=inventory.CATEGORY_EFFECTS,
         update_category=inventory.MAINTENANCE_CATEGORY,
         terminal_enabled=bool(core().settings.get(conn, "terminal_clients_enabled")),
         windows_tool_missing=_windows_tool_missing(conn),
         windows_package=windowsops.REQUIRED_PACKAGE,
+        befehlsvorlagen=service.BEFEHLSVORLAGEN,
     )
 
 
@@ -144,12 +146,19 @@ def install_windows_tool():
 def status():
     """Zustand der Auftraege -- aus der Datenbank, nicht aus dem Prozessspeicher."""
     conn = db()
-    jobs = service.list_jobs(conn, limit=30)
+    jobs = service.laufende_und_letzte(conn, limit=30)
     running = any(job["state"] in {"pending", "running"} for job in jobs)
     return jsonify(
         {
             "running": running,
             "poll_ms": 2000 if running else 10000,
+            # Der Zustand der Geraete gehoert dazu: die Seite steht sonst mit
+            # dem Stand ihres Aufbaus da, und wer nach einem Neustart auf die
+            # Rueckkehr wartet, sieht "unbekannt", bis er von Hand neu laedt.
+            "devices": [
+                {"id": int(row["id"]), "state": str(row["state"] or "unknown")}
+                for row in _eligible_devices(conn)
+            ],
             "jobs": [
                 {
                     "id": job["id"],
@@ -159,6 +168,16 @@ def status():
                     "progress": job["progress"],
                     "message": job["message"],
                     "updated_at": job["updated_at"],
+                    # Die letzten Zeilen -- nur von dem, was gerade laeuft.
+                    # Mitlesen heisst mitlesen: wer nach der Wartung wissen
+                    # will, was war, oeffnet den Auftrag. Alles mitzuschicken
+                    # hiesse, alle zwei Sekunden das gesamte Protokoll aller
+                    # Geraete zu uebertragen.
+                    "output": (
+                        service.letzte_zeilen(str(job["output"] or ""))
+                        if service.eben_fertig(dict(job))
+                        else ""
+                    ),
                 }
                 for job in jobs
             ],
@@ -187,7 +206,7 @@ def job_output(job_id: str):
     return render_template("tesm/_maintenance_output.html", job=job)
 
 
-def _start(kind: str) -> None:
+def _start(kind: str, befehl: str = "") -> None:
     extension = core()
     conn = db()
     device_ids = [int(value) for value in request.form.getlist("device_ids") if value.isdigit()]
@@ -233,12 +252,27 @@ def _start(kind: str) -> None:
                 actor_id=current_user.id,
                 action=kind,
                 target=str(device["name"]),
-                detail=f"Auftrag {handle.id}",
+                # Beim Befehl gehoert sein Wortlaut hierher und nicht nur die
+                # Auftragsnummer: was gelaufen ist, muss aus dem Protokoll
+                # hervorgehen, auch wenn der Auftrag laengst aus dem Verlauf
+                # gerollt ist.
+                detail=f"Auftrag {handle.id}" + (f": {befehl}" if befehl else ""),
                 ip=client_ip(),
-                severity="notice",
+                severity="warning" if befehl else "notice",
             )
 
-        if kind == service.JOB_KIND_UPDATE:
+        if kind == service.JOB_KIND_COMMAND:
+            service.start_background(
+                service.run_command,
+                database=extension.database,
+                job_id=handle.id,
+                device=dict(device),
+                username=username,
+                password=password,
+                befehl=befehl,
+                timeout=int(extension.settings.get(conn, "maintenance_command_timeout") or 900),
+            )
+        elif kind == service.JOB_KIND_UPDATE:
             service.start_background(
                 service.run_update,
                 database=extension.database,
@@ -249,27 +283,35 @@ def _start(kind: str) -> None:
                 timeout=int(extension.settings.get(conn, "maintenance_command_timeout") or 900),
             )
         else:
+            weg = (
+                service.METHOD_RPC
+                if str(device["category"]) == inventory.NON_SSH_CATEGORY
+                else service.METHOD_SSH
+            )
             # Sofort sichtbar, nicht erst wenn das Geraet zurueck ist.
             with transaction() as verbindung:
-                monitor.mark_restarting(verbindung, int(device["id"]))
+                monitor.mark_restarting(
+                    verbindung,
+                    int(device["id"]),
+                    live=extension.registry.get("live_log"),
+                    trigger="maintenance",
+                    method=weg,
+                )
             service.start_background(
                 service.run_reboot,
                 database=extension.database,
+                live=extension.registry.get("live_log"),
                 job_id=handle.id,
                 device=dict(device),
                 username=username,
                 password=password,
                 wait_seconds=int(extension.settings.get(conn, "maintenance_reboot_wait") or 300),
                 actor=current_user.username,
-                # Hier steht in ``category`` die Kategorie der *Zugangsdaten*
-                # (siehe _query_devices) -- daraus folgt der Weg. Uebergeben
-                # statt in run_reboot erraten: dort bedeutet derselbe
-                # Schluessel je Herkunft etwas anderes.
-                method=(
-                    service.METHOD_RPC
-                    if str(device["category"]) == inventory.NON_SSH_CATEGORY
-                    else service.METHOD_SSH
-                ),
+                # Der Weg steht oben: in ``category`` liegt die Kategorie der
+                # *Zugangsdaten* (siehe _query_devices), daraus folgt er.
+                # Uebergeben statt in run_reboot erraten -- dort bedeutet
+                # derselbe Schluessel je Herkunft etwas anderes.
+                method=weg,
             )
         started += 1
 
@@ -289,3 +331,22 @@ def start_update():
 def start_reboot():
     _start(service.JOB_KIND_REBOOT)
     return redirect(url_for("maintenance.overview"))
+
+
+@bp.post("/command")
+@permission_required("servicing_command.execute")
+@reauth_required
+def start_command():
+    """Eine Befehlszeile auf allen ausgewaehlten Clients.
+
+    Dieselbe Schwelle wie die Konsole: eigenes Recht **und** eine frische
+    Passwortbestaetigung. Wer hier etwas eintippt, tut es auf einem Dutzend
+    Maschinen gleichzeitig, und niemand sieht dabei zu.
+    """
+    try:
+        befehl = service.befehl_pruefen(request.form.get("befehl", ""))
+    except ValueError as exc:
+        flash(str(exc), "danger")
+        return redirect(url_for("maintenance.overview"))
+    _start(service.JOB_KIND_COMMAND, befehl=befehl)
+    return redirect(url_for("maintenance.overview"))

apps/tesm/src/tesm/blueprints/screen.py

@@ -30,7 +30,15 @@ import threading
 import time
 from typing import Any
 
-from flask import Blueprint, abort, render_template
+from flask import (
+    Blueprint,
+    abort,
+    flash,
+    redirect,
+    render_template,
+    request,
+    url_for,
+)
 from tesm_core import audit
 from tesm_core.auth.models import current_user, permission_required, reauth_required
 from tesm_core.auth.service import client_ip, reauth_is_fresh
@@ -50,6 +58,10 @@ VERBINDUNGSLIMIT = 6.0
 #: bis ein Schub weitergereicht wird.
 BLOCK = 32 * 1024
 
+#: Wie oft nachgesehen wird, ob die Sitzung noch etwas tut. Kurz genug, dass
+#: das Trennen puenktlich ist, lang genug, dass das Nachsehen nichts kostet.
+TAKT = 1.0
+
 
 def _geraet(conn: Any, device_id: int) -> dict[str, Any] | None:
     device = inventory.get_device(conn, device_id)
@@ -58,6 +70,30 @@ def _geraet(conn: Any, device_id: int) -> dict[str, Any] | None:
     return device
 
 
+def _erklaerung(fehler: OSError) -> str:
+    """Die Fehlernummer in einem Satz, der weiterhilft.
+
+    "No route to host" und "Connection refused" sehen im Protokoll gleich
+    harmlos aus und bedeuten das Gegenteil voneinander: einmal kommt man gar
+    nicht hin, einmal kommt man hin und niemand hoert zu. Und beides hat mit
+    einem gelungenen Ping nichts zu tun -- der prueft eine andere Schicht.
+    """
+    import errno as fehlernummern
+
+    nummer = getattr(fehler, "errno", None)
+    if nummer == fehlernummern.EHOSTUNREACH:
+        return (
+            f"{fehler} – kein Weg dorthin. Eine Firewall oder eine Route steht "
+            "dazwischen; ein gelungener Ping sagt darüber nichts, der prüft eine "
+            "andere Schicht"
+        )
+    if nummer == fehlernummern.ECONNREFUSED:
+        return f"{fehler} – das Gerät ist erreichbar, aber auf diesem Port hört niemand"
+    if nummer == fehlernummern.ETIMEDOUT:
+        return f"{fehler} – keine Antwort; Paketfilter verwerfen meist stillschweigend"
+    return str(fehler)
+
+
 def _port(conn: Any) -> int:
     extension = core()
     if not extension.settings.get(conn, "vnc_enabled"):
@@ -71,11 +107,13 @@ def _port(conn: Any) -> int:
 def screen(device_id: int):
     """Die Seite mit der Leinwand.
 
-    Sie misst vor dem Verbinden, **wie** der VNC-Server sich authentifizieren
-    will. Bietet er nur Verfahren an, die der Browser-Client nicht kennt, steht
-    das als Satz auf der Seite -- mit der Zeile, die das auf dem Geraet aendert.
-    Der Unterschied zur schwarzen Flaeche ist der ganze Punkt: wer nicht weiss,
-    woran es liegt, sucht den Fehler bei TESM.
+    Sie beruehrt das Geraet nicht: die Sitzung selbst ist der einzige Anlass,
+    dort anzuklopfen. Was ueber die Anmeldeverfahren bekannt ist, steht in der
+    Datenbank -- aus der letzten ausdruecklichen Pruefung (Knopf "Verfahren
+    pruefen"). Dass diese Seite frueher selbst gemessen hat, war ein Fehler:
+    jede Messung ist eine angefangene und abgebrochene Protokollverhandlung,
+    und ein RealVNC Server zaehlt so etwas -- das Oeffnen der Seite hat der
+    Sitzung also selbst im Weg gestanden.
     """
     conn = db()
     device = _geraet(conn, device_id)
@@ -85,43 +123,156 @@ def screen(device_id: int):
     if not port:
         abort(404)
 
-    zugang = vnc.zugang(device, port=port, pruefen=str(device.get("state") or "") == "online")
-    benutzer, passwort = "", ""
-    darf_geheimnis = bool(current_user.has("credentials.secrets"))
-    if device.get("credential_id") and darf_geheimnis:
-        try:
-            benutzer, passwort = inventory.credential_secret(
-                conn, core().keystore, int(device["credential_id"])
-            )
-        except inventory.ValidationError:
-            benutzer, passwort = "", ""
-        if passwort:
-            with core().database.transaction(conn):
-                audit.log(
-                    conn,
-                    actor=current_user.username,
-                    actor_id=current_user.id,
-                    action="device.vnc_credentials_used",
-                    target=str(device["name"]),
-                    detail=(
-                        f"Hinterlegte Zugangsdaten ({benutzer}) an die Bildschirmsitzung "
-                        "übergeben"
-                    ),
-                    ip=client_ip(),
-                    severity="warning",
-                )
-
+    zugang = vnc.zugang_gemerkt(device, port=port)
     return render_template(
         "tesm/screen.html",
         device=device,
         zugang=zugang,
-        websocket_path=f"/ws/screen/{device_id}",
-        vorgaben={"username": benutzer, "password": passwort},
-        darf_geheimnis=darf_geheimnis,
+        quelle=url_for("screen.session_json", device_id=device_id),
+        darf_geheimnis=bool(current_user.has("credentials.secrets")),
         verfahren_name=vnc.verfahren_name,
     )
 
 
+def _zugangsdaten(conn: Any, device: dict[str, Any]) -> tuple[str, str]:
+    """Hinterlegte Zugangsdaten -- nur fuer den, der Geheimnisse sehen darf.
+
+    Weil der Browser die Anmeldung fuehrt, muessen sie in die Seite. Wer
+    Geheimnisse nicht sehen darf, bekommt sie auch hier nicht: sonst waere die
+    Bildschirmsitzung der Umweg, auf dem jeder das Passwort liest. Jede
+    Herausgabe steht im Aenderungsprotokoll -- das ist kein Zusehen, sondern
+    ein Zugriff auf etwas, das sonst niemand sieht.
+    """
+    if not device.get("credential_id") or not current_user.has("credentials.secrets"):
+        return "", ""
+    try:
+        benutzer, passwort = inventory.credential_secret(
+            conn, core().keystore, int(device["credential_id"])
+        )
+    except inventory.ValidationError:
+        return "", ""
+    if passwort:
+        with core().database.transaction(conn):
+            audit.log(
+                conn,
+                actor=current_user.username,
+                actor_id=current_user.id,
+                action="device.vnc_credentials_used",
+                target=str(device["name"]),
+                detail=(
+                    f"Hinterlegte Zugangsdaten ({benutzer}) an die Bildschirmsitzung "
+                    "übergeben"
+                ),
+                ip=client_ip(),
+                severity="warning",
+            )
+    return benutzer, passwort
+
+
+@bp.post("/monitoring/clients/<int:device_id>/screen/probe")
+@permission_required("device_vnc.execute")
+@reauth_required
+def probe(device_id: int):
+    """Fragt das Geraet ausdruecklich, wie es sich authentifizieren will.
+
+    Ein Knopf und keine Nebenwirkung des Seitenaufbaus: die Messung bricht eine
+    Protokollverhandlung ab, und RealVNC zaehlt das. Sie gehoert in die Hand
+    dessen, der gerade sucht -- nicht in jeden Aufruf.
+    """
+    conn = db()
+    device = _geraet(conn, device_id)
+    if device is None:
+        abort(404)
+    port = _port(conn)
+    if not port:
+        abort(404)
+
+    from ..services import monitor
+
+    zugang = vnc.zugang(device, port=port)
+    with core().database.transaction(conn):
+        monitor.merke_vnc(conn, int(device["id"]), zugang.erreichbar, zugang.ziel)
+        monitor.merke_verfahren(conn, int(device["id"]), zugang.verfahren, zugang.absage)
+    if zugang.absage:
+        flash(f"Der Server antwortet: „{zugang.absage}“", "warning")
+    elif zugang.verfahren:
+        flash(
+            "Angebotene Anmeldeverfahren: "
+            + ", ".join(vnc.verfahren_name(v) for v in zugang.verfahren),
+            "info",
+        )
+    else:
+        flash(f"{zugang.ziel}:{port} hat nicht geantwortet.", "danger")
+    return redirect(url_for("screen.screen", device_id=device_id))
+
+
+@bp.get("/monitoring/clients/<int:device_id>/screen/session")
+@permission_required("device_vnc.execute")
+def session_json(device_id: int):
+    """Alles, was der Client fuer eine Sitzung braucht -- als Auskunft.
+
+    Warum nicht in die Seite geschrieben: dieselbe Sitzung laeuft auch im
+    Fenster der Statusuebersicht, und dort stuenden sonst die Zugangsdaten
+    **jedes** Geraets im Quelltext der Seite. So holt sie sich nur, wer eine
+    Sitzung wirklich oeffnet -- und nur fuer das eine Geraet.
+
+    Die frische Passwortbestaetigung wird hier von Hand geprueft statt ueber
+    den Dekorator: der wuerde auf eine Seite umleiten, und eine Umleitung ist
+    fuer einen Abruf im Hintergrund keine Auskunft. 409 mit einem Hinweis ist
+    eine.
+    """
+    conn = db()
+    device = _geraet(conn, device_id)
+    if device is None:
+        abort(404)
+    port = _port(conn)
+    if not port:
+        abort(404)
+    if not reauth_is_fresh():
+        return {"reauth": True}, 409
+
+    zugang = vnc.zugang_gemerkt(device, port=port)
+    benutzer, passwort = _zugangsdaten(conn, device)
+    return {
+        "name": str(device["name"]),
+        "socket": f"/ws/screen/{device_id}",
+        "ziel": f"{zugang.ziel}:{zugang.port}",
+        "verfahren": list(zugang.verfahren),
+        "bewaehrt": zugang.bewaehrt,
+        "hinderungsgrund": zugang.hinderungsgrund,
+        "meldeweg": url_for("screen.merke_verfahren", device_id=device_id),
+        "vorgaben": {"username": benutzer, "password": passwort},
+    }
+
+
+@bp.post("/monitoring/clients/<int:device_id>/screen/method")
+@permission_required("device_vnc.execute")
+def merke_verfahren(device_id: int):
+    """Der Browser meldet, womit die Sitzung zustande kam.
+
+    Nur er weiss es: die Strecke reicht Bytes durch und liest das Protokoll
+    nicht. Beim naechsten Mal faengt die Seite damit an, statt wieder bei der
+    ersten Wahl des Servers -- die hier schon einmal abgerissen ist und deren
+    Absage sich ein sperrender RealVNC Server Minuten Zeit laesst.
+    """
+    conn = db()
+    device = _geraet(conn, device_id)
+    if device is None:
+        abort(404)
+    try:
+        verfahren = int(request.json.get("verfahren", 0)) if request.json else 0
+    except (TypeError, ValueError):
+        verfahren = 0
+    if not 0 < verfahren < 256:
+        return {"ok": False}, 400
+
+    from ..services import monitor
+
+    with core().database.transaction(conn):
+        monitor.merke_verfahren_das_traegt(conn, int(device["id"]), verfahren)
+    return {"ok": True}
+
+
 def init_app(app) -> None:  # type: ignore[no-untyped-def]
     """Meldet Seite und -- falls verfuegbar -- die WebSocket-Strecke an."""
     app.register_blueprint(bp)
@@ -138,6 +289,26 @@ def init_app(app) -> None:  # type: ignore[no-untyped-def]
     def screen_socket(ws, device_id: int):  # type: ignore[no-untyped-def]
         _strecke(ws, device_id)
 
+    @sock.route("/ws/probe")
+    def probe_socket(ws):  # type: ignore[no-untyped-def]
+        """Sagt "da", und mehr nicht.
+
+        Wozu: bricht eine Bildschirmsitzung ab, gibt es zwei sehr verschiedene
+        Ursachen -- der VNC-Server mag nicht, oder die WebSocket-Verbindung
+        kommt gar nicht erst durch (ein Proxy zwischen Browser und TESM, der
+        "Upgrade" nicht weiterreicht, ist der haeufigste Fall). Von aussen
+        sehen beide gleich aus: ein Abbruch ohne Grund. Diese Probe trennt
+        sie, ohne dass jemand ein Protokoll lesen muss.
+        """
+        if not current_user.is_authenticated:
+            ws.close(1008, "Nicht angemeldet.")
+            return
+        try:
+            ws.send("da")
+            ws.receive(timeout=2)
+        except Exception:  # noqa: BLE001 - der Browser ist weg, das ist keine Stoerung
+            pass
+
 
 def _strecke(ws, device_id: int) -> None:  # type: ignore[no-untyped-def]
     """Bytes hin, Bytes her -- und sonst nichts.
@@ -167,42 +338,116 @@ def _strecke(ws, device_id: int) -> None:  # type: ignore[no-untyped-def]
         ws.close(1008, "Für diesen Client ist kein Ziel bekannt.")
         return
 
-    try:
-        gegenstelle = socket.create_connection((host, port), timeout=VERBINDUNGSLIMIT)
-    except OSError as exc:
-        ws.close(1011, f"{host}:{port} antwortet nicht ({exc}).")
+    gegenstelle = None
+    ausweich = str(device.get("ip") or "").strip()
+    for versuch, ziel_host in enumerate([host] + ([ausweich] if ausweich != host else [])):
+        try:
+            gegenstelle = socket.create_connection((ziel_host, port), timeout=VERBINDUNGSLIMIT)
+            if versuch:
+                # Der Name fuehrte ins Leere, die Adresse nicht. Das ist eine
+                # Auskunft ueber das Netz, keine Nebensaechlichkeit: irgendwo
+                # zeigt ein Eintrag woandershin.
+                if live_log := extension.registry.get("live_log"):
+                    live_log.warning(
+                        "vnc",
+                        f"{host} war nicht erreichbar – Sitzung läuft über {ziel_host}",
+                    )
+                host = ziel_host
+            break
+        except OSError as exc:
+            letzter = exc
+    if gegenstelle is None:
+        ws.close(1011, f"{host}:{port} antwortet nicht ({_erklaerung(letzter)}).")
         return
+    # Das Zeitlimit galt dem *Aufbau* -- als Abbruchgrund taugt es nicht.
+    #
+    # ``create_connection`` setzt es an den Socket, und dort gilt es fuer jede
+    # weitere Leseoperation. Ein Bildschirm, auf dem sich gerade nichts tut,
+    # schickt sekundenlang nichts; nach sechs Sekunden Stille brach das Lesen
+    # mit einer Zeitueberschreitung ab, und die Sitzung war weg. Genau so
+    # beobachtet: Bild steht, nach fuenf bis zehn Sekunden Schluss.
+    #
+    # Stattdessen ein kurzer Takt: das Lesen laeuft immer wieder in ein
+    # Zeitlimit, und *das* ist kein Abbruch, sondern der Anlass nachzusehen,
+    # ob die Sitzung ueberhaupt noch etwas tut.
+    # Ohne das sammelt der Kern kleine Pakete, bis genug beisammen ist
+    # (Nagle) -- bei einem Bildschirm sind Tastendruck und Mausbewegung genau
+    # solche kleinen Pakete, und das Warten darauf faellt als Ruckeln auf.
+    gegenstelle.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+    gegenstelle.settimeout(TAKT)
+    leerlauf = int(extension.settings.get(conn, "vnc_idle_timeout") or 0)
 
+    # Ins **laufende** Protokoll, nicht in die Aenderungskette: eine
+    # Bildschirmsitzung aendert nichts an der Anlage. Das Aenderungsprotokoll
+    # soll beantworten, wer was umgestellt hat -- wer wann zugesehen hat,
+    # gehoert nicht in dieselbe Liste und macht sie in einem Betrieb mit
+    # ein paar Dutzend Geraeten unlesbar. Sichtbar ist die Sitzung trotzdem,
+    # solange sie laeuft.
     begonnen = time.monotonic()
-    with extension.database.transaction(conn):
-        audit.log(
-            conn,
-            actor=current_user.username,
-            actor_id=current_user.id,
-            action="device.screen_opened",
-            target=str(device["name"]),
-            detail=f"Bildschirmsitzung zu {host}:{port}",
-            ip=client_ip(),
-            severity="warning",
-        )
+    live = extension.registry.get("live_log")
+    if live is not None:
+        live.info("vnc", f"{current_user.username} öffnet den Bildschirm von {device['name']}")
 
     laeuft = threading.Event()
     laeuft.set()
+    #: Wann zuletzt etwas floss -- in *irgendeine* Richtung. Eine Liste, weil
+    #: beide Richtungen daran schreiben und eine Zuweisung in Python nicht in
+    #: die andere hineinlaufen kann.
+    zuletzt = [time.monotonic()]
+    #: Grund des Endes, falls wir selbst getrennt haben.
+    schluss = [""]
+    #: Kam ueberhaupt schon ein Byte vom Geraet?
+    gehoert = [False]
 
     def vom_geraet() -> None:
         """Alles, was der VNC-Server schickt, geht als Binaerrahmen weiter."""
         try:
             while laeuft.is_set():
-                daten = gegenstelle.recv(BLOCK)
+                try:
+                    daten = gegenstelle.recv(BLOCK)
+                except socket.timeout:
+                    # Kein Fehler, nur Stille -- und die bedeutet zweierlei,
+                    # je nachdem, ob die Sitzung schon stand.
+                    #
+                    # **Vor dem ersten Byte** ist Stille ein Befund: der Port
+                    # nimmt an, aber es kommt nichts. Genau so verhaelt sich
+                    # ein RealVNC Server, der die Adresse gerade aussperrt. Wer
+                    # das nicht erfaehrt, sieht ewig "Verbindung wird
+                    # aufgebaut" -- und sucht den Fehler bei uns.
+                    if not gehoert[0] and time.monotonic() - begonnen > VERBINDUNGSLIMIT:
+                        schluss[0] = (
+                            f"{host}:{port} nimmt die Verbindung an, schickt aber nichts. "
+                            "So verhält sich ein VNC-Server, der die Adresse gerade "
+                            "aussperrt (RealVNC: BlacklistTimeout) – ein Neustart des "
+                            "VNC-Dienstes auf dem Gerät räumt das ab."
+                        )
+                        break
+                    # **Danach** ist Stille der Normalfall: ein Bildschirm, auf
+                    # dem sich nichts tut, schickt nichts.
+                    if gehoert[0] and leerlauf and time.monotonic() - zuletzt[0] > leerlauf:
+                        schluss[0] = (
+                            f"Sitzung nach {leerlauf} Sekunden ohne Bewegung getrennt"
+                        )
+                        break
+                    continue
                 if not daten:
+                    if not gehoert[0]:
+                        schluss[0] = (
+                            f"{host}:{port} hat die Verbindung sofort wieder geschlossen."
+                        )
                     break
+                gehoert[0] = True
+                zuletzt[0] = time.monotonic()
                 ws.send(daten)
         except Exception:  # noqa: BLE001 - Abbruch ist der Normalfall, nicht die Stoerung
             pass
         finally:
             laeuft.clear()
             try:
-                ws.close()
+                if schluss[0]:
+                    ws.close(1000 if gehoert[0] else 1011, schluss[0])
+                else:
+                    ws.close()
             except Exception:  # noqa: BLE001
                 pass
 
@@ -219,6 +464,7 @@ def _strecke(ws, device_id: int) -> None:  # type: ignore[no-untyped-def]
                 # waere entweder ein Irrtum oder ein Versuch -- beides endet
                 # hier und nicht auf dem Geraet.
                 continue
+            zuletzt[0] = time.monotonic()
             gegenstelle.sendall(nachricht)
     except Exception:  # noqa: BLE001
         logger.debug("Bildschirmsitzung beendet (%s)", device["name"], exc_info=True)
@@ -230,14 +476,9 @@ def _strecke(ws, device_id: int) -> None:  # type: ignore[no-untyped-def]
             pass
         gegenstelle.close()
         dauer = int(time.monotonic() - begonnen)
-        with extension.database.session() as frisch, extension.database.transaction(frisch):
-            audit.log(
-                frisch,
-                actor=current_user.username,
-                actor_id=current_user.id,
-                action="device.screen_closed",
-                target=str(device["name"]),
-                detail=f"Dauer {dauer}s",
-                ip=client_ip(),
-                severity="info",
+        if live is not None:
+            live.info(
+                "vnc",
+                f"Bildschirmsitzung {device['name']} beendet ({dauer}s)"
+                + (f" – {schluss[0]}" if schluss[0] else ""),
             )

apps/tesm/src/tesm/blueprints/settings.py

@@ -105,6 +105,8 @@ def system():
                 "dashboard_public",
                 "vnc_enabled",
                 "vnc_port",
+                "vnc_idle_timeout",
+                "vnc_warn_unencrypted_off",
                 "terminal_switches_enabled",
                 "terminal_clients_enabled",
                 "terminal_idle_timeout",
@@ -147,6 +149,8 @@ def system_save():
         "dashboard_public",
         "vnc_enabled",
         "vnc_port",
+        "vnc_idle_timeout",
+        "vnc_warn_unencrypted_off",
         "terminal_switches_enabled",
         "terminal_clients_enabled",
         "terminal_idle_timeout",

apps/tesm/src/tesm/blueprints/terminal.py

@@ -76,6 +76,16 @@ CLIENT_COMMANDS: tuple[tuple[str, str], ...] = (
     ("journalctl -p err -n 50 --no-pager", "Letzte Fehler im Journal"),
     ("apt list --upgradable 2>/dev/null", "Verfügbare Aktualisierungen"),
     ("uname -a", "Kernel und Architektur"),
+    # Die beiden schreiben -- deshalb stehen sie am Ende und sagen es im Namen.
+    # Eine Vorlage fuellt nur das Eingabefeld; abgeschickt wird von Hand.
+    (
+        'echo "Encryption=AlwaysOff" | sudo tee -a /etc/vnc/config.d/common.custom',
+        "VNC: Streckenverschlüsselung abschalten (schreibt)",
+    ),
+    (
+        "sudo systemctl restart vncserver-x11-serviced",
+        "VNC-Dienst neu starten (schreibt)",
+    ),
 )
 
 

apps/tesm/src/tesm/navigation.py

@@ -128,7 +128,7 @@ NAVIGATION = NavTree(
             children=(
                 NavItem(
                     key="logs_live",
-                    label="Laufend",
+                    label="Live",
                     icon="terminal",
                     endpoint="logs.live",
                     permissions=("logs_live.read",),

apps/tesm/src/tesm/permissions.py

@@ -187,6 +187,24 @@ SERVICING_TOOL = Resource(
     action_hints={A.EXECUTE: "Installation auslösen."},
 )
 
+#: Ein freier Befehl auf vielen Geraeten ist das Maechtigste, was diese
+#: Anwendung kann -- und das Einzige, dessen Wirkung sie nicht kennt. Deshalb
+#: ein eigenes Recht, das niemand nebenbei bekommt: wer Pakete aktualisieren
+#: oder neu starten darf, tut etwas Umrissenes; wer hier etwas eintippt, tut
+#: alles, was ein Konto auf dem Geraet tun kann. Die Vorlagen nehmen dem den
+#: Alltag ab, nicht die Verantwortung.
+SERVICING_COMMAND = Resource(
+    key="servicing_command",
+    label="Befehl auf mehreren Geräten",
+    actions=(A.READ, A.EXECUTE),
+    hint="Eine Befehlszeile über SSH, auf allen ausgewählten Clients",
+    action_hints={
+        A.READ: "Die Karte sehen – und damit, was zuletzt lief.",
+        A.EXECUTE: "Befehl absenden. Verlangt eine frische Passwortbestätigung; "
+        "jeder Auftrag steht mit seinem Wortlaut im Änderungsprotokoll.",
+    },
+)
+
 #: Die Wartungsseite zeigt alle drei Aufgaben. Sie oeffnet, wer **eine** davon
 #: sehen darf -- und zeigt dann nur die. Als Konstante, damit die vier Routen
 #: dieselbe Antwort geben; einzeln getippt liefen sie irgendwann auseinander.
@@ -194,6 +212,7 @@ SERVICING_PAGE: tuple[str, ...] = (
     "servicing_update.read",
     "servicing_reboot.read",
     "servicing_tool.read",
+    "servicing_command.read",
 )
 
 #: Elf Funktionen hingen an ``dhcp.edit``: Grundeinstellungen, Subnetze,
@@ -245,6 +264,31 @@ DHCP_SERVICE = Resource(
     action_hints={A.EXECUTE: "Dienstzustand ändern."},
 )
 
+#: Eine dynamische Lease in einen Client verwandeln.
+#:
+#: Eigene Zeile, weil es eine eigene Entscheidung ist: hier wird aus einer
+#: Beobachtung ("dieses Geraet hat sich eine Adresse geholt") ein gepflegter
+#: Datensatz, den die Ueberwachung ab sofort anpingt und der beim naechsten
+#: Schreiben der Konfiguration eine feste Adresse bekommt. Wer Leases sehen
+#: darf, soll deshalb nicht automatisch welche uebernehmen duerfen.
+#:
+#: **Und es reicht allein nicht.** Die Uebernahme legt einen Client an, also
+#: verlangt die Route zusaetzlich "Clients: Anlegen". Sonst waere dies eine
+#: Hintertuer an der Geraeteverwaltung vorbei -- dieselbe Wirkung, anderes
+#: Formular. Beide Haken zusammen, oder die Schaltflaeche erscheint nicht.
+DHCP_LEASE_ADOPT = Resource(
+    key="dhcp_lease_adopt",
+    parent="dhcp_subnets",
+    label="DHCP: Lease als Client übernehmen",
+    actions=(A.READ, A.EXECUTE),
+    hint="Aus einer dynamisch vergebenen Adresse einen überwachten Client machen",
+    action_hints={
+        A.READ: "Die Schaltfläche an dynamischen Leases sehen.",
+        A.EXECUTE: "Client aus der Lease anlegen. Verlangt zusätzlich "
+        "'Clients: Anlegen' – es entsteht ein Gerätedatensatz.",
+    },
+)
+
 #: Die DHCP-Seite zeigt alle Abschnitte; jeder Abschnitt haengt an seiner
 #: eigenen Zeile. Geoeffnet wird sie, wer einen davon sehen darf.
 DHCP_PAGE: tuple[str, ...] = (
@@ -354,14 +398,21 @@ MAINTENANCE_AREA = Area(
     icon="wrench",
     hint="Paketpflege und Neustarts. Ohne diesen Zugang bleibt der Bereich "
     "verborgen – auch wenn einzelne Rechte darunter gesetzt sind.",
-    resources=(SERVICING_UPDATE, SERVICING_REBOOT, SERVICING_TOOL),
+    resources=(SERVICING_UPDATE, SERVICING_REBOOT, SERVICING_COMMAND, SERVICING_TOOL),
 )
 
 NETWORK_AREA = Area(
     key="network",
     label="Netzwerkdienste",
     icon="network",
-    resources=(DHCP_SUBNETS, DHCP_OPTIONS, DHCP_RESERVATIONS, DHCP_CONFIG, DHCP_SERVICE),
+    resources=(
+        DHCP_SUBNETS,
+        DHCP_OPTIONS,
+        DHCP_RESERVATIONS,
+        DHCP_LEASE_ADOPT,
+        DHCP_CONFIG,
+        DHCP_SERVICE,
+    ),
 )
 
 FILES_AREA = Area(

apps/tesm/src/tesm/schema.py

@@ -526,6 +526,32 @@ ALTER TABLE device_status ADD COLUMN vnc_types TEXT NOT NULL DEFAULT '';
 """
 
 
+# Version 13 ----------------------------------------------------------------
+#
+# Die Absage eines VNC-Servers und der Zeitpunkt der Verfahrensmessung. Beide
+# gehoeren getrennt vom Ueberwachungsdurchlauf gefuehrt: der fragt nur noch,
+# ob der Port annimmt (eine abgebrochene Protokollverhandlung sperrt bei
+# RealVNC die eigene Adresse aus), die Verfahren misst die Seite -- und auch
+# die nur, wenn die letzte Messung alt ist.
+V13 = """
+ALTER TABLE device_status ADD COLUMN vnc_reason TEXT NOT NULL DEFAULT '';
+ALTER TABLE device_status ADD COLUMN vnc_types_at TEXT;
+"""
+
+
+# Version 14 ----------------------------------------------------------------
+#
+# Welches Anmeldeverfahren zuletzt wirklich getragen hat. Der Server nennt
+# seine Reihenfolge, und die gilt -- aber wenn seine erste Wahl schon einmal
+# abgerissen ist und eine andere zum Bild gefuehrt hat, ist das ein Befund.
+# Ihn zu vergessen kostet bei jedem Oeffnen einen Fehlversuch, und RealVNC
+# laesst sich mit der Absage Zeit: gemessen zwei bis drei Minuten, bis das
+# Bild stand.
+V14 = """
+ALTER TABLE device_status ADD COLUMN vnc_method INTEGER NOT NULL DEFAULT 0;
+"""
+
+
 def uebergang_standardgruppen(conn) -> None:  # type: ignore[no-untyped-def]
     """Aus sieben Standardgruppen werden drei -- ohne jemandem etwas wegzunehmen.
 
@@ -571,4 +597,6 @@ TESM_MIGRATIONS: tuple[Migration, ...] = (
     Migration(version=10, name="vnc-erreichbarkeit", sql=V10),
     Migration(version=11, name="vnc-ziel", sql=V11),
     Migration(version=12, name="vnc-verfahren", sql=V12),
+    Migration(version=13, name="vnc-absage", sql=V13),
+    Migration(version=14, name="vnc-verfahren-das-traegt", sql=V14),
 )

apps/tesm/src/tesm/services/inventory.py

@@ -544,7 +544,9 @@ def list_devices(
                st.last_ok_at, st.last_change_at, st.last_restart_at, st.restart_count,
                st.fail_count, COALESCE(st.vnc_open, 0) AS vnc_open, st.vnc_checked_at,
                COALESCE(st.vnc_target, '') AS vnc_target,
-               COALESCE(st.vnc_types, '') AS vnc_types
+               COALESCE(st.vnc_types, '') AS vnc_types,
+               COALESCE(st.vnc_reason, '') AS vnc_reason, st.vnc_types_at,
+               COALESCE(st.vnc_method, 0) AS vnc_method
           FROM devices d
           LEFT JOIN switches s ON s.id = d.switch_id AND s.deleted_at IS NULL
           LEFT JOIN credentials c ON c.id = d.credential_id AND c.deleted_at IS NULL

apps/tesm/src/tesm/services/maintenance.py

@@ -29,7 +29,7 @@ import sqlite3
 import threading
 import time
 from dataclasses import dataclass
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from typing import Any, Callable
 
 from tesm_core import audit
@@ -44,6 +44,51 @@ logger = logging.getLogger(__name__)
 
 JOB_KIND_UPDATE = "maintenance.update"
 JOB_KIND_REBOOT = "maintenance.reboot"
+JOB_KIND_COMMAND = "maintenance.command"
+
+#: Vorlagen fuer den Massenbefehl: Name, Befehl, Erklaerung.
+#:
+#: ``{sudo}`` wird zur Laufzeit ersetzt -- mit ``sudo -n``, wo es ohne Passwort
+#: geht, sonst mit ``sudo -S`` und dem hinterlegten Passwort ueber stdin. Wer
+#: eine Vorlage waehlt, sieht den Befehl im Feld und kann ihn aendern: eine
+#: Vorlage ist ein Vorschlag, kein Automat.
+BEFEHLSVORLAGEN: tuple[tuple[str, str, str], ...] = (
+    (
+        "VNC: Streckenverschlüsselung abschalten",
+        'echo "Encryption=AlwaysOff" | {sudo} tee -a /etc/vnc/config.d/common.custom',
+        "Danach bietet RealVNC auch RA2ne und „ohne Authentifizierung“ an – nur damit "
+        "kommt eine Sitzung im Browser zustande. Die Strecke ist dann unverschlüsselt; "
+        "im Netz zwischen Server und Gerät ist sie es ohnehin.",
+    ),
+    (
+        "VNC-Dienst neu starten",
+        "{sudo} systemctl restart vncserver-x11-serviced",
+        "Räumt auch eine Sperre ab, die der Server nach zu vielen abgebrochenen "
+        "Verbindungsversuchen gesetzt hat.",
+    ),
+    (
+        "VNC: aktuelle Einstellungen zeigen",
+        "cat /etc/vnc/config.d/common.custom 2>/dev/null || echo '(keine eigene Konfiguration)'",
+        "Liest nur – gut, um vor dem Ändern zu sehen, was schon dasteht.",
+    ),
+    (
+        "Zeit und Zeitzone",
+        "timedatectl",
+        "Liest nur.",
+    ),
+    (
+        "Belegung der Dateisysteme",
+        "df -h",
+        "Liest nur.",
+    ),
+)
+
+#: Was in einer Befehlszeile nichts zu suchen hat. Nicht als Schutz vor einem
+#: Menschen mit diesem Recht -- er darf ohnehin alles, was sein Konto auf dem
+#: Geraet darf --, sondern gegen Unfaelle: ein Zeilenumbruch aus der
+#: Zwischenablage macht aus einem Befehl unbemerkt zwei.
+VERBOTENE_ZEICHEN = ("\n", "\r", "\x00")
+MAX_BEFEHLSLAENGE = 500
 
 MAX_OUTPUT_LINES = 400
 CONNECT_TIMEOUT = 25
@@ -231,16 +276,89 @@ def update_job(
 
 
 def list_jobs(
-    conn: sqlite3.Connection, *, kinds: tuple[str, ...] = (JOB_KIND_UPDATE, JOB_KIND_REBOOT), limit: int = 60
+    conn: sqlite3.Connection,
+    *,
+    kinds: tuple[str, ...] = (JOB_KIND_UPDATE, JOB_KIND_REBOOT, JOB_KIND_COMMAND),
+    limit: int = 60,
 ) -> list[dict[str, Any]]:
     placeholders = ",".join("?" * len(kinds))
     return Database.all(
         conn,
-        f"SELECT * FROM jobs WHERE kind IN ({placeholders}) ORDER BY created_at DESC LIMIT ?",
+        # ``rowid`` als zweites Ordnungsmerkmal: ``created_at`` hat
+        # Sekundenaufloesung, und ein Massenbefehl legt vierzig Auftraege in
+        # derselben Sekunde an. Ohne das entschied bei Gleichstand die
+        # Speicherreihenfolge -- die Liste sah bei jedem Aufruf anders aus.
+        f"SELECT * FROM jobs WHERE kind IN ({placeholders}) "
+        "ORDER BY created_at DESC, rowid DESC LIMIT ?",
         (*kinds, limit),
     )
 
 
+def laufende_und_letzte(
+    conn: sqlite3.Connection,
+    *,
+    kinds: tuple[str, ...] = (JOB_KIND_UPDATE, JOB_KIND_REBOOT, JOB_KIND_COMMAND),
+    limit: int = 30,
+) -> list[dict[str, Any]]:
+    """Alles, was laeuft oder eben fertig wurde -- und dazu die letzten Auftraege.
+
+    Fuer die Statusabfrage der Wartungsseite. Eine feste Obergrenze allein
+    reicht dort nicht, und das war ein echter Fehler: ein Massenbefehl auf
+    vierzig Geraete legt vierzig Auftraege an, ``LIMIT 30`` schnitt zehn davon
+    ab -- und weil alle denselben Zeitstempel auf die Sekunde tragen, waren es
+    zehn willkuerliche. Auf der Seite sah das aus, als haetten die letzten
+    Geraete den Befehl nie bekommen: sie liefen, ihre Ausgabe kam nur nie an.
+
+    Was laeuft, faellt hier deshalb nie heraus, und was gerade fertig wurde,
+    behaelt seine letzten Zeilen so lange wie ``eben_fertig`` es zusagt.
+    """
+    platzhalter = ",".join("?" * len(kinds))
+    schwelle = (
+        datetime.now(timezone.utc) - timedelta(seconds=EBEN_FERTIG_SEKUNDEN)
+    ).isoformat(timespec="seconds")
+    gesammelt: dict[str, dict[str, Any]] = {}
+    for sql, params in (
+        (
+            f"SELECT * FROM jobs WHERE kind IN ({platzhalter}) "
+            "AND state IN ('pending','running') ORDER BY created_at DESC, rowid DESC",
+            (*kinds,),
+        ),
+        (
+            f"SELECT * FROM jobs WHERE kind IN ({platzhalter}) "
+            "AND COALESCE(finished_at, updated_at) >= ? ORDER BY created_at DESC, rowid DESC",
+            (*kinds, schwelle),
+        ),
+        (
+            f"SELECT * FROM jobs WHERE kind IN ({platzhalter}) "
+            "ORDER BY created_at DESC, rowid DESC LIMIT ?",
+            (*kinds, limit),
+        ),
+    ):
+        for job in Database.all(conn, sql, params):
+            gesammelt.setdefault(str(job["id"]), job)
+    return sorted(
+        gesammelt.values(), key=lambda job: str(job["created_at"] or ""), reverse=True
+    )
+
+
+def letzter_auftrag_je_geraet(
+    conn: sqlite3.Connection,
+    *,
+    kinds: tuple[str, ...] = (JOB_KIND_UPDATE, JOB_KIND_REBOOT, JOB_KIND_COMMAND),
+    limit: int = 400,
+) -> dict[str, dict[str, Any]]:
+    """Zu jedem Geraetenamen sein neuester Auftrag.
+
+    Damit die Wartungsseite schon beim Aufbau zeigt, was wo laeuft -- und nicht
+    erst, wenn die erste Statusabfrage zurueck ist. Der Schluessel ist der
+    Name, denn genau den traegt ein Auftrag als ``subject``.
+    """
+    stand: dict[str, dict[str, Any]] = {}
+    for job in list_jobs(conn, kinds=kinds, limit=limit):
+        stand.setdefault(str(job["subject"]), job)
+    return stand
+
+
 def get_job(conn: sqlite3.Connection, job_id: str) -> dict[str, Any] | None:
     return Database.one(conn, "SELECT * FROM jobs WHERE id=?", (job_id,))
 
@@ -447,6 +565,149 @@ def run_update(
         )
 
 
+#: So lange gilt ein Auftrag als "eben fertig geworden" und schickt seine
+#: letzten Zeilen noch mit. Ohne das verschwaende die Ausgabe genau in dem
+#: Augenblick, in dem sie interessant wird: wenn der Befehl durch ist.
+EBEN_FERTIG_SEKUNDEN = 120
+
+#: So viele Zeilen gehen ins Mitlesen. Genug, um zu sehen, was gerade
+#: passiert; wenig genug, dass eine Abfrage alle zwei Sekunden nichts kostet.
+MITLESEN_ZEILEN = 40
+
+
+def letzte_zeilen(ausgabe: str, anzahl: int = MITLESEN_ZEILEN) -> str:
+    """Das Ende einer Ausgabe -- das ist der Teil, der gerade entsteht."""
+    zeilen = [zeile for zeile in ausgabe.splitlines() if zeile.strip()]
+    return "\n".join(zeilen[-anzahl:])
+
+
+def eben_fertig(job: dict[str, Any], sekunden: int = EBEN_FERTIG_SEKUNDEN) -> bool:
+    """Ist dieser Auftrag gerade eben fertig geworden?"""
+    if job.get("state") in {"pending", "running"}:
+        return True
+    stempel = str(job.get("finished_at") or job.get("updated_at") or "")
+    if not stempel:
+        return False
+    try:
+        moment = datetime.fromisoformat(stempel)
+    except ValueError:
+        return False
+    if moment.tzinfo is None:
+        moment = moment.replace(tzinfo=timezone.utc)
+    return (datetime.now(timezone.utc) - moment).total_seconds() < sekunden
+
+
+def befehl_pruefen(befehl: str) -> str:
+    """Gibt den bereinigten Befehl zurueck -- oder wirft mit Klartext.
+
+    Eine eigene Funktion, weil genau diese Frage sich pruefen lassen muss,
+    ohne ein Geraet zu brauchen.
+    """
+    sauber = (befehl or "").strip()
+    if not sauber:
+        raise ValueError("Es wurde kein Befehl eingegeben.")
+    if len(sauber) > MAX_BEFEHLSLAENGE:
+        raise ValueError(
+            f"Der Befehl ist zu lang (mehr als {MAX_BEFEHLSLAENGE} Zeichen). "
+            "Für längere Abläufe ist ein Skript auf dem Gerät der bessere Weg."
+        )
+    for zeichen in VERBOTENE_ZEICHEN:
+        if zeichen in sauber:
+            raise ValueError(
+                "Der Befehl enthält einen Zeilenumbruch. Hier läuft genau eine "
+                "Befehlszeile – alles danach würde stillschweigend mitlaufen."
+            )
+    return sauber
+
+
+def run_command(
+    database: Any,
+    *,
+    job_id: str,
+    device: dict[str, Any],
+    username: str,
+    password: str,
+    befehl: str,
+    timeout: int,
+) -> None:
+    """Fuehrt **eine** Befehlszeile auf einem Geraet aus. Eigener Thread.
+
+    Bewusst ohne Deutung des Ergebnisses: was der Befehl tut, weiss der
+    Mensch, der ihn geschrieben hat. Festgehalten wird, was zurueckkam und mit
+    welchem Rueckgabewert -- mehr kann ein Werkzeug hier nicht beitragen, und
+    weniger waere zu wenig.
+    """
+    name = str(device.get("name") or device.get("ip"))
+
+    def emit(line: str) -> None:
+        stamp = datetime.now().strftime("%H:%M:%S")
+        update_job(database, job_id, append_output=f"{stamp}  {line}\n")
+
+    update_job(
+        database, job_id, state="running", progress=5, message="Verbindung wird aufgebaut"
+    )
+    try:
+        with database.session() as conn:
+            transport = open_transport(
+                conn,
+                host=str(device["ip"]),
+                port=int(device.get("ssh_port") or 22),
+                username=username,
+                password=password,
+            )
+    except SshError as exc:
+        emit(f"FEHLER: {exc}")
+        update_job(database, job_id, state="failed", message=str(exc), finished=True)
+        return
+
+    status = 1
+    try:
+        sudo, sudo_stdin = _sudo_mode(transport, password, emit)
+        # Nur wer {sudo} benutzt, bekommt es auch: ein Befehl ohne diese Marke
+        # laeuft als der angemeldete Benutzer, und das ist die richtige
+        # Vorgabe -- Rechte holt man sich hier ausdruecklich.
+        ausgefuehrt = befehl.replace("{sudo}", sudo) if "{sudo}" in befehl else befehl
+        emit(f"$ {ausgefuehrt}")
+        update_job(database, job_id, progress=40, message="Befehl läuft")
+        status = _run_remote_command(
+            transport,
+            ausgefuehrt,
+            timeout=timeout,
+            on_line=emit,
+            stdin_text=sudo_stdin if "{sudo}" in befehl else "",
+        )
+    except Exception as exc:  # noqa: BLE001 - der Auftrag soll das Ergebnis tragen
+        emit(f"FEHLER: {exc}")
+    finally:
+        try:
+            transport.close()
+        except Exception:  # noqa: BLE001
+            pass
+
+    emit(COMPLETION_MARKER)
+    update_job(
+        database,
+        job_id,
+        state="succeeded" if status == 0 else "failed",
+        progress=100,
+        message=(
+            "Befehl ausgeführt."
+            if status == 0
+            else f"Der Befehl endete mit Rückgabewert {status}."
+        ),
+        finished=True,
+    )
+    with database.session() as conn, database.transaction(conn):
+        audit.log(
+            conn,
+            actor="system",
+            action="maintenance.command_finished",
+            target=name,
+            detail=f"Rückgabewert {status}",
+            severity="notice" if status == 0 else "warning",
+        )
+
+
 def _reboot_windows(
     database: Any,
     *,
@@ -457,6 +718,7 @@ def _reboot_windows(
     actor: str,
     emit: Callable[[str], None],
     elapsed: Callable[[], int],
+    live: Any = None,
 ) -> bool:
     """Neustart eines Windows-Geraets ueber RPC. ``True`` = weiter warten.
 
@@ -487,6 +749,7 @@ def _reboot_windows(
         duration_ms=elapsed(),
         detail=detail,
         method=METHOD_RPC,
+        live=live,
     )
     return False
 
@@ -501,6 +764,7 @@ def run_reboot(
     wait_seconds: int,
     actor: str = "system",
     method: str = METHOD_SSH,
+    live: Any = None,
 ) -> None:
     """Loest einen Neustart aus und wartet auf die Rueckkehr.
 
@@ -553,6 +817,7 @@ def run_reboot(
             actor=actor,
             emit=emit,
             elapsed=elapsed,
+            live=live,
         ):
             return
     else:
@@ -576,6 +841,7 @@ def run_reboot(
                 duration_ms=elapsed(),
                 detail=str(exc),
                 method=method,
+                live=live,
             )
             return
 
@@ -618,6 +884,7 @@ def run_reboot(
                 duration_ms=elapsed(),
                 detail=problem,
                 method=method,
+                live=live,
             )
             return
 
@@ -658,6 +925,7 @@ def run_reboot(
                 duration_ms=elapsed(),
                 detail="Neustart über SSH, Gerät ist zurückgekehrt.",
                 method=method,
+                live=live,
             )
             return
         time.sleep(REBOOT_POLL_SECONDS)
@@ -682,7 +950,8 @@ def run_reboot(
             f"{wait_seconds}s nicht wieder geantwortet."
         ),
         method=method,
-            )
+        live=live,
+    )
 
 
 def _log_restart(
@@ -694,6 +963,7 @@ def _log_restart(
     duration_ms: int,
     detail: str,
     method: str = METHOD_SSH,
+    live: Any = None,
 ) -> None:
     """Traegt den Neustart in die geraeteweite Neustart-Historie ein.
 
@@ -716,6 +986,7 @@ def _log_restart(
                 duration_ms=duration_ms,
                 detail=detail,
                 method=method,
+                live=live,
             )
     except Exception:  # noqa: BLE001 - Protokollieren darf den Auftrag nie kippen
         logger.exception("Neustart konnte nicht protokolliert werden (Gerät %s)", device_id)

apps/tesm/src/tesm/services/monitor.py

@@ -156,6 +156,16 @@ class LiveLog:
     def info(self, scope: str, message: str) -> None:
         self.write("INFO", scope, message)
 
+    def notice(self, scope: str, message: str) -> None:
+        """Etwas ist passiert, und es ist in Ordnung -- aber es gehoert gesehen.
+
+        Zwischen "laeuft" und "stimmt etwas nicht" fehlte eine Stufe. Ein
+        Geraet, das neu gestartet wird, ist kein Fehler; es einfach als INFO
+        zwischen zweihundert Erreichbarkeitsmeldungen zu stellen heisst aber,
+        dass es niemand findet.
+        """
+        self.write("HINWEIS", scope, message)
+
     def warning(self, scope: str, message: str) -> None:
         self.write("WARNUNG", scope, message)
 
@@ -278,6 +288,39 @@ METHOD_LABELS = {
     METHOD_RPC: "Neustart über RPC",
 }
 
+#: Wer den Neustart ausgeloest hat -- in Worten statt in Schluesseln.
+#:
+#: Die Schluessel stehen so in der Datenbank und bleiben dort; eine Spalte
+#: umzuschreiben, um eine Anzeige zu verbessern, waere der falsche Weg. Die
+#: Uebersetzung gehoert an genau eine Stelle, sonst heisst derselbe Vorgang im
+#: Protokoll "auto" und auf der Seite "automatisch".
+TRIGGER_LABELS = {
+    "auto": "automatisch",
+    "manuell": "manuell",
+    "maintenance": "aus der Wartung",
+}
+
+
+def trigger_label(trigger: str) -> str:
+    """Der Ausloeser als Wort -- unbekannte Schluessel bleiben, wie sie sind."""
+    return TRIGGER_LABELS.get(str(trigger or ""), str(trigger or "unbekannt"))
+
+
+def _geraet_kurz(conn: sqlite3.Connection, device_id: int) -> str:
+    """``Name (IP)`` fuer das laufende Protokoll.
+
+    Die Neustart-Funktionen bekommen nur eine Kennung; im Protokoll steht aber
+    eine Zeile, die ein Mensch liest -- und "Geraet 17 wird neu gestartet"
+    hilft niemandem.
+    """
+    row = conn.execute("SELECT name, ip FROM devices WHERE id=?", (int(device_id),)).fetchone()
+    if row is None:
+        return f"Gerät {device_id}"
+    name = str(row["name"] or "").strip() or f"Gerät {device_id}"
+    ip = str(row["ip"] or "").strip()
+    return f"{name} ({ip})" if ip else name
+
+
 #: Zustand zwischen ausgeloestem Neustart und Rueckkehr.
 #:
 #: Ohne ihn blieb die Kachel auf "online" stehen: der Zustand wechselt erst
@@ -303,6 +346,7 @@ def record_restart(
     duration_ms: int,
     detail: str,
     method: str = METHOD_POE,
+    live: Any = None,
 ) -> None:
     """Schreibt einen Neustart ins Protokoll -- unabhaengig davon, wie er lief.
 
@@ -311,6 +355,12 @@ def record_restart(
     nur in ``method``. Vorher gab es nur die PoE-Haelfte, und ein per Wartung
     neu gestartetes Geraet tauchte in der Neustart-Historie ueberhaupt nicht
     auf.
+
+    Mit ``live`` steht das Ergebnis auch im laufenden Protokoll. Diese
+    Funktion ist der Trichter, durch den **jeder** Neustart laeuft -- PoE
+    automatisch wie von Hand, SSH und RPC aus der Wartung. Die Zeile hier zu
+    schreiben statt bei jeder Quelle einzeln ist der Unterschied zwischen
+    "alle Wege sind abgedeckt" und "alle Wege, an die jemand gedacht hat".
     """
     conn.execute(
         "INSERT INTO restart_events "
@@ -318,6 +368,17 @@ def record_restart(
         "VALUES (?,?,?,?,?,?,?,?,?)",
         (device_id, _now(), trigger, actor, action, result, duration_ms, detail[:8000], method),
     )
+    if live is not None:
+        wer = _geraet_kurz(conn, device_id)
+        weg = METHOD_LABELS.get(method, method)
+        if result == "ok":
+            live.info("neustart", f"{wer}: Neustart über {weg} erfolgreich")
+        elif result == "skipped":
+            # Warnstufe: ein Geraet, das haette neu gestartet werden sollen und
+            # es nicht wurde, ist kein Hinweis am Rande.
+            live.warning("neustart", f"{wer}: Neustart nicht ausgeführt – {detail}")
+        else:
+            live.error("neustart", f"{wer}: Neustart fehlgeschlagen – {detail}")
     if result == "ok":
         # Hier faellt nur noch der Zaehler und der Zeitstempel an. Den Zustand
         # setzt ``mark_restarting`` schon beim Ausloesen -- dieses Ergebnis
@@ -330,7 +391,14 @@ def record_restart(
         )
 
 
-def mark_restarting(conn: sqlite3.Connection, device_id: int) -> None:
+def mark_restarting(
+    conn: sqlite3.Connection,
+    device_id: int,
+    *,
+    live: Any = None,
+    trigger: str = "",
+    method: str = METHOD_POE,
+) -> None:
     """Setzt den Zustand auf "startet neu" -- beim **Ausloesen**, nicht am Ende.
 
     Ein Neustart ueber SSH oder RPC laeuft als Auftrag: Kommando schicken, dann
@@ -342,6 +410,12 @@ def mark_restarting(conn: sqlite3.Connection, device_id: int) -> None:
     Absicht. Und ohne ``last_restart_at``: das Kulanzfenster laeuft ab dem
     Zeitpunkt, an dem der Neustart tatsaechlich ausgeloest wurde
     (``record_restart``).
+
+    Mit ``live`` geht der Beginn ins laufende Protokoll -- als Hinweis, nicht
+    als Warnung: ein Neustart ist kein Stoerfall, aber er erklaert die Luecke,
+    die gleich in der Erreichbarkeit steht. Dass die Zeile hier entsteht und
+    nicht bei den Aufrufern, ist Absicht: dies ist der Punkt, an dem ein
+    Neustart **ausgeloest** wird, gleich von welcher Quelle.
     """
     conn.execute(
         """
@@ -355,6 +429,12 @@ def mark_restarting(conn: sqlite3.Connection, device_id: int) -> None:
         """,
         (device_id, STATE_RESTARTING, _now(), _now()),
     )
+    if live is not None:
+        weg = METHOD_LABELS.get(method, method)
+        woher = f" ({trigger_label(trigger)})" if trigger else ""
+        live.notice(
+            "neustart", f"{_geraet_kurz(conn, device_id)} wird neu gestartet – {weg}{woher}"
+        )
 
 
 # --------------------------------------------------------------------------- #
@@ -402,7 +482,9 @@ def restart_device_poe(
     # wie fuer den automatischen Neustart, denn beide laufen hier durch.
     if port and switch_ip:
         with write():
-            mark_restarting(conn, int(device["id"]))
+            mark_restarting(
+                conn, int(device["id"]), live=live, trigger=trigger, method=METHOD_POE
+            )
 
     if not port or not switch_ip:
         message = (
@@ -418,6 +500,7 @@ def restart_device_poe(
             actor=actor,
             duration_ms=0,
             detail=message,
+            live=live,
         )
         return {"ok": False, "message": message, "transcript": ""}
 
@@ -462,9 +545,8 @@ def restart_device_poe(
             actor=actor,
             duration_ms=duration,
             detail=str(exc),
+            live=live,
         )
-        if live:
-            live.error("poe", f"{name}: {exc}")
         return {"ok": False, "message": str(exc), "transcript": ""}
 
     duration = int((time.monotonic() - started) * 1000)
@@ -478,12 +560,8 @@ def restart_device_poe(
         actor=actor,
         duration_ms=duration,
         detail=(outcome.error or "; ".join(outcome.steps))[:8000],
+        live=live,
     )
-    if live:
-        if outcome.ok:
-            live.info("poe", f"{name}: PoE-Neustart auf {device.get('switch_hostname')} {port} erfolgreich")
-        else:
-            live.error("poe", f"{name}: PoE-Neustart fehlgeschlagen -- {outcome.error}")
     return {
         "ok": outcome.ok,
         "message": outcome.error or "PoE-Neustart durchgeführt.",
@@ -507,30 +585,45 @@ class SweepReport:
     duration_ms: int = 0
 
 
-def merke_vnc(
-    conn: sqlite3.Connection,
-    device_id: int,
-    offen: bool,
-    ziel: str = "",
-    verfahren: tuple[int, ...] = (),
-) -> None:
+def merke_vnc(conn: sqlite3.Connection, device_id: int, offen: bool, ziel: str = "") -> None:
     """Haelt fest, ob dort ein VNC-Server antwortet -- und unter welchem Ziel.
 
     Das Ziel gehoert dazu, weil die Statusuebersicht die Verbindung unmittelbar
     verlinkt. Es aus dem Namen neu herzuleiten hiesse, je Kachel und
     Seitenaufbau eine Namensaufloesung zu versuchen; hier steht es einmal
     geschrieben, von dem, der ohnehin gefragt hat.
+
+    Die Anmeldeverfahren bleiben unberuehrt: sie kommen aus einer anderen
+    Quelle (:func:`merke_verfahren`) und haetten hier nur den Wert "nicht
+    gefragt" -- der wuerde eine gute Messung ueberschreiben.
     """
     conn.execute(
-        "UPDATE device_status SET vnc_open=?, vnc_checked_at=?, vnc_target=?, vnc_types=? "
-        "WHERE device_id=?",
-        (
-            1 if offen else 0,
-            _now(),
-            ziel,
-            ",".join(str(v) for v in verfahren),
-            device_id,
-        ),
+        "UPDATE device_status SET vnc_open=?, vnc_checked_at=?, vnc_target=? WHERE device_id=?",
+        (1 if offen else 0, _now(), ziel, device_id),
+    )
+
+
+def merke_verfahren(
+    conn: sqlite3.Connection, device_id: int, verfahren: tuple[int, ...], absage: str = ""
+) -> None:
+    """Haelt fest, wie sich der VNC-Server authentifizieren will.
+
+    Mit Zeitstempel, denn diese Messung kostet eine angefangene
+    Protokollverhandlung -- und die soll sich nicht bei jedem Seitenaufbau
+    wiederholen.
+    """
+    conn.execute(
+        "UPDATE device_status SET vnc_types=?, vnc_reason=?, vnc_types_at=? WHERE device_id=?",
+        (",".join(str(v) for v in verfahren), absage, _now(), device_id),
+    )
+
+
+def merke_verfahren_das_traegt(
+    conn: sqlite3.Connection, device_id: int, verfahren: int
+) -> None:
+    """Haelt fest, womit die letzte Sitzung wirklich zustande kam."""
+    conn.execute(
+        "UPDATE device_status SET vnc_method=? WHERE device_id=?", (int(verfahren), device_id)
     )
 
 
@@ -553,6 +646,10 @@ def run_sweep(
     erreichbare Geraet: nimmt dort ein VNC-Server Verbindungen an? Sie gehoert
     hierher und nicht in den Seitenaufbau -- einmal je Intervall statt einmal
     je Aufruf, und nur fuer Geraete, die ohnehin gerade antworten.
+
+    **Nur die Frage nach dem Port**, kein Wort Protokoll: ein RealVNC Server
+    zaehlt abgebrochene Verhandlungen und sperrt die Adresse eine Weile aus.
+    Welche Anmeldeverfahren er anbietet, misst die Seite, die es braucht.
     """
     from . import vnc as vnc_dienst  # spaet: vnc benutzt tcp_reachable von hier
 
@@ -575,7 +672,16 @@ def run_sweep(
             # bekannten Stand stehen. Ein Geraet, das gerade neu startet, soll
             # seinen Knopf nicht verlieren.
             return device, ergebnis, None
-        return device, ergebnis, vnc_dienst.zugang(device, port=vnc_port)
+        try:
+            return device, ergebnis, vnc_dienst.zugang_kurz(device, port=vnc_port)
+        except Exception:  # noqa: BLE001
+            # Die Ueberwachung ist die Kernaufgabe, der Bildschirmzugriff eine
+            # Zugabe. Was hier schiefgeht -- ein Name, den der Resolver nicht
+            # verdaut, ein Netz, das seltsam antwortet --, darf niemals den
+            # ganzen Durchlauf kosten: sonst stuenden alle Geraete auf
+            # "unbekannt", und niemand brächte das mit VNC in Verbindung.
+            logger.warning("VNC-Pruefung fuer %s uebersprungen", device.get("name"), exc_info=True)
+            return device, ergebnis, None
 
     with ThreadPoolExecutor(max_workers=min(MAX_PARALLEL_CHECKS, len(devices))) as pool:
         results = list(pool.map(pruefen, devices))
@@ -587,13 +693,7 @@ def run_sweep(
                 report.checked += 1
                 previous, current = record_status(conn, int(device["id"]), result)
                 if vnc_offen is not None:
-                    merke_vnc(
-                        conn,
-                        int(device["id"]),
-                        vnc_offen.erreichbar,
-                        vnc_offen.ziel,
-                        vnc_offen.verfahren,
-                    )
+                    merke_vnc(conn, int(device["id"]), vnc_offen.erreichbar, vnc_offen.ziel)
                 if result.ok:
                     report.online += 1
                 else:
@@ -619,10 +719,22 @@ def run_sweep(
         name = str(device["name"])
         if not license_allows_auto_restart:
             report.skipped_unlicensed += 1
-            live.warning(
-                "poe",
-                f"{name}: automatischer PoE-Neustart übersprungen – keine gültige Lizenz.",
-            )
+            # Als Zeile in der Neustart-Historie, nicht nur als Protokollsatz:
+            # wer auf der Seite "Neustarts" nachsieht, warum ein Geraet nicht
+            # zurueckkam, soll dort auch lesen, dass TESM es versucht haette.
+            # Ein leerer Verlauf sieht sonst aus wie "es war nichts noetig".
+            with database.session() as conn, database.transaction(conn):
+                record_restart(
+                    conn,
+                    device_id=int(device["id"]),
+                    action="cycle",
+                    result="skipped",
+                    trigger="auto",
+                    actor="system",
+                    duration_ms=0,
+                    detail="keine gültige Lizenz für den automatischen PoE-Neustart",
+                    live=live,
+                )
             continue
         report.restarts_triggered += 1
         # Bewusst **keine** umschliessende Transaktion: der Neustart oeffnet eine

apps/tesm/src/tesm/services/vnc.py

@@ -61,6 +61,12 @@ class Zugang:
     #: gemessen). Daraus entsteht der Satz, warum eine Sitzung im Browser
     #: gehen wird oder nicht.
     verfahren: tuple[int, ...] = ()
+    #: Der Text, mit dem der Server die Verbindung abgelehnt hat -- er nennt
+    #: dann kein Verfahren, sondern eine 0 und einen Grund.
+    absage: str = ""
+    #: Das Verfahren, mit dem zuletzt wirklich eine Sitzung zustande kam
+    #: (0: noch keine). Damit faengt der naechste Versuch an.
+    bewaehrt: int = 0
 
     @property
     def browsertauglich(self) -> bool:
@@ -72,6 +78,14 @@ class Zugang:
         """Warum eine Sitzung im Browser nicht zustande kaeme -- im Klartext."""
         if not self.erreichbar:
             return f"Auf {self.ziel}:{self.port} antwortet kein VNC-Server."
+        if self.absage:
+            return (
+                f"Der VNC-Server auf {self.ziel} weist die Verbindung ab: "
+                f"„{self.absage}“. Das ist seine Auskunft, nicht unsere – "
+                "typisch sind eine Sperre nach zu vielen Fehlversuchen "
+                "(RealVNC: BlacklistTimeout), eine Adressfilterung oder eine "
+                "belegte Sitzung."
+            )
         if not self.verfahren:
             return ""
         if self.browsertauglich:
@@ -118,7 +132,9 @@ def aufloesbar(name: str) -> bool:
     try:
         socket.getaddrinfo(name, None)
         ergebnis = True
-    except OSError:
+    except Exception:  # noqa: BLE001
+        # Nicht nur OSError: ein Name mit Sonderzeichen wirft UnicodeError,
+        # und der ist kein OSError. Aufloesbar ist er so oder so nicht.
         ergebnis = False
     _AUFLOESUNG[name] = (jetzt, ergebnis)
     return ergebnis
@@ -181,7 +197,36 @@ def verfahren_name(nummer: int) -> str:
     return str(nummer)
 
 
-def sicherheitsverfahren(host: str, port: int = STANDARD_PORT) -> tuple[str, tuple[int, ...]]:
+def _absage(sock: Any) -> str:
+    """Der Grund, den ein Server einer abgelehnten Verbindung mitgibt.
+
+    Auf eine 0 -- ob als Anzahl (ab 3.7) oder als bestimmtes Verfahren (3.3) --
+    folgt eine Laenge und ein Text. Genau dieser Satz ist die Auskunft, die
+    sonst niemand bekommt: "zu viele Fehlversuche", "Verbindung von dieser
+    Adresse nicht erlaubt", "kein gemeinsames Verfahren". Ohne ihn steht da
+    nur, dass es nicht geht.
+    """
+    try:
+        roh = sock.recv(4)
+        if len(roh) < 4:
+            return ""
+        laenge = int.from_bytes(roh, "big")
+        if not 0 < laenge <= 1024:
+            return ""
+        text = b""
+        while len(text) < laenge:
+            stueck = sock.recv(laenge - len(text))
+            if not stueck:
+                break
+            text += stueck
+        return text.decode("utf-8", "replace").strip()
+    except OSError:
+        return ""
+
+
+def sicherheitsverfahren(
+    host: str, port: int = STANDARD_PORT
+) -> tuple[str, tuple[int, ...], str]:
     """Fragt den Server, **wie** er sich authentifizieren will.
 
     Der Anfang einer VNC-Verbindung ist fuer jeden Server derselbe: er nennt
@@ -192,8 +237,12 @@ def sicherheitsverfahren(host: str, port: int = STANDARD_PORT) -> tuple[str, tup
     Das ist die Angabe, an der eine Bildschirmsitzung im Browser scheitert oder
     gelingt, und sie hier zu messen ist der Unterschied zwischen einer
     schwarzen Flaeche und dem Satz "dieser Server bietet nur Verfahren an, die
-    der Browser nicht kennt". Gibt ``(Fassung, Verfahren)`` zurueck; bei einem
-    Fehler ``("", ())``.
+    der Browser nicht kennt".
+
+    Gibt ``(Fassung, Verfahren, Absage)`` zurueck. Die Absage ist der Text, den
+    ein Server mitschickt, wenn er die Verbindung **ablehnt** -- er meldet dann
+    kein Verfahren, sondern eine 0 und einen Grund. Bei einem Fehler
+    ``("", (), "")``.
     """
     import socket
 
@@ -202,28 +251,68 @@ def sicherheitsverfahren(host: str, port: int = STANDARD_PORT) -> tuple[str, tup
             sock.settimeout(ZEITLIMIT)
             gruss = sock.recv(12)
             if not gruss.startswith(b"RFB "):
-                return "", ()
+                return "", (), ""
             fassung = gruss[4:11].decode("ascii", "replace")
             # Wir antworten mit 3.8 -- der Fassung, die auch der Browser
             # spricht. Ein Server, der mehr kann, faellt darauf zurueck und
             # nennt trotzdem seine Verfahren.
-            sock.sendall(b"RFB 003.008" + bytes([10]))
+            # Antworten wird mit *seiner* Fassung, hoechstens 3.8. Wer einem
+            # 3.3-Server mit 3.8 antwortet, bekommt keine Liste, sondern eine
+            # 32-Bit-Zahl -- und liest sie als "keine Verfahren".
+            eigene = "003.003" if fassung == "003.003" else "003.008"
+            sock.sendall(b"RFB " + eigene.encode("ascii") + bytes([10]))
+
+            if eigene == "003.003":
+                # RFB 3.3: der Server bestimmt allein und schickt eine
+                # 32-Bit-Zahl. Das ist kein Sonderfall aus der Vorzeit --
+                # RealVNC faellt darauf zurueck, sobald keine Anmeldung
+                # verlangt wird.
+                rohwert = b""
+                while len(rohwert) < 4:
+                    stueck = sock.recv(4 - len(rohwert))
+                    if not stueck:
+                        break
+                    rohwert += stueck
+                if len(rohwert) < 4:
+                    return fassung, (), ""
+                bestimmt = int.from_bytes(rohwert, "big")
+                if bestimmt == 0:
+                    return fassung, (), _absage(sock)
+                return fassung, (bestimmt,), ""
+
             anzahl = sock.recv(1)
             if not anzahl:
-                return fassung, ()
+                return fassung, (), ""
             wie_viele = anzahl[0]
             if wie_viele == 0:
                 # Null heisst: der Server lehnt ab und schickt den Grund.
-                return fassung, ()
+                return fassung, (), _absage(sock)
             liste = b""
             while len(liste) < wie_viele:
                 stueck = sock.recv(wie_viele - len(liste))
                 if not stueck:
                     break
                 liste += stueck
-            return fassung, tuple(liste)
+            return fassung, tuple(liste), ""
     except OSError:
-        return "", ()
+        return "", (), ""
+
+
+def zugang_kurz(device: Mapping[str, Any], *, port: int = STANDARD_PORT) -> Zugang:
+    """Nur die Frage, ob dort jemand annimmt -- ohne ein Wort Protokoll.
+
+    Das ist die Fassung fuer den Ueberwachungsdurchlauf. Er laeuft alle paar
+    Minuten ueber jedes Geraet, und eine angefangene und sofort wieder
+    abgebrochene Protokollverhandlung ist nicht nur unhoeflich: ein RealVNC
+    Server zaehlt abgebrochene Versuche und sperrt die Adresse eine Weile aus
+    (``BlacklistTimeout``). Eine Ueberwachung, die ihr eigenes Ziel aussperrt,
+    waere ein schoener Eigentor -- also fragt sie nur, ob der Port annimmt.
+
+    Welche Anmeldeverfahren der Server kann, misst erst die Seite, die es
+    wirklich braucht -- und auch die nicht oefter als noetig.
+    """
+    host = ziel(device)
+    return Zugang(ziel=host, port=port, erreichbar=erreichbar(host, port))
 
 
 def zugang(device: Mapping[str, Any], *, port: int = STANDARD_PORT, pruefen: bool = True) -> Zugang:
@@ -231,17 +320,63 @@ def zugang(device: Mapping[str, Any], *, port: int = STANDARD_PORT, pruefen: boo
     host = ziel(device)
     if not pruefen:
         return Zugang(ziel=host, port=port, erreichbar=False)
-    fassung, verfahren = sicherheitsverfahren(host, port)
-    return Zugang(ziel=host, port=port, erreichbar=bool(fassung), verfahren=verfahren)
+    fassung, verfahren, absage = sicherheitsverfahren(host, port)
+    return Zugang(
+        ziel=host,
+        port=port,
+        erreichbar=bool(fassung),
+        verfahren=verfahren,
+        absage=absage,
+    )
 
 
-def verbindungsdatei(device: Mapping[str, Any], *, port: int = STANDARD_PORT) -> str:
+def zugang_gemerkt(device: Mapping[str, Any], *, port: int = STANDARD_PORT) -> Zugang:
+    """Der Zugang, wie er in der Datenbank steht -- **ohne** das Geraet zu fragen.
+
+    Frueher hat diese Funktion selbst gemessen, wenn die letzte Messung alt war.
+    Das ist gestrichen, und zwar aus Erfahrung: jede Messung ist eine
+    angefangene und abgebrochene Protokollverhandlung, und ein RealVNC Server
+    zaehlt so etwas. Wer eine Bildschirmseite oeffnet, klopfte damit zweimal an
+    -- einmal zum Messen, einmal fuer die Sitzung --, und das zweite Klopfen
+    fiel dem ersten zum Opfer.
+
+    Jetzt beruehrt das Oeffnen einer Seite das Geraet gar nicht mehr. Die
+    Erreichbarkeit kommt aus dem Ueberwachungsdurchlauf (ein blosser
+    Verbindungsaufbau), die Anmeldeverfahren aus der letzten **ausdruecklichen**
+    Pruefung -- der Knopf dafuer steht auf der Seite und wird gedrueckt, wenn
+    etwas nicht geht.
+    """
+    gespeichert = str(device.get("vnc_types") or "")
+    return Zugang(
+        ziel=ziel(device),
+        port=port,
+        erreichbar=bool(device.get("vnc_open")),
+        verfahren=tuple(
+            int(teil) for teil in gespeichert.split(",") if teil.strip().isdigit()
+        ),
+        absage=str(device.get("vnc_reason") or ""),
+        bewaehrt=int(device.get("vnc_method") or 0),
+    )
+
+
+def verbindungsdatei(
+    device: Mapping[str, Any], *, port: int = STANDARD_PORT, warnung_aus: bool = False
+) -> str:
     """Der Inhalt der ``.vnc``-Datei -- drei Zeilen, keine vierte.
 
     ``ConnMethod=tcp`` ist die direkte Verbindung (nicht ueber den Cloud-Dienst
     von RealVNC), ``FriendlyName`` der Name, den der Viewer anzeigt, ``Host``
     das Ziel. Ein abweichender Port gehoert in dieser Datei an den Host, mit
     Doppelpunkt -- einen eigenen Schluessel dafuer gibt es nicht.
+
+    ``warnung_aus`` haengt eine vierte Zeile an: ``WarnUnencrypted=False``. Sie
+    betrifft **den Viewer**, nicht den Server -- er zeigt sonst bei jeder
+    Verbindung zu einem Geraet ohne Streckenverschluesselung einen roten
+    Hinweis, den man wegklicken muss. Wer ``Encryption=AlwaysOff`` auf dem
+    Geraet gesetzt hat (damit der Browser ueberhaupt verbinden kann), sieht
+    diesen Hinweis fortan bei jedem Start. Er bleibt in der Vorgabe stehen:
+    eine unverschluesselte Strecke soll man einmal bewusst hinnehmen, nicht
+    stillschweigend. Abschaltbar unter Verwaltung -> System.
     """
     host = ziel(device)
     if port != STANDARD_PORT:
@@ -251,6 +386,8 @@ def verbindungsdatei(device: Mapping[str, Any], *, port: int = STANDARD_PORT) ->
         f"FriendlyName={str(device.get('name') or host).strip()}",
         f"Host={host}",
     ]
+    if warnung_aus:
+        zeilen.append("WarnUnencrypted=False")
     return ZEILE.join(zeilen) + ZEILE
 
 

apps/tesm/src/tesm/settings_spec.py

@@ -66,6 +66,28 @@ TESM_SETTINGS: tuple[SettingSpec, ...] = (
         minimum=1,
         maximum=65535,
     ),
+    SettingSpec(
+        "vnc_idle_timeout",
+        300,
+        "int",
+        "Bildschirmsitzung bei Untätigkeit trennen nach (Sekunden)",
+        hint="Gezählt wird, wenn in **keine** Richtung mehr etwas fließt: der Bildschirm "
+        "ändert sich nicht und es kommt keine Eingabe. Eine Sitzung, die jemand offen "
+        "vergisst, hält sonst die Verbindung zum Gerät. 0 schaltet die Trennung ab.",
+        section="monitoring",
+        minimum=0,
+        maximum=86400,
+    ),
+    SettingSpec(
+        "vnc_warn_unencrypted_off",
+        False,
+        "bool",
+        "Warnung des Viewers vor unverschlüsselter Verbindung unterdrücken",
+        hint="Setzt WarnUnencrypted=False in die Verbindungsdatei. Betrifft nur den "
+        "RealVNC Viewer auf dem Arbeitsplatz, nicht die Verbindung selbst: die bleibt "
+        "unverschlüsselt, wenn das Gerät es so anbietet.",
+        section="monitoring",
+    ),
     # -- DHCP --------------------------------------------------------------- #
     SettingSpec("dhcp_domain", "local", "str", "Domainname", section="dhcp"),
     SettingSpec(

apps/tesm/src/tesm/templates/tesm/_dashboard_tiles.html

@@ -102,11 +102,25 @@
                     <div class="tile__actions">
                       {% if tile.vnc %}
                         {# Die Sitzung laeuft in TESM selbst: ein Klick, kein
-                           Viewer auf dem Arbeitsplatz, keine Datei. #}
-                        <a class="btn btn--sm" href="{{ url_for('screen.screen', device_id=tile.id) }}"
-                           title="Bildschirm im Browser öffnen">
-                          {{ icon('monitor', size=14) }} VNC
-                        </a>
+                           Viewer auf dem Arbeitsplatz, keine Datei.
+
+                           Mit frischer Passwortbestätigung öffnet sie sich hier
+                           im Fenster -- man bleibt bei der Übersicht und sieht
+                           die anderen Geräte weiter. Ohne sie führt der Knopf
+                           auf die Geräteseite, wo danach gefragt wird. #}
+                        {% if vnc_fenster %}
+                          <button class="btn btn--sm" type="button"
+                                  data-vnc-oeffnen="{{ tile.vnc_quelle }}"
+                                  data-vnc-name="{{ tile.name }}"
+                                  title="Bildschirm im Fenster öffnen">
+                            {{ icon('monitor', size=14) }} VNC
+                          </button>
+                        {% else %}
+                          <a class="btn btn--sm" href="{{ url_for('screen.screen', device_id=tile.id) }}"
+                             title="Bildschirm im Browser öffnen">
+                            {{ icon('monitor', size=14) }} VNC
+                          </a>
+                        {% endif %}
                       {% else %}
                         <span class="tile__spacer" aria-hidden="true"></span>
                       {% endif %}

apps/tesm/src/tesm/templates/tesm/_vnc_flaeche.html

@@ -0,0 +1,42 @@
+{# Die Bildschirmfläche -- einmal geschrieben, an zwei Orten benutzt: auf der
+   Geräteseite und im Fenster der Statusübersicht.
+
+   Die Teile finden sich über `data-rolle`, nicht über Kennungen: im Fenster
+   gäbe es sie sonst zweimal auf derselben Seite, und die zweite wäre die, die
+   niemand findet. #}
+{% macro vnc_flaeche(quelle='') %}
+<div class="screen" {% if quelle %}data-sitzung="{{ quelle }}"{% endif %}>
+  <div data-rolle="leinwand" class="screen__canvas" hidden></div>
+</div>
+{% endmacro %}
+
+{% macro vnc_status() %}
+<div data-rolle="status" class="screen__status">Wird vorbereitet …</div>
+{% endmacro %}
+
+{% macro vnc_zugangsdaten() %}
+<form data-rolle="zugangsdaten" class="row row--tight" hidden onsubmit="return false">
+  <label class="field">
+    <span class="field__label">Benutzer</span>
+    <input class="input" type="text" data-rolle="benutzer" autocomplete="off">
+  </label>
+  <label class="field">
+    <span class="field__label">Passwort</span>
+    <input class="input" type="password" data-rolle="passwort" autocomplete="off">
+  </label>
+  <button class="btn btn--primary" type="button" data-rolle="anmelden">Anmelden</button>
+</form>
+{% endmacro %}
+
+{# Tasten, die der Arbeitsplatz selbst abfängt und die deshalb einen Knopf
+   brauchen: Strg+Alt+Entf schaltet der Browser gar nicht erst durch, Alt+F4
+   schlösse das Fenster hier statt das Fenster dort. #}
+{% macro vnc_tasten() %}
+<button class="btn btn--sm" type="button" data-rolle="taste-cad" hidden
+        title="Strg+Alt+Entf an das Gerät senden">Strg+Alt+Entf</button>
+<button class="btn btn--sm" type="button" data-rolle="taste-altf4" hidden
+        title="Alt+F4 an das Gerät senden – schließt dort das oberste Fenster">Alt+F4</button>
+<button class="btn btn--sm" type="button" data-rolle="taste-f5" hidden
+        title="F5 an das Gerät senden – der Browser des Arbeitsplatzes würde sonst diese Seite neu laden">F5</button>
+<button class="btn btn--sm" type="button" data-rolle="trennen" hidden>Trennen</button>
+{% endmacro %}

apps/tesm/src/tesm/templates/tesm/dashboard.html

@@ -1,5 +1,6 @@
 {% extends "tesm_core/base.html" %}
-{% from "tesm_core/macros.html" import search_box %}
+{% from "tesm_core/macros.html" import search_box, modal %}
+{% from "tesm/_vnc_flaeche.html" import vnc_flaeche, vnc_status, vnc_zugangsdaten, vnc_tasten %}
 
 {% block page_title %}Statusübersicht{% endblock %}
 {% block page_sub %}
@@ -19,4 +20,27 @@
      data-refresh-interval="20000">
   {% include "tesm/_dashboard_tiles.html" %}
 </div>
+
+{% if vnc_fenster %}
+  {# Ein Fenster für alle Kacheln: welches Gerät gemeint ist, bringt der Knopf
+     beim Öffnen mit. Ein Dialog je Kachel wäre dieselbe Sache dutzendfach im
+     Quelltext -- und dutzendfach eine Sitzung, die niemand aufräumt. #}
+  {% call modal('vnc-fenster', 'Bildschirm', 'Tastatur und Maus gehen an das Gerät. Die Zwischenablage bleibt getrennt.', 'wide') %}
+    <div class="modal__body stack" data-rolle="behaelter">
+      <div class="row row--tight">
+        <strong data-rolle="titel" class="flex-1"></strong>
+        {{ vnc_tasten() }}
+      </div>
+      {{ vnc_status() }}
+      {{ vnc_zugangsdaten() }}
+      {{ vnc_flaeche() }}
+    </div>
+  {% endcall %}
+{% endif %}
+{% endblock %}
+
+{% block scripts %}
+{% if vnc_fenster %}
+  <script type="module" src="{{ asset_url('js/screen.js') }}" nonce="{{ csp_nonce }}"></script>
+{% endif %}
 {% endblock %}

apps/tesm/src/tesm/templates/tesm/dhcp.html

@@ -377,6 +377,10 @@
         <div class="card__title">{{ icon('clock', size=17) }} Leases</div>
         <div class="card__sub">
           Direkt aus {{ lease_file }} gelesen &ndash; je Adresse gilt der letzte Eintrag.
+          {% if current_user.has('dhcp_lease_adopt.read') and current_user.has('devices.create') %}
+            Eine <strong>dynamische</strong> Lease lässt sich als Client übernehmen; sie bekommt
+            damit eine feste Adresse und wird überwacht.
+          {% endif %}
         </div>
       </div>
     </div>
@@ -394,7 +398,7 @@
       <div class="table-wrap" style="max-height:420px;overflow:auto">
         <table class="table table--compact">
           <thead><tr><th>IP</th><th>MAC</th><th>Hostname</th><th>Art</th><th>Zustand</th>
-                     <th>Läuft ab</th></tr></thead>
+                     <th>Läuft ab</th><th></th></tr></thead>
           <tbody>
             {% for lease in leases %}
               <tr>
@@ -413,6 +417,31 @@
                 <td class="fs-sm">{{ lease.expires_text }}
                   <div class="fs-xs faint">{{ lease.remaining_text }}</div>
                 </td>
+                <td class="nowrap">
+                  {# Übernehmen gibt es nur für dynamische Leases: was reserviert
+                     ist, gehört schon zu einem gepflegten Datensatz. Und nur,
+                     wenn beide Rechte stehen -- hier entsteht ein Client. #}
+                  {% if lease.address not in reserved_ips
+                        and current_user.has('dhcp_lease_adopt.read')
+                        and current_user.has('devices.create') %}
+                    {% if lease.mac in bekannte_macs %}
+                      <span class="faint fs-xs" title="Zu dieser MAC gibt es bereits einen Client">
+                        bereits Client
+                      </span>
+                    {% else %}
+                      <form method="post" action="{{ url_for('dhcp.adopt_lease') }}">
+                        <input type="hidden" name="{{ csrf_field_name }}" value="{{ csrf_token() }}">
+                        <input type="hidden" name="mac" value="{{ lease.mac }}">
+                        <button class="btn btn--sm btn--ghost" type="submit"
+                                data-confirm="{{ lease.hostname or lease.address }} als überwachten Client anlegen? Switch, Port und Zugangsdaten tragen Sie danach nach."
+                                data-confirm-title="Als Client übernehmen"
+                                data-confirm-ok="Übernehmen">
+                          {{ icon('plus', size=14) }} Als Client
+                        </button>
+                      </form>
+                    {% endif %}
+                  {% endif %}
+                </td>
               </tr>
             {% endfor %}
           </tbody>

apps/tesm/src/tesm/templates/tesm/fileshare.html

@@ -242,8 +242,7 @@
          data-viewer-pdflib="{{ asset_url('vendor/pdflib/pdf-lib.min.js') }}"
          data-viewer-konto="{{ current_user.username }}"
          data-viewer-zeuge="{{ '1' if signature_witness else '0' }}"
-         data-viewer-zeit="{{ serverzeit }}"
-         data-viewer-ordnerliste="{{ verzeichnisse | tojson }}">
+         data-viewer-zeit="{{ serverzeit }}">
       <div class="viewer">
         <div class="viewer__stage" data-viewer-bildbuehne hidden>
           <img class="viewer__img" alt="" data-viewer-bild>

apps/tesm/src/tesm/templates/tesm/logs_restarts.html

@@ -6,7 +6,8 @@
 {% block content %}
 {{ alert('Jeder Neustart wird mit Methode, Ergebnis, Dauer und Auslöser festgehalten -- automatisch
 wie manuell, über den PoE-Port des Switches ebenso wie per Neustart-Befehl aus der Wartung.
-Der Vorgänger protokollierte Neustarts ausdrücklich nicht.', 'info') }}
+Auch ein Neustart, den die Überwachung auslösen wollte und nicht durfte, steht hier:
+als "übersprungen" mit dem Grund. Der Vorgänger protokollierte Neustarts ausdrücklich nicht.', 'info') }}
 
 <section class="card">
   <div class="card__header">
@@ -32,7 +33,7 @@ Der Vorgänger protokollierte Neustarts ausdrücklich nicht.', 'info') }}
       </tr></thead>
       <tbody>
         {% for row in rows %}
-          <tr data-filter-text="{{ row.device_name }} {{ row.result }} {{ row.actor }} {{ method_labels.get(row.method, row.method) }} {{ row.detail }}">
+          <tr data-filter-text="{{ row.device_name }} {{ row.result }} {{ row.actor }} {{ method_labels.get(row.method, row.method) }} {{ trigger_labels.get(row.trigger, row.trigger) }} {{ row.detail }}">
             <td class="fs-sm nowrap" data-sort-value="{{ row.ts }}">{{ row.ts | dt }}</td>
             <td class="fw-600 fs-sm">{{ row.device_name or '&ndash;' | safe }}</td>
             <td class="fs-sm">
@@ -41,10 +42,15 @@ Der Vorgänger protokollierte Neustarts ausdrücklich nicht.', 'info') }}
                  jahrelang als PoE ausgegeben. #}
               {% if row.method == 'ssh' %}{{ pill('SSH', 'info') }}
               {% elif row.method == 'rpc' %}{{ pill('RPC', 'accent') }}
-              {% elif row.method == 'pö' %}{{ pill('PoE-Port', '') }}
+              {# 'poe', nicht 'pö'. Der Umlaut stand hier durch eine
+                 Ersetzung, die "oe" fuer eine Umschrift hielt -- und traf den
+                 haeufigsten Fall von allen: jeder automatische Neustart laeuft
+                 ueber den PoE-Port. Sie standen damit als orangefarbenes
+                 "poe" da, wo "PoE-Port" stehen sollte. #}
+              {% elif row.method == 'poe' %}{{ pill('PoE-Port', '') }}
               {% else %}{{ pill(row.method or 'unbekannt', 'warning') }}{% endif %}
             </td>
-            <td class="fs-sm">{{ row.trigger }}</td>
+            <td class="fs-sm">{{ trigger_labels.get(row.trigger, row.trigger) }}</td>
             <td class="fs-sm">{{ row.actor }}</td>
             <td>
               {% if row.result == 'ok' %}{{ pill('erfolgreich', 'online') }}

apps/tesm/src/tesm/templates/tesm/maintenance.html

@@ -45,15 +45,78 @@ brauchen dafür weder SSH noch einen Host-Schlüssel, sondern die offene Datei-
 Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Port.',
 'info') }}
 
-<form method="post" id="maintenance-form" action="{{ url_for('maintenance.start_update') }}">
+{# ``stack``: Massenbefehl und Geräteauswahl sind zwei Bereiche und sollen auch
+   so aussehen. Ohne das stossen die beiden Karten aneinander. #}
+<form method="post" id="maintenance-form" class="stack"
+      action="{{ url_for('maintenance.start_update') }}">
   <input type="hidden" name="{{ csrf_field_name }}" value="{{ csrf_token() }}">
+
+  {% if current_user.has('servicing_command.read') %}
+    {# Zugeklappt beim Laden: der Massenbefehl ist das seltenere Werkzeug, die
+       Geräteliste darunter das tägliche. Aufgeklappt schob er sie aus dem
+       Bild. #}
+    <section class="card">
+      <div class="card__header">
+        <button class="btn btn--ghost btn--sm" type="button" data-befehl-schalter
+                aria-expanded="false" title="Massenbefehl ein- und ausklappen">
+          {{ icon('chevron-right', size=14) }}
+        </button>
+        <div class="flex-1">
+          <div class="card__title">{{ icon('terminal', size=17) }} Massenbefehl</div>
+          <div class="card__sub">
+            Eine Befehlszeile über SSH, auf allen unten ausgewählten Clients – jeder als
+            eigener Auftrag mit eigener Ausgabe. <strong>{{ '{sudo}' }}</strong> im Befehl
+            wird ersetzt: mit <code>sudo -n</code>, wo es ohne Passwort geht, sonst mit dem
+            hinterlegten Passwort über stdin. Ohne diese Marke läuft der Befehl als das
+            angemeldete Konto.
+          </div>
+        </div>
+      </div>
+      <div class="card__body stack" data-befehl-feld hidden>
+        <label class="field">
+          <span class="field__label">Vorlage</span>
+          <select class="select" id="befehlsvorlage">
+            <option value="">– eigene Eingabe –</option>
+            {% for name, befehl, erklaerung in befehlsvorlagen %}
+              <option value="{{ befehl }}" data-erklaerung="{{ erklaerung }}">{{ name }}</option>
+            {% endfor %}
+          </select>
+          <span class="field__hint" id="befehlserklaerung">
+            Eine Vorlage füllt nur das Feld darunter – abgeschickt wird von Hand.
+          </span>
+        </label>
+        <label class="field">
+          <span class="field__label">Befehl</span>
+          <input class="input mono" type="text" name="befehl" id="befehl"
+                 maxlength="500" autocomplete="off"
+                 placeholder='echo "Encryption=AlwaysOff" | {sudo} tee -a /etc/vnc/config.d/common.custom'
+                 {% if not current_user.has('servicing_command.execute') %}disabled{% endif %}>
+          <span class="field__hint">
+            Genau eine Zeile. Was der Befehl bewirkt, weiß der, der ihn schreibt – TESM
+            führt ihn aus und hält fest, was zurückkam.
+          </span>
+        </label>
+      </div>
+    </section>
+  {% endif %}
   <section class="card">
     <div class="table-toolbar">
       <label class="check">
         <input type="checkbox" id="select-all">
         <span>Alle auswählen</span>
       </label>
+      <button class="btn btn--sm btn--ghost" type="button" data-alle-einklappen>
+        {{ icon('chevron-up', size=14) }} Alle einklappen
+      </button>
       <span class="table-toolbar__spacer"></span>
+      {% if current_user.has('servicing_command.execute') %}
+        <button class="btn btn--sm" type="submit"
+                formaction="{{ url_for('maintenance.start_command') }}"
+                data-confirm="Den eingetragenen Befehl auf allen ausgewählten Geräten ausführen? Was er bewirkt, entscheidet er selbst – TESM führt ihn nur aus."
+                data-confirm-title="Befehl senden" data-confirm-ok="Senden" data-confirm-style="danger">
+          {{ icon('terminal', size=15) }} Befehl senden
+        </button>
+      {% endif %}
       {% if current_user.has('servicing_update.execute') %}
         <button class="btn btn--sm btn--primary" type="submit"
                 formaction="{{ url_for('maintenance.start_update') }}"
@@ -79,6 +142,7 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
             <th class="sortable">Gerät</th>
             <th class="sortable">IP</th>
             <th class="sortable">Zustand</th>
+            <th class="sortable">Auftrag</th>
             <th class="sortable">Zugangsdaten</th>
             <th class="sortable">Host-Schlüssel</th>
             <th></th>
@@ -95,13 +159,36 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
                   <span class="sr-only">{{ device.name }} auswählen</span>
                 </label>
               </td>
-              <td class="fw-600">{{ device.name }}</td>
+              <td class="fw-600">
+                {# Mitlesen, ohne die Seite zu verlassen -- so war es in der
+                   Fassung 1.2.8, und es fehlte seither. Die Zeile darunter
+                   klappt auf, sobald für dieses Gerät etwas läuft. #}
+                <button class="btn btn--ghost btn--sm" type="button"
+                        data-ausgabe-schalter="{{ device.name }}"
+                        title="Ausgabe dieses Geräts mitlesen">
+                  {{ icon('chevron-right', size=13) }}
+                </button>
+                {{ device.name }}
+              </td>
               <td class="mono fs-sm">{{ device.ip }}</td>
-              <td>
+              <td data-zustand="{{ device.id }}">
                 {% if device.state == 'online' %}{{ pill('online', 'online') }}
                 {% elif device.state == 'offline' %}{{ pill('offline', 'offline') }}
                 {% else %}{{ pill('unbekannt', 'warning') }}{% endif %}
               </td>
+              {# Wie weit ist der Auftrag dieses Geräts? Ohne diese Spalte
+                 blieb nur die Auftragsliste weiter unten -- und dort steht
+                 nicht, welche Zeile zu welchem Gerät gehört, wenn vierzig
+                 Aufträge in derselben Sekunde starten. #}
+              <td data-auftragslage="{{ device.name }}">
+                {% set lage = auftragslage.get(device.name) %}
+                {% if not lage %}<span class="faint fs-xs">–</span>
+                {% elif lage.state == 'running' %}{{ pill('läuft', 'info') }}
+                {% elif lage.state == 'pending' %}{{ pill('wartet', '') }}
+                {% elif lage.state == 'succeeded' %}{{ pill('fertig', 'online') }}
+                {% elif lage.state == 'failed' %}{{ pill('Fehler', 'danger') }}
+                {% else %}{{ pill('unklar', 'warning') }}{% endif %}
+              </td>
               <td class="fs-sm">
                 {{ device.credential_name }}
                 <div class="fs-xs faint">{{ category_labels.get(device.category, device.category) }}</div>
@@ -129,6 +216,11 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
                 {% endif %}
               </td>
             </tr>
+            <tr data-ausgabe-zeile="{{ device.name }}" hidden>
+              <td colspan="8" class="p-0">
+                <pre class="job-output" data-ausgabe="{{ device.name }}">Noch keine Ausgabe.</pre>
+              </td>
+            </tr>
           {% endfor %}
         </tbody>
       </table>
@@ -161,13 +253,13 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
         <thead><tr><th>Gestartet</th><th>Gerät</th><th>Art</th><th>Zustand</th><th>Fortschritt</th><th>Meldung</th></tr></thead>
         <tbody>
           {% for job in jobs %}
-            <tr>
+            <tr data-auftrag="{{ job.id }}">
               <td class="fs-sm nowrap">{{ job.created_at | dt }}</td>
               <td class="fs-sm fw-600">
                 <a href="{{ url_for('maintenance.job_detail', job_id=job.id) }}">{{ job.subject }}</a>
               </td>
               <td class="fs-sm">{{ 'Aktualisierung' if job.kind.endswith('update') else 'Neustart' }}</td>
-              <td>
+              <td data-auftrag-zustand>
                 {% if job.state == 'succeeded' %}{{ pill('erfolgreich', 'online') }}
                 {% elif job.state == 'failed' %}{{ pill('fehlgeschlagen', 'danger') }}
                 {% elif job.state == 'running' %}{{ pill('läuft', 'info') }}
@@ -175,11 +267,12 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
                 {% else %}{{ pill('wartet', '') }}{% endif %}
               </td>
               <td style="min-width:120px">
-                <div class="progress {{ 'progress--success' if job.state == 'succeeded' else ('progress--danger' if job.state == 'failed' else '') }}">
+                <div class="progress {{ 'progress--success' if job.state == 'succeeded' else ('progress--danger' if job.state == 'failed' else '') }}"
+                     data-auftrag-balken>
                   <div class="progress__bar" style="width: {{ job.progress }}%"></div>
                 </div>
               </td>
-              <td class="fs-xs muted">{{ job.message }}</td>
+              <td class="fs-xs muted" data-auftrag-meldung>{{ job.message }}</td>
             </tr>
           {% endfor %}
         </tbody>
@@ -193,6 +286,18 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
 
 {% block scripts %}
 <script type="module" nonce="{{ csp_nonce }}">
+  // Eine Vorlage füllt das Feld und erklärt sich -- abgeschickt wird von Hand.
+  const vorlage = document.getElementById("befehlsvorlage");
+  const befehl = document.getElementById("befehl");
+  const erklaerung = document.getElementById("befehlserklaerung");
+  vorlage?.addEventListener("change", () => {
+    const gewaehlt = vorlage.selectedOptions[0];
+    if (vorlage.value) befehl.value = vorlage.value;
+    erklaerung.textContent =
+      gewaehlt?.dataset.erklaerung ||
+      "Eine Vorlage füllt nur das Feld darunter – abgeschickt wird von Hand.";
+  });
+
   // Auswahl beim Laden bewusst zurücksetzen: Browser stellen den Checked-Zustand
   // sonst aus dem Verlauf wieder her – und dann wird bei "Neustarten"
   // versehentlich das falsche Gerät erwischt.
@@ -205,14 +310,172 @@ Druckerfreigabe. Der PoE-Neustart ist davon getrennt: er schaltet den Switch-Por
          .forEach((box) => (box.checked = all.checked));
   });
 
-  // Auftragsliste nachladen, solange etwas läuft.
+  // Mitlesen: die Zeile unter dem Gerät zeigt, was dort gerade passiert.
+  //
+  // Vorher lud diese Seite sich alle zwei Sekunden komplett neu, solange etwas
+  // lief -- das verwarf jede Auswahl, jeden Tastendruck im Befehlsfeld und
+  // sprang nach oben. Jetzt kommen nur die letzten Zeilen, und die Seite
+  // bleibt stehen.
+  // Der Massenbefehl: zugeklappt geladen, per Kopfzeile aufgeklappt.
+  const befehlSchalter = document.querySelector("[data-befehl-schalter]");
+  const befehlFeld = document.querySelector("[data-befehl-feld]");
+  befehlSchalter?.addEventListener("click", () => {
+    const zu = befehlFeld.hidden;
+    befehlFeld.hidden = !zu;
+    befehlSchalter.setAttribute("aria-expanded", zu ? "true" : "false");
+    befehlSchalter.style.transform = zu ? "rotate(90deg)" : "";
+    if (zu) document.getElementById("befehl")?.focus();
+  });
+
+  const schalter = Array.from(document.querySelectorAll("[data-ausgabe-schalter]"));
+  // Wer von Hand zuklappt, will es zu haben. Ohne dieses Gedaechtnis riss die
+  // naechste Statusabfrage die Zeile wieder auf, weil dort noch Ausgabe stand
+  // -- zwei Sekunden spaeter, jedes Mal.
+  const zugeklappt = new Set();
+  // Beim ersten Fuellen ans Ende springen, danach nur, wenn man ohnehin unten
+  // steht. So steht nach dem Neuladen der Seite das Aktuelle im Bild und nicht
+  // der Anfang von vorgestern -- und wer hochscrollt, um etwas zu lesen, wird
+  // nicht wieder heruntergezogen.
+  const gefuellt = new Set();
+
+  function klappen(name, zu) {
+    const zeile = document.querySelector(`[data-ausgabe-zeile="${CSS.escape(name)}"]`);
+    if (!zeile) return;
+    zeile.hidden = zu;
+    if (zu) zugeklappt.add(name);
+    else zugeklappt.delete(name);
+  }
+
+  schalter.forEach((knopf) => {
+    knopf.addEventListener("click", () => {
+      const name = knopf.dataset.ausgabeSchalter;
+      const zeile = document.querySelector(`[data-ausgabe-zeile="${CSS.escape(name)}"]`);
+      if (zeile) klappen(name, !zeile.hidden);
+    });
+  });
+
+  document.querySelector("[data-alle-einklappen]")?.addEventListener("click", () => {
+    schalter.forEach((knopf) => klappen(knopf.dataset.ausgabeSchalter, true));
+  });
+
+  function zeigen(name, text) {
+    const feld = document.querySelector(`[data-ausgabe="${CSS.escape(name)}"]`);
+    const zeile = document.querySelector(`[data-ausgabe-zeile="${CSS.escape(name)}"]`);
+    if (!feld || !zeile) return;
+    const erstmals = !gefuellt.has(name);
+    const unten = feld.scrollTop + feld.clientHeight >= feld.scrollHeight - 24;
+    feld.textContent = text || "Noch keine Ausgabe.";
+    if (text) gefuellt.add(name);
+    if (erstmals || unten) feld.scrollTop = feld.scrollHeight;
+    // Was läuft, klappt von selbst auf -- wer zusieht, will nicht erst suchen.
+    if (text && zeile.hidden && !zugeklappt.has(name)) zeile.hidden = false;
+  }
+
+  // Zustand, Fortschritt und Meldung eines Auftrags nachziehen.
+  //
+  // Vorher lud die Seite sich dafür komplett neu, sobald der letzte Auftrag
+  // durch war -- und riss damit genau das weg, was man lesen wollte: die
+  // Ausgabe stand da, dann sprang die Seite, und danach war sie leer.
+  const ZUSTAENDE = {
+    succeeded: ["erfolgreich", "pill--online", "progress--success"],
+    failed: ["fehlgeschlagen", "pill--danger", "progress--danger"],
+    running: ["läuft", "pill--info", ""],
+    unknown: ["unklar", "pill--warning", ""],
+    pending: ["wartet", "", ""],
+  };
+
+  function auftragZeigen(job) {
+    const zeile = document.querySelector(`[data-auftrag="${CSS.escape(job.id)}"]`);
+    if (!zeile) return false;
+    const [text, pillenKlasse, balkenKlasse] = ZUSTAENDE[job.state] || ZUSTAENDE.pending;
+    const pille = zeile.querySelector("[data-auftrag-zustand] .pill");
+    if (pille && pille.textContent.trim() !== text) {
+      pille.textContent = text;
+      pille.className = `pill ${pillenKlasse}`.trim();
+    }
+    const balken = zeile.querySelector("[data-auftrag-balken]");
+    if (balken) {
+      balken.className = `progress ${balkenKlasse}`.trim();
+      const inner = balken.querySelector(".progress__bar");
+      if (inner) inner.style.width = `${job.progress || 0}%`;
+    }
+    const meldung = zeile.querySelector("[data-auftrag-meldung]");
+    if (meldung && meldung.textContent.trim() !== (job.message || "")) {
+      meldung.textContent = job.message || "";
+    }
+    return true;
+  }
+
+  // Dieselben fünf Zustände wie in der Auftragsliste -- hier aber neben dem
+  // Gerät, wo man sie sucht.
+  const LAGE = {
+    pending: ["wartet", ""],
+    running: ["läuft", "pill--info"],
+    succeeded: ["fertig", "pill--online"],
+    failed: ["Fehler", "pill--danger"],
+    unknown: ["unklar", "pill--warning"],
+  };
+
+  function lageZeigen(name, zustand) {
+    const zelle = document.querySelector(`[data-auftragslage="${CSS.escape(name)}"]`);
+    if (!zelle) return;
+    const [text, klasse] = LAGE[zustand] || LAGE.pending;
+    const vorhanden = zelle.querySelector(".pill");
+    if (vorhanden && vorhanden.textContent.trim() === text) return;
+    const pille = document.createElement("span");
+    pille.className = `pill ${klasse}`.trim();
+    pille.textContent = text;
+    zelle.replaceChildren(pille);
+  }
+
+  let neueAuftraege = false;
   async function poll() {
+    let weiter = 10000;
     try {
-      const state = await window.tesm.api("{{ url_for('maintenance.status') }}");
-      if (state.running) window.setTimeout(() => location.reload(), state.poll_ms);
+      const state = await window.tesm.api("{{ url_for('maintenance.status') }}", { auto: true });
+      weiter = state.poll_ms || 10000;
+      // Der neueste Auftrag je Gerät gewinnt; die Liste kommt neueste zuerst.
+      const gesehen = new Set();
+      state.jobs.forEach((job) => {
+        if (!gesehen.has(job.subject)) {
+          gesehen.add(job.subject);
+          lageZeigen(job.subject, job.state);
+        }
+        if (job.output) zeigen(job.subject, job.output);
+        // Ein Auftrag, der in der Tabelle noch gar nicht steht, ist neu --
+        // dafür braucht es die Seite einmal frisch, aber erst, wenn nichts
+        // mehr läuft.
+        if (!auftragZeigen(job)) neueAuftraege = true;
+      });
+      // Erreichbarkeit mitziehen -- sonst steht die Seite mit dem Stand ihres
+      // Aufbaus da, und wer nach einem Neustart auf die Rückkehr wartet, sieht
+      // "unbekannt", bis er von Hand neu lädt.
+      (state.devices || []).forEach((geraet) => {
+        const zelle = document.querySelector(`[data-zustand="${geraet.id}"]`);
+        if (!zelle) return;
+        const [text, art] =
+          geraet.state === "online"
+            ? ["online", "pill--online"]
+            : geraet.state === "offline"
+              ? ["offline", "pill--offline"]
+              : ["unbekannt", "pill--warning"];
+        const pille = zelle.querySelector(".pill");
+        if (pille && pille.textContent.trim() !== text) {
+          pille.textContent = text;
+          pille.className = `pill ${art}`;
+        }
+      });
+      // Neu laden nur, wenn Aufträge dazugekommen sind, die in der Tabelle
+      // fehlen -- und auch dann erst, wenn nichts mehr läuft. Wer zusieht,
+      // soll nicht mitten im Lesen weggerissen werden.
+      if (neueAuftraege && !state.running) {
+        window.setTimeout(() => location.reload(), 8000);
+        neueAuftraege = false;
+      }
     } catch {
       /* stumm bleiben – die Seite ist auch ohne Aktualisierung nutzbar */
     }
+    window.setTimeout(poll, weiter);
   }
   poll();
 </script>

apps/tesm/src/tesm/templates/tesm/screen.html

@@ -1,5 +1,6 @@
 {% extends "tesm_core/base.html" %}
 {% from "tesm_core/macros.html" import alert, pill %}
+{% from "tesm/_vnc_flaeche.html" import vnc_flaeche, vnc_status, vnc_zugangsdaten, vnc_tasten %}
 
 {% block page_title %}Bildschirm: {{ device.name }}{% endblock %}
 {% block page_sub %}{{ zugang.ziel }}:{{ zugang.port }}{% endblock %}
@@ -13,13 +14,6 @@
 {% endblock %}
 
 {% block content %}
-{# Die Zugangsdaten stehen in einem eigenen JSON-Block statt in einem
-   data-Attribut: ein Attribut steht im Quelltext der Seite zwischen der
-   Beschriftung und wird beim Kopieren einer Zeile mitgenommen. Beides ist
-   derselbe Inhalt -- der Unterschied ist, wie leicht er einem versehentlich
-   unter die Augen kommt. #}
-<script type="application/json" id="screen-credentials-data">{{ vorgaben | tojson }}</script>
-
 <div class="stack">
   {% if zugang.hinderungsgrund %}
     {{ alert(zugang.hinderungsgrund, 'warning') }}
@@ -30,7 +24,8 @@
       <div class="flex-1">
         <div class="card__title">
           {{ icon('monitor', size=17) }} {{ device.name }}
-          {% if zugang.verfahren %}
+          {% if zugang.absage %}{{ pill('Verbindung abgelehnt', 'warning') }}
+          {% elif zugang.verfahren %}
             {% if zugang.browsertauglich %}{{ pill('Browser-Sitzung möglich', 'online') }}
             {% else %}{{ pill('Verfahren nicht unterstützt', 'warning') }}{% endif %}
           {% endif %}
@@ -39,15 +34,29 @@
           Tastatur und Maus gehen an das Gerät, sobald das Bild steht. Die Zwischenablage
           bleibt getrennt.
           {% if zugang.verfahren %}
-            Angebotene Anmeldeverfahren:
+            Zuletzt angebotene Anmeldeverfahren:
             {% for nummer in zugang.verfahren %}{{ verfahren_name(nummer) }}{% if not loop.last %}, {% endif %}{% endfor %}.
+          {% else %}
+            Welche Anmeldeverfahren das Gerät anbietet, ist nicht bekannt – die Seite
+            fragt es nicht von sich aus.
           {% endif %}
         </div>
       </div>
       <div class="row row--tight">
-        <button class="btn btn--sm" type="button" id="screen-cad" hidden
-                title="Strg+Alt+Entf an das Gerät senden">Strg+Alt+Entf</button>
-        <button class="btn btn--sm" type="button" id="screen-disconnect" hidden>Trennen</button>
+        {{ vnc_tasten() }}
+        {# Ausdrücklich ein Knopf und keine Nebenwirkung des Seitenaufbaus: die
+           Prüfung bricht eine Protokollverhandlung ab, und RealVNC zählt das.
+           Wer sucht, drückt ihn; wer nur arbeiten will, merkt nichts davon. #}
+        <form method="post" data-no-guard
+              action="{{ url_for('screen.probe', device_id=device.id) }}">
+          <input type="hidden" name="{{ csrf_field_name }}" value="{{ csrf_token() }}">
+          <button class="btn btn--sm btn--ghost" type="submit"
+                  title="Fragt das Gerät, welche Anmeldeverfahren es anbietet. Das ist
+eine eigene Verbindung, die abgebrochen wird – ein RealVNC Server zählt so etwas mit.
+Nicht unmittelbar vor dem Verbinden drücken.">
+            Verfahren prüfen
+          </button>
+        </form>
         <a class="btn btn--sm btn--ghost"
            href="{{ url_for('devices.vnc_connection', device_id=device.id) }}">
           {{ icon('download', size=14) }} Verbindungsdatei
@@ -55,29 +64,10 @@
       </div>
     </div>
 
-    <div class="card__body stack">
-      <div id="screen-status" class="screen__status">Wird vorbereitet …</div>
-
-      <form id="screen-credentials" class="row row--tight" hidden onsubmit="return false">
-        <label class="field">
-          <span class="field__label">Benutzer</span>
-          <input class="input" type="text" id="screen-username" autocomplete="off"
-                 value="{{ vorgaben.username }}">
-        </label>
-        <label class="field">
-          <span class="field__label">Passwort</span>
-          <input class="input" type="password" id="screen-password" autocomplete="off">
-        </label>
-        <button class="btn btn--primary" type="button" id="screen-send">Anmelden</button>
-      </form>
-
-      <div id="screen" class="screen"
-           data-socket="{{ websocket_path }}"
-           data-ziel="{{ zugang.ziel }}:{{ zugang.port }}"
-           data-blockiert="{{ '1' if zugang.hinderungsgrund else '0' }}"
-           data-grund="{{ zugang.hinderungsgrund }}">
-        <div id="screen-canvas" class="screen__canvas" hidden></div>
-      </div>
+    <div class="card__body stack" id="screen" data-sitzung="{{ quelle }}">
+      {{ vnc_status() }}
+      {{ vnc_zugangsdaten() }}
+      {{ vnc_flaeche() }}
 
       {% if not darf_geheimnis and device.credential_id %}
         <p class="fs-xs faint">

apps/tesm/src/tesm/templates/tesm/settings_system.html

@@ -46,13 +46,6 @@
           {{ checkbox('dashboard_public', 'Statusübersicht ohne Anmeldung erreichbar',
                       checked=values.dashboard_public,
                       hint_text=specs['dashboard_public'].hint) }}
-          {{ checkbox('vnc_enabled', 'Bildschirmzugriff (VNC) anbieten',
-                      checked=values.vnc_enabled,
-                      hint_text=specs['vnc_enabled'].hint) }}
-          <div class="form-grid">
-            {{ field('vnc_port', 'VNC-Port', value=values.vnc_port, type='number',
-                     hint_text=specs['vnc_port'].hint) }}
-          </div>
         </div>
         <div class="card__footer"><button class="btn btn--primary" type="submit">Speichern</button></div>
       </form>
@@ -113,6 +106,39 @@
       </form>
     </section>
 
+    <section class="card">
+      <div class="card__header">
+        <div class="flex-1">
+          <div class="card__title">{{ icon('monitor', size=17) }} Bildschirm (VNC)</div>
+          <div class="card__sub">
+            Dieselben Regeln wie bei der Konsole: eigenes Recht, frische
+            Passwortbestätigung, getrennte Zwischenablage. Der Knopf erscheint nur, wo
+            ein VNC-Server antwortet – das prüft der Überwachungsdurchlauf mit.
+          </div>
+        </div>
+      </div>
+      <form method="post" action="{{ url_for('settings.system_save') }}">
+        <input type="hidden" name="{{ csrf_field_name }}" value="{{ csrf_token() }}">
+        <div class="card__body stack">
+          {{ checkbox('vnc_enabled', 'Bildschirmzugriff (VNC) anbieten',
+                      checked=values.vnc_enabled,
+                      hint_text=specs['vnc_enabled'].hint) }}
+          <div class="form-grid">
+            {{ field('vnc_port', 'VNC-Port', value=values.vnc_port, type='number',
+                     hint_text=specs['vnc_port'].hint) }}
+            {{ field('vnc_idle_timeout', 'Trennen bei Untätigkeit (Sekunden)',
+                     value=values.vnc_idle_timeout, type='number',
+                     hint_text=specs['vnc_idle_timeout'].hint) }}
+          </div>
+          {{ checkbox('vnc_warn_unencrypted_off',
+                      'Warnung des Viewers vor unverschlüsselter Verbindung unterdrücken',
+                      checked=values.vnc_warn_unencrypted_off,
+                      hint_text=specs['vnc_warn_unencrypted_off'].hint) }}
+        </div>
+        <div class="card__footer"><button class="btn btn--primary" type="submit">Speichern</button></div>
+      </form>
+    </section>
+
     <section class="card">
       <div class="card__header">
         <div class="flex-1">

apps/tesm/src/tesm/worker.py

@@ -113,7 +113,11 @@ class MonitorDaemon:
                 time.sleep(min(1.0, remaining))
                 remaining -= 1.0
 
-        live.info("monitor", "Überwachungsprozess beendet")
+        # Warnstufe, nicht INFO: dass die Ueberwachung *laeuft*, ist der
+        # Normalfall und darf gruen sein. Dass sie **steht**, ist der Zustand,
+        # in dem niemand mehr erfaehrt, dass ein Geraet weg ist -- und genau
+        # diese Zeile sucht man hinterher im Protokoll.
+        live.warning("monitor", "Überwachungsprozess beendet")
         return 0
 
 

deploy/install.sh

@@ -39,6 +39,7 @@ HTTPS=0
 HTTPS_PORT=""
 DOMAIN=""
 ACME_EMAIL=""
+ERZWINGEN=0
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 REPO_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
@@ -49,6 +50,39 @@ warn()  { printf '%s !!%s %s\n' "$COLOR_WARN" "$COLOR_OFF" "$*"; }
 fail()  { printf '%s !!%s %s\n' "$COLOR_ERR" "$COLOR_OFF" "$*" >&2; exit 1; }
 info()  { printf '    %s\n' "$*"; }
 
+# -- Welche Fassung liegt hier, und welche laeuft schon? ---------------------
+#
+# Ein Installationslauf auf dieselbe Fassung macht nichts besser: er baut die
+# Python-Umgebung neu, kopiert dieselben Dateien, laedt nginx neu und startet
+# den Dienst -- mit der einzigen Wirkung, dass die Anwendung ein paar Sekunden
+# weg ist. Wer "update.sh" in einen Zeitplan haengt, bekaeme das taeglich.
+#
+# Verglichen wird die Anwendung **und** der Kern: die beiden Nummern laufen
+# absichtlich auseinander (siehe pyproject.toml), und eine Auslieferung kann
+# denselben Anwendungsstand mit neuem Kern enthalten.
+
+#: Die Nummer aus einer pyproject.toml. Die erste Zeile "version = ..." gilt --
+#: weitere Vorkommen stehen in Abhaengigkeiten und gehen uns nichts an.
+paket_version() {
+  sed -n 's/^version = "\([^"]*\)"/\1/p' "$1" 2>/dev/null | head -1
+}
+
+#: Was in dieser Installation laeuft: "<anwendung> <kern>", sonst leer.
+laufende_version() {
+  local wurzel="$1" modul="$2"
+  [[ -x "$wurzel/venv/bin/python" ]] || return 0
+  "$wurzel/venv/bin/python" -c \
+    "import $modul, tesm_core; print($modul.__version__, tesm_core.__version__)" \
+    2>/dev/null || true
+}
+
+#: Ist das, was hier liegt, schon installiert? Eine eigene Funktion, weil genau
+#: diese Frage sich pruefen lassen muss -- ohne einen Server aufzusetzen.
+gleiche_version() {
+  local laeuft="$1" liegt="$2"
+  [[ -n "$laeuft" && "$laeuft" == "$liegt" ]]
+}
+
 #: Merker fuer die EXIT-Falle. Zurueckgerollt wird nur, was auch gesichert ist.
 SICHERUNG_STEHT=0
 INSTALL_FERTIG=0
@@ -129,6 +163,7 @@ Verwendung: install.sh --app <tesm|tesm-license> [Optionen]
   --acme-email <a>    Kontaktadresse fuer Let's Encrypt.
   --skip-packages     Keine Systempakete installieren
   --yes               Rueckfragen ueberspringen
+  --force             Auch dann einrichten, wenn dieselbe Fassung schon laeuft
 USAGE
 }
 
@@ -144,6 +179,7 @@ while [[ $# -gt 0 ]]; do
     --acme-email) ACME_EMAIL="${2:?}"; shift 2 ;;
     --skip-packages) SKIP_PACKAGES=1; shift ;;
     --yes|-y) ASSUME_YES=1; shift ;;
+    --force) ERZWINGEN=1; shift ;;
     -h|--help) usage; exit 0 ;;
     *) fail "unbekannte Option: $1" ;;
   esac
@@ -261,6 +297,23 @@ FAILED_DIR="/srv/$NAME-failed-$TIMESTAMP"
 IS_UPDATE=0
 [[ -f "$ROOT/data/app.db" ]] && IS_UPDATE=1
 
+# Laeuft hier schon genau das, was hier liegt? Dann ist Schluss, bevor
+# irgendetwas angefasst wird -- und zwar mit Ausstiegscode 0: es ist nichts
+# schiefgegangen, es war nur nichts zu tun.
+MODUL="tesm"
+[[ "$APP" == "tesm-license" ]] && MODUL="tesm_license"
+LIEGT="$(paket_version "$REPO_DIR/apps/$APP/pyproject.toml") $(
+         paket_version "$REPO_DIR/packages/tesm-core/pyproject.toml")"
+LAEUFT="$(laufende_version "$ROOT" "$MODUL")"
+if [[ $IS_UPDATE -eq 1 && $ERZWINGEN -eq 0 ]] && gleiche_version "$LAEUFT" "$LIEGT"; then
+  step "Nichts zu tun"
+  info "$APP ${LIEGT%% *} (tesm-core ${LIEGT##* }) laeuft hier bereits."
+  info "Ein zweiter Durchlauf wuerde nur die Umgebung neu bauen und den"
+  info "Dienst neu starten -- ohne dass sich etwas aendert."
+  info "Trotzdem neu einrichten: --force"
+  exit 0
+fi
+
 step "TESM-Installation"
 info "Anwendung   : $APP${INSTANCE:+ (Instanz $INSTANCE)}"
 info "Ziel        : $ROOT"
@@ -278,6 +331,7 @@ else
   info "nginx       : Port $HTTP_PORT (nur HTTP)"
 fi
 info "Modus       : $([[ $IS_UPDATE -eq 1 ]] && echo Aktualisierung || echo Neuinstallation)"
+info "Fassung     : ${LIEGT%% *} (tesm-core ${LIEGT##* })${LAEUFT:+, bisher ${LAEUFT%% *}}"
 
 if [[ $ASSUME_YES -eq 0 ]]; then
   read -r -p "Fortfahren? [j/N] " answer
@@ -364,9 +418,32 @@ info "Dateien abgeglichen (Instanzdaten unter data/ bleiben unangetastet)"
 
 # -- venv --------------------------------------------------------------------
 step "Python-Umgebung"
-if [[ ! -x "$ROOT/venv/bin/python3" ]]; then
+# Ein venv haengt an der **Minor-Fassung**, mit der er gebaut wurde: die Pakete
+# liegen unter lib/python3.X. Wechselt die Systemfassung -- ein Release-Upgrade
+# von Ubuntu bringt genau das, 24.04 hat 3.12 und 26.04 hat 3.14 --, dann ist
+# venv/bin/python3 weiter ausfuehrbar: der Verweis zeigt auf /usr/bin/python3,
+# also auf den **neuen** Interpreter. Der venv sieht heil aus und ist es nicht.
+# Er findet danach kein einziges Paket mehr, nicht einmal pip.
+#
+# Gemessen auf dem Testserver, mit verschobenem lib-Verzeichnis:
+#     [[ -x venv/bin/python3 ]]        -> wahr
+#     venv/bin/python3 -m pip --version -> "No module named pip"
+#
+# Die alte Pruefung fragte nur nach der Ausfuehrbarkeit. Sie haette den toten
+# venv behalten und waere eine Zeile spaeter an "python3 -m pip" gescheitert --
+# mitten in einer Aktualisierung, auf einem Server, dessen Dienste ohnehin
+# schon stehen. Gefragt wird deshalb, was gebraucht wird: laesst sich in
+# diesem venv pip benutzen?
+venv_traegt() {
+  [[ -x "$ROOT/venv/bin/python3" ]] || return 1
+  "$ROOT/venv/bin/python3" -c "import pip" >/dev/null 2>&1
+}
+if ! venv_traegt; then
+  # Ohne --clear: ein erneutes "venv" ergaenzt das fehlende lib-Verzeichnis und
+  # holt pip zurueck; die Abhaengigkeiten kommen gleich darunter ohnehin neu.
+  # Auch das ist gemessen und nicht angenommen.
   python3 -m venv "$ROOT/venv"
-  info "venv erzeugt"
+  info "Python-Umgebung aufgebaut ($(python3 -V 2>&1))"
 fi
 # Immer ueber "python3 -m pip" -- der pip-Shim im venv baeckt einen absoluten
 # Pfad in seinen Shebang, der nach einer Umbenennung des Verzeichnisses bricht.

deploy/tesm-motd

@@ -150,6 +150,22 @@ def main(argv: list[str] | None = None) -> int:
         globals().update(AMBER="", DIM="", BOLD="", RESET="")
 
     root = Path(args.root)
+
+    # Gibt es diese Installation ueberhaupt noch? Wenn nicht, ist hier nichts
+    # zu melden -- auch kein Fehler.
+    #
+    # Der Hook unter /etc/update-motd.d bleibt liegen, wenn jemand eine
+    # Installation von Hand entfernt; einen Rueckbau bringt TESM nicht mit.
+    # Vorher druckte jeder dieser Hooks trotzdem seinen vollen Banner und
+    # darunter "Datenbank nicht lesbar". Auf dem Testserver standen so
+    # vierzehn Bloecke fuer vierzehn laengst geloeschte Probeinstallationen
+    # vor jeder Anmeldung -- und der echte Banner ging darin unter.
+    #
+    # Eine entfernte Installation ist keine kaputte. Eine Datenbank, die da
+    # ist und sich nicht lesen laesst, dagegen schon: die meldet sich weiter.
+    if not (root / "data" / "app.db").is_file():
+        return 0
+
     # Kein isatty()-Test: dieses Skript schreibt beim Login nicht auf ein
     # Terminal, sondern ueber run-parts in eine Datei. Der Betrachter ist
     # trotzdem ein echtes Terminal -- deshalb immer Farbe.

deploy/update.sh

@@ -33,6 +33,8 @@ EXTRA=("$@")
   echo "Verwendung: update.sh <tesm|tesm-license> [tag] [install.sh-Argumente ...]" >&2
   echo "Beispiel  : update.sh tesm latest --instance test" >&2
   echo "Ohne Rueckfrage: --yes anhaengen (ohne Terminal zwingend)." >&2
+  echo "Laeuft die Fassung schon, endet der Aufruf ohne Arbeit; --force setzt" >&2
+  echo "sie trotzdem neu auf." >&2
   exit 2
 }
 
@@ -173,6 +175,32 @@ release_holen() {
 
 release_holen
 
+# Schon installiert? Dann gar nicht erst fragen.
+#
+# Dieselbe Pruefung steht in install.sh und gilt dort endgueltig (sie
+# vergleicht auch den Kern). Hier steht sie noch einmal, weil ein Update, das
+# ohne Wirkung bleibt, gar nicht erst nach einer Bestaetigung fragen soll --
+# und weil "es lief durch" sonst wie eine Aktualisierung aussieht.
+ERZWINGEN=0
+for ((i = 0; i < ${#EXTRA[@]}; i++)); do
+  [[ "${EXTRA[i]}" == "--force" ]] && ERZWINGEN=1
+done
+INSTALLATION="$APP"
+for ((i = 0; i < ${#EXTRA[@]}; i++)); do
+  [[ "${EXTRA[i]}" == "--instance" ]] && INSTALLATION="$APP-${EXTRA[i + 1]:-}"
+done
+MODUL="tesm"
+[[ "$APP" == "tesm-license" ]] && MODUL="tesm_license"
+if [[ $ERZWINGEN -eq 0 && -x "/srv/$INSTALLATION/venv/bin/python" ]]; then
+  LAEUFT="$("/srv/$INSTALLATION/venv/bin/python" -c \
+            "import $MODUL; print($MODUL.__version__)" 2>/dev/null || true)"
+  if [[ -n "$LAEUFT" && "v$LAEUFT" == "$TAG" ]]; then
+    echo "==> $APP $LAEUFT laeuft hier bereits -- nichts zu tun."
+    echo "    Trotzdem neu einrichten: --force"
+    exit 0
+  fi
+fi
+
 # --yes darf auch hier stehen, nicht nur bei install.sh und upgrade.sh. Es
 # bleibt in EXTRA: install.sh bekommt es ohnehin, doppelt schadet nicht.
 OHNE_RUECKFRAGE=0

docs/BETRIEB.md

@@ -120,6 +120,14 @@ sudo bash /srv/tesm/deploy/update.sh tesm
 sudo bash /srv/tesm-license/deploy/update.sh tesm-license
 ```
 
+**Läuft die Fassung schon, passiert nichts.** `update.sh` vergleicht den
+aufgelösten Tag mit dem, was installiert ist, und endet mit `0`, bevor es eine
+Rückfrage stellt; `install.sh` prüft es noch einmal genauer (Anwendung **und**
+Kern) und bricht vor dem ersten Eingriff ab. Ein zweiter Lauf auf dieselbe
+Fassung baut sonst die Python-Umgebung neu, kopiert dieselben Dateien und
+startet den Dienst neu -- ein paar Sekunden Ausfall ohne jede Wirkung. Wer das
+trotzdem will (eine beschädigte Installation etwa), hängt `--force` an.
+
 Alles nach dem Tag geht unverändert an `install.sh` weiter -- das ist der Weg,
 eine **benannte Instanz** zu aktualisieren:
 

packages/tesm-core/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tesm-core"
-version = "2.8.5"
+version = "2.8.18"
 description = "Gemeinsames Anwendungsgeruest (Auth, RBAC, Navigation, Design-System, Migrationen) fuer TESM und TESM-Lizenzserver"
 requires-python = ">=3.11"
 dependencies = [

packages/tesm-core/src/tesm_core/auth/models.py

@@ -266,6 +266,35 @@ def _bitte_bestaetigen(permission: str) -> Any:
     return redirect(url_for("auth.reauth"))
 
 
+def _heikel(permissions: tuple[str, ...], mode: str) -> str:
+    """Welches Recht verlangt hier eine frische Bestaetigung? Sonst leer.
+
+    Bei ``mode="all"`` ist die Antwort einfach: jedes genannte Recht wird
+    gebraucht, also zaehlt jedes heikle darunter.
+
+    Bei ``mode="any"`` nicht. Diese Seiten nennen mehrere **unabhaengige**
+    Wege hinein, und welcher genommen wird, entscheidet das Konto. Der
+    Protokollverlauf etwa nennt "logs_history.read" und "logs_history.export":
+    lesen ist harmlos, mitnehmen nicht. Gezaehlt wurde aber ueber alle
+    genannten Rechte -- und so verlangte das blosse **Ansehen** des Verlaufs
+    nach fuenfzehn Minuten eine Passworteingabe, mit dem Hinweis, man greife
+    auf einen Datenexport zu. Das stimmte nicht, und wer es dreimal liest,
+    glaubt die Meldung beim vierten Mal auch dann nicht, wenn sie zutrifft.
+
+    Gefragt wird deshalb: haette dieses Konto die Seite auch ohne das heikle
+    Recht geoeffnet? Dann gibt es nichts zu bestaetigen. Die Ausfuhr selbst
+    haengt an ihrer eigenen Route, und die nennt nur ein Recht.
+    """
+    heikle = [p for p in permissions if _verlangt_wiederanmeldung(p)]
+    if not heikle:
+        return ""
+    if mode == "any":
+        harmlos = [p for p in permissions if p not in heikle]
+        if any(current_user.has(p) for p in harmlos):
+            return ""
+    return heikle[0]
+
+
 def permission_required(*permissions: str, mode: str = "all") -> Callable[..., Any]:
     """Erzwingt Rechte serverseitig.
 
@@ -289,9 +318,9 @@ def permission_required(*permissions: str, mode: str = "all") -> Callable[..., A
             # in jeder Route einzeln. Vorher hing es daran, dass jemand an den
             # Dekorator dachte: dieselbe Lizenz herunterzuladen fragte nach,
             # sie per Mail zu verschicken nicht.
-            heikel = [p for p in permissions if _verlangt_wiederanmeldung(p)]
+            heikel = _heikel(permissions, mode)
             if heikel and not _wiederanmeldung_frisch():
-                return _bitte_bestaetigen(heikel[0])
+                return _bitte_bestaetigen(heikel)
             return view(*args, **kwargs)
 
         wrapper._required_permissions = permissions  # type: ignore[attr-defined]

packages/tesm-core/src/tesm_core/cli_web.py

@@ -42,6 +42,8 @@ def _config_from_settings(extension: Any, conn: Any) -> webserver.WebConfig:
         ],
     )
     return webserver.WebConfig(
+        # Die neue Schreibweise, sobald der Webserver sie kennt.
+        http2_directive=webserver.nginx_kann_http2(),
         app_key=extension.config.site_key,
         upstream=str(extension.registry.get("upstream", "127.0.0.1:5000")),
         static_root=str(

packages/tesm-core/src/tesm_core/rbac/common.py

@@ -129,7 +129,7 @@ DIAGNOSTICS = Resource(
 
 LOGS_LIVE = Resource(
     key="logs_live",
-    label="Laufendes Protokoll",
+    label="Live-Protokoll",
     actions=(A.READ,),
 )
 

packages/tesm-core/src/tesm_core/static/tesm_core/css/components.css

@@ -1133,6 +1133,16 @@
   }
   .log-view mark { background: var(--warning-soft); color: var(--warning); border-radius: 3px; }
 
+  /* Stufen im laufenden Protokoll. Die Zuordnung der Farbrollen ist Absicht:
+     --warning ist bernsteinfarben und traegt den HINWEIS, --danger ist rot und
+     traegt die WARNUNG. Wer das nach den Namen "aufraeumt", dreht die Bedeutung
+     um: ein Geraet, das nicht antwortet, waere dann orange und eines, das neu
+     startet, rot. */
+  .log-view__zeile--info { color: var(--success); }
+  .log-view__zeile--hinweis { color: var(--warning); }
+  .log-view__zeile--warnung { color: var(--danger); }
+  .log-view__zeile--fehler { color: var(--danger); font-weight: 600; }
+
   .kv { display: grid; grid-template-columns: auto 1fr; gap: var(--sp-2) var(--sp-4); font-size: var(--fs-base); }
   .kv dt { color: var(--text-faint); white-space: nowrap; }
   .kv dd { margin: 0; min-width: 0; overflow-wrap: anywhere; }
@@ -1275,6 +1285,24 @@
     color: var(--text-faint);
   }
 
+  /* Mitlesen auf der Wartungsseite: die Ausgabe eines laufenden Auftrags,
+     direkt unter seinem Geraet. Dunkler Grund wie in jeder Konsole -- was
+     dort steht, kommt von einer fremden Maschine und nicht aus dieser
+     Oberflaeche. */
+  .job-output {
+    margin: 0;
+    max-height: 220px;
+    overflow: auto;
+    padding: var(--sp-3) var(--sp-4);
+    background: #101216;
+    color: #d7dbe0;
+    font-family: var(--font-mono);
+    font-size: var(--fs-xs);
+    line-height: 1.5;
+    white-space: pre-wrap;
+    word-break: break-word;
+  }
+
   /* ---------------------------------------------------------------------- #
      Bildschirmsitzung (VNC)
 
@@ -1295,6 +1323,9 @@
        sprengen; noVNC skaliert das Bild hinein. */
     height: min(72vh, 760px);
   }
+  /* Im Fenster ist weniger Platz -- und das Fenster soll nicht ueber den
+     Bildschirmrand hinauswachsen, nur weil das Geraet hochaufloesend ist. */
+  dialog.modal .screen__canvas { height: min(62vh, 620px); }
   .screen__status {
     font-size: var(--fs-sm);
     color: var(--text-faint);

packages/tesm-core/src/tesm_core/static/tesm_core/js/screen.js

@@ -8,42 +8,266 @@
 // Die Meldungen sind der eigentliche Wert. Eine Sitzung, die schwarz bleibt,
 // laesst offen, ob es an der Berechtigung, am Netz, am Server oder am
 // Passwort liegt -- und wer das nicht sieht, sucht den Fehler in TESM.
+//
+// **Ein Bauteil, zwei Orte.** Dieselbe Sitzung laeuft auf der Bildschirmseite
+// und im Fenster der Statusuebersicht. Sie holt alles, was sie braucht, aus
+// einer JSON-Auskunft des Servers -- damit gibt es keine zweite Fassung, die
+// man beim naechsten Fund vergisst nachzuziehen.
 
 import RFB from "../vendor/novnc/core/rfb.js";
 
-const wurzel = document.getElementById("screen");
-if (wurzel) {
-  starten(wurzel);
-}
+// Drei Eingriffe in private Methoden der mitgelieferten Bibliothek. Bewusst
+// hier und nicht in der Bibliothek selbst: eine neue Fassung von noVNC laesst
+// sich dann austauschen, ohne eine Aenderung nachzupflegen -- faellt eine
+// Methode weg, entfaellt nur die Auskunft, nicht die Sitzung.
+//
+// Zwei davon holen nur Auskunft (_fail, _socketClose). Der dritte greift in
+// die Wahl des Sicherheitsverfahrens ein -- aber erst, **nachdem** eines
+// nachweislich nicht getragen hat, oder weil eines schon einmal getragen hat.
+//
+// Die Vorgeschichte gehoert dazu, damit niemand den Schritt zurueckgeht: hier
+// stand einmal eine Vorauswahl, die ohne hinterlegte Zugangsdaten ein
+// Verfahren ohne Anmeldung erzwang, weil RealVNC RA2ne zuerst nennt. Das war
+// geraten und falsch. Was jetzt hier steht, ist das Gegenteil einer Vermutung:
+// ein Befund aus einer vorherigen Sitzung.
+const istUnterstuetzt = RFB.prototype._isSupportedSecurityType;
 
-function starten(wurzel) {
-  const leinwand = document.getElementById("screen-canvas");
-  const zeile = document.getElementById("screen-status");
-  const abfrage = document.getElementById("screen-credentials");
-  const feldBenutzer = document.getElementById("screen-username");
-  const feldPasswort = document.getElementById("screen-password");
-  const knopfSenden = document.getElementById("screen-send");
-  const knopfTrennen = document.getElementById("screen-disconnect");
-  const knopfStrg = document.getElementById("screen-cad");
+//: Den *Grund* eines Fehlschlags kennt nur ``_fail`` -- das Ereignis
+//: "disconnect" traegt ihn nicht, und der Weg ueber die Protokollausgabe
+//: funktioniert nicht: die Bibliothek bindet ``console.error`` beim Laden,
+//: also bevor eine Seite etwas daran aendern koennte.
+let letzterGrund = "";
+const originalFail = RFB.prototype._fail;
+RFB.prototype._fail = function (details) {
+  letzterGrund = String(details);
+  return originalFail.call(this, details);
+};
 
-  const pfad = wurzel.dataset.socket;
-  const schema = window.location.protocol === "https:" ? "wss:" : "ws:";
-  const adresse = `${schema}//${window.location.host}${pfad}`;
+//: Und der Abschluss der Leitung selbst: der Schliesscode sagt, ob TESM
+//: abgewiesen hat (1008), ob es ein Serverfehler war (1011) -- oder ob die
+//: Verbindung nie zustande kam (1006).
+let letzterCode = 0;
+const originalSocketClose = RFB.prototype._socketClose;
+RFB.prototype._socketClose = function (ereignis) {
+  letzterCode = (ereignis && ereignis.code) || 0;
+  if (ereignis && ereignis.reason) {
+    letzterGrund = letzterGrund || String(ereignis.reason);
+  }
+  return originalSocketClose.call(this, ereignis);
+};
 
-  const vorgabe = JSON.parse(
-    document.getElementById("screen-credentials-data")?.textContent || "{}",
-  );
+//: Hoechstens ein zweiter Anlauf. Jeder Versuch ist eine Verbindung, und ein
+//: RealVNC Server zaehlt abgebrochene Versuche mit -- wer dreimal anklopft,
+//: sperrt sich aus.
+const HOECHSTENS = 2;
 
+//: So lange darf "wird aufgebaut" stehen, bevor die Seite selbst nachsieht.
+//: Kommt die WebSocket-Verbindung gar nicht erst zustande, wartet noVNC ohne
+//: jedes Ereignis, und die Seite stuende stumm bis zum Seitenwechsel.
+const AUFBAU_GRENZE = 12000;
+
+//: Verfahren, die im Browser keinen Schluesseltausch kosten.
+//:
+//: Der Grund steht in der Bibliothek, `core/ra2.js`: fuer RA2ne erzeugt der
+//: **Browser** bei jeder Sitzung ein eigenes 2048-Bit-RSA-Schluesselpaar, in
+//: JavaScript. Die Primzahlsuche dafuer dauert ein bis drei Minuten -- genau
+//: die Zeit, die zwischen Klick und Bild lag. "Ohne Authentifizierung" (1)
+//: kostet davon nichts.
+//:
+//: Deshalb kommt es zuerst, **wenn der Server es anbietet** und wir nicht
+//: ohnehin schon wissen, was hier traegt. Das ist nicht dieselbe Vorauswahl
+//: wie in 2.8.14: die war geraten, diese steht auf einer Messung. Traegt sie
+//: nicht, nimmt der zweite Anlauf die Reihenfolge des Servers -- dann dauert
+//: es eben.
+const OHNE_SCHLUESSELTAUSCH = new Set([1]);
+
+//: RA2ne. Wird es ausgehandelt, ist die Wartezeit erklaerbar und kein Fehler.
+const RA2NE = 6;
+
+//: Tastenkombinationen, die der Arbeitsplatz selbst abfaengt und die deshalb
+//: einen Knopf brauchen. X11-Keysyms.
+const ALT_LINKS = 0xffe9;
+const F4 = 0xffc1;
+const F5 = 0xffc2;
+
+const schema = window.location.protocol === "https:" ? "wss:" : "ws:";
+
+/**
+ * Baut eine Sitzung in diesem Behaelter auf.
+ *
+ * ``quelle`` ist die Adresse der JSON-Auskunft; alles Weitere steht dort.
+ * Rueckgabe: eine Funktion, die die Sitzung wieder abbaut.
+ */
+export function starteSitzung(wurzel, quelle, { beiEnde = null } = {}) {
+  const teil = (rolle) => wurzel.querySelector(`[data-rolle="${rolle}"]`);
+  const leinwand = teil("leinwand");
+  const zeile = teil("status");
+  const abfrage = teil("zugangsdaten");
+  const feldBenutzer = teil("benutzer");
+  const feldPasswort = teil("passwort");
+  const knopfSenden = teil("anmelden");
+  const knopfTrennen = teil("trennen");
+  const knoepfeSitzung = [...wurzel.querySelectorAll("[data-rolle^='taste-']"), knopfTrennen];
+
+  const gescheitert = new Set();
   let rfb = null;
+  let aufbauUhr = 0;
+  let versuche = 0;
+  let stand = false;
+  let daten = null;
+  let letzterZugang = {};
+  let beendet = false;
 
   function melden(text, art = "") {
+    if (!zeile) return;
     zeile.textContent = text;
     zeile.className = `screen__status${art ? " screen__status--" + art : ""}`;
   }
 
+  function sitzungsknoepfe(sichtbar) {
+    knoepfeSitzung.forEach((knopf) => {
+      if (knopf) knopf.hidden = !sichtbar;
+    });
+  }
+
+  function grund() {
+    const teile = [];
+    if (letzterGrund) {
+      teile.push(letzterGrund.replace(/^Failed (when|while) \w+: /, ""));
+    }
+    if (rfb && rfb._rfbAuthScheme > 0) {
+      teile.push(`gewähltes Verfahren: ${rfb._rfbAuthScheme}`);
+    }
+    if (gescheitert.size) {
+      teile.push(`erfolglos: ${[...gescheitert].join(", ")}`);
+    }
+    return teile.join(" · ");
+  }
+
+  // Steht die WebSocket-Strecke zu TESM überhaupt? Zwei sehr verschiedene
+  // Ursachen sehen von aussen gleich aus: der VNC-Server mag nicht, oder die
+  // Verbindung kommt nie zustande, weil ein Proxy zwischen Browser und TESM
+  // "Upgrade" nicht durchreicht. Diese Probe trennt sie.
+  function streckeTesten() {
+    return new Promise((fertig) => {
+      let beantwortet = false;
+      const pruefling = new WebSocket(`${schema}//${window.location.host}/ws/probe`);
+      const schliessen = (ergebnis) => {
+        if (beantwortet) return;
+        beantwortet = true;
+        try {
+          pruefling.close();
+        } catch (fehler) {
+          /* schon zu */
+        }
+        fertig(ergebnis);
+      };
+      pruefling.onmessage = () => schliessen(true);
+      pruefling.onerror = () => schliessen(false);
+      pruefling.onclose = () => schliessen(false);
+      window.setTimeout(() => schliessen(false), 4000);
+    });
+  }
+
+  // Hat das gewählte Verfahren die Verbindung abreissen lassen? Dann ist das
+  // ein Befund und keine Vermutung -- der naechste Anlauf laesst es aus. Nur
+  // solange nie ein Bild stand: bricht eine **laufende** Sitzung ab, liegt es
+  // nicht am Anmeldeverfahren.
+  function naechsterVersuch() {
+    const verfahren = rfb && rfb._rfbAuthScheme > 0 ? rfb._rfbAuthScheme : 0;
+    if (!verfahren || versuche >= HOECHSTENS || gescheitert.has(verfahren)) {
+      return false;
+    }
+    gescheitert.add(verfahren);
+    melden(
+      `Verfahren ${verfahren} hat die Verbindung nicht getragen – nächster Anlauf ` +
+        "mit dem nächsten, das der Server anbietet …",
+      "warnung",
+    );
+    const zugang = letzterZugang;
+    rfb = null;
+    window.setTimeout(() => verbinden(zugang), 400);
+    return true;
+  }
+
+  function verfahrenMelden(gewaehlt) {
+    if (!gewaehlt || gewaehlt === daten.bewaehrt || !daten.meldeweg) return;
+    fetch(daten.meldeweg, {
+      method: "POST",
+      credentials: "same-origin",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Requested-With": "fetch",
+        "X-CSRF-Token": document.body?.dataset.csrf || "",
+      },
+      body: JSON.stringify({ verfahren: gewaehlt }),
+    }).catch(() => {
+      /* Eine Merkhilfe, kein Teil der Sitzung. */
+    });
+  }
+
   function verbinden(zugang) {
-    melden("Verbindung wird aufgebaut …");
-    rfb = new RFB(leinwand, adresse, {
+    if (beendet) return;
+    melden(versuche ? "Nächster Versuch …" : "Verbindung wird aufgebaut …");
+    letzterGrund = "";
+    letzterCode = 0;
+    letzterZugang = zugang;
+    versuche += 1;
+    window.clearTimeout(aufbauUhr);
+    aufbauUhr = window.setTimeout(() => {
+      // Ein ausgehandeltes RA2ne ist kein Fehler, sondern Rechenzeit: der
+      // Browser erzeugt dafuer gerade einen 2048-Bit-Schluessel. Das zu
+      // melden ist das Gegenteil einer Warnung -- es nimmt die Sorge.
+      if (rfb && rfb._rfbAuthScheme === RA2NE) {
+        melden(
+          "Der Server verlangt RA2ne (RSA-AES). Dafür erzeugt der Browser ein " +
+            "2048-Bit-Schlüsselpaar – das dauert ein bis drei Minuten. Bitte warten.",
+          "warnung",
+        );
+        return;
+      }
+      melden("Es kommt keine Antwort. Wird geprüft, woran es liegt …", "warnung");
+      streckeTesten().then((steht) => {
+        melden(
+          steht
+            ? "Die WebSocket-Strecke zu TESM steht, aber die Sitzung kommt nicht " +
+                "zustande. Antwortet der VNC-Server auf dem Gerät noch? Ein Neustart " +
+                "des VNC-Dienstes räumt eine Sperre ab."
+            : "Die WebSocket-Verbindung zu TESM kommt nicht zustande – auch eine " +
+                "einfache Probe scheitert. Ein Proxy zwischen Browser und TESM muss " +
+                "die Kopfzeilen Upgrade und Connection durchreichen (nginx: " +
+                "location /ws/ mit proxy_set_header Upgrade $http_upgrade).",
+          "fehler",
+        );
+      });
+    }, AUFBAU_GRENZE);
+
+    // Drei Regeln, alle aus Messung und keine aus Vermutung:
+    //
+    // 1. Was schon einmal getragen hat, kommt zuerst.
+    // 2. Sonst das Verfahren ohne Schluesseltausch -- aber nur, wenn der
+    //    Server es nachweislich anbietet (sonst faende noVNC gar keines und
+    //    scheiterte sofort). RA2ne kostet sonst ein bis drei Minuten
+    //    Rechenzeit im Browser, jedes Mal.
+    // 3. Was abgerissen ist, wird nicht noch einmal gewaehlt.
+    //
+    // Beides gilt nur fuer den **ersten** Anlauf; danach zaehlt die
+    // Reihenfolge des Servers, abzueglich dessen, was schon abgerissen ist.
+    const bewaehrt = daten.bewaehrt || 0;
+    const angeboten = daten.verfahren || [];
+    const schnell = angeboten.filter((typ) => OHNE_SCHLUESSELTAUSCH.has(typ));
+    let bevorzugt = 0;
+    if (versuche === 1) {
+      if (bewaehrt > 0 && !gescheitert.has(bewaehrt)) bevorzugt = bewaehrt;
+      else if (schnell.length && !gescheitert.has(schnell[0])) bevorzugt = schnell[0];
+    }
+    RFB.prototype._isSupportedSecurityType = function (typ) {
+      if (gescheitert.has(typ)) return false;
+      if (bevorzugt) return typ === bevorzugt;
+      return istUnterstuetzt.call(this, typ);
+    };
+
+    rfb = new RFB(leinwand, `${schema}//${window.location.host}${daten.socket}`, {
       credentials: zugang,
       // Eine Bildschirmsitzung soll nicht nebenbei die Zwischenablage des
       // Arbeitsplatzes mit dem Geraet teilen -- das ist eine eigene
@@ -55,80 +279,190 @@ function starten(wurzel) {
     rfb.focusOnClick = true;
 
     rfb.addEventListener("connect", () => {
-      melden(`Verbunden mit ${wurzel.dataset.ziel}`, "ok");
-      abfrage.hidden = true;
+      window.clearTimeout(aufbauUhr);
+      stand = true;
+      verfahrenMelden(rfb && rfb._rfbAuthScheme > 0 ? rfb._rfbAuthScheme : 0);
+      melden(`Verbunden mit ${daten.ziel}`, "ok");
+      if (abfrage) abfrage.hidden = true;
       leinwand.hidden = false;
-      knopfTrennen.hidden = false;
-      knopfStrg.hidden = false;
+      sitzungsknoepfe(true);
     });
 
     rfb.addEventListener("disconnect", (ereignis) => {
+      window.clearTimeout(aufbauUhr);
       leinwand.hidden = true;
-      knopfTrennen.hidden = true;
-      knopfStrg.hidden = true;
+      sitzungsknoepfe(false);
       if (ereignis.detail && ereignis.detail.clean) {
-        melden("Sitzung beendet.");
+        // Beim sauberen Schluss steht der Grund im Schliessrahmen -- etwa,
+        // dass TESM wegen Untätigkeit getrennt hat.
+        melden(letzterGrund ? `Sitzung beendet – ${letzterGrund}` : "Sitzung beendet.");
+        // Im Fenster gibt es nach dem Trennen nichts mehr zu sehen: ein leerer
+        // Rahmen, den man wegklicken muss. Bei einem **Abbruch** bleibt es
+        // stehen -- dort steht der Grund, und der ist der ganze Zweck.
+        beiEnde?.();
+      } else if (!stand && naechsterVersuch()) {
+        return;
       } else {
+        const erklaerung = grund();
         melden(
-          "Verbindung abgebrochen. Antwortet der VNC-Server noch, und lässt der " +
-            "Arbeitsplatz die Verbindung zu?",
+          erklaerung
+            ? `Verbindung abgebrochen – ${erklaerung}`
+            : "Verbindung abgebrochen. Wird geprüft, woran es liegt …",
           "fehler",
         );
+        if (letzterCode === 1006 || !erklaerung) {
+          streckeTesten().then((steht) => {
+            melden(
+              steht
+                ? `${erklaerung || "Verbindung abgebrochen"} – die WebSocket-Strecke zu ` +
+                    "TESM selbst steht (Probe erfolgreich), der Abbruch kommt also von " +
+                    "der VNC-Seite."
+                : "Die WebSocket-Verbindung zu TESM kommt nicht zustande – auch eine " +
+                    "einfache Probe scheitert. Ein Proxy zwischen Browser und TESM muss " +
+                    "die Kopfzeilen Upgrade und Connection durchreichen (nginx: " +
+                    "location /ws/ mit proxy_set_header Upgrade $http_upgrade). Dasselbe " +
+                    "gilt für die Browser-Konsole.",
+              "fehler",
+            );
+          });
+        }
       }
       rfb = null;
     });
 
     rfb.addEventListener("credentialsrequired", (ereignis) => {
+      window.clearTimeout(aufbauUhr);
       const gefragt = ereignis.detail.types || ["password"];
-      abfrage.hidden = false;
-      feldBenutzer.closest("label").hidden = !gefragt.includes("username");
+      if (abfrage) abfrage.hidden = false;
+      if (feldBenutzer) feldBenutzer.closest("label").hidden = !gefragt.includes("username");
       melden("Der VNC-Server verlangt Zugangsdaten.", "warnung");
-      (gefragt.includes("username") ? feldBenutzer : feldPasswort).focus();
+      (gefragt.includes("username") ? feldBenutzer : feldPasswort)?.focus();
     });
 
     rfb.addEventListener("securityfailure", (ereignis) => {
+      window.clearTimeout(aufbauUhr);
       melden(
         `Anmeldung abgelehnt: ${ereignis.detail.reason || "kein Grund genannt"}`,
         "fehler",
       );
-      abfrage.hidden = false;
-    });
-
-    rfb.addEventListener("desktopname", (ereignis) => {
-      wurzel.dataset.desktop = ereignis.detail.name;
+      if (abfrage) abfrage.hidden = false;
     });
   }
 
   knopfSenden?.addEventListener("click", () => {
     const zugang = {};
-    if (feldBenutzer.value) zugang.username = feldBenutzer.value;
-    if (feldPasswort.value) zugang.password = feldPasswort.value;
-    if (rfb) {
-      rfb.sendCredentials(zugang);
-    } else {
-      verbinden(zugang);
-    }
+    if (feldBenutzer?.value) zugang.username = feldBenutzer.value;
+    if (feldPasswort?.value) zugang.password = feldPasswort.value;
+    if (rfb) rfb.sendCredentials(zugang);
+    else verbinden(zugang);
   });
 
   [feldBenutzer, feldPasswort].forEach((feld) =>
     feld?.addEventListener("keydown", (ereignis) => {
       if (ereignis.key === "Enter") {
         ereignis.preventDefault();
-        knopfSenden.click();
+        knopfSenden?.click();
       }
     }),
   );
 
   knopfTrennen?.addEventListener("click", () => rfb && rfb.disconnect());
-  knopfStrg?.addEventListener("click", () => rfb && rfb.sendCtrlAltDel());
+  teil("taste-cad")?.addEventListener("click", () => rfb && rfb.sendCtrlAltDel());
+  // Alt+F4 kennt noVNC nicht als fertigen Griff: der Arbeitsplatz faengt die
+  // Kombination selbst ab, bevor sie in der Leinwand ankommt. Also einzeln --
+  // Alt halten, F4 tippen, Alt loslassen -- wie es auf der Tastatur auch
+  // geschieht.
+  teil("taste-altf4")?.addEventListener("click", () => {
+    if (!rfb) return;
+    rfb.sendKey(ALT_LINKS, "AltLeft", true);
+    rfb.sendKey(F4, "F4", true);
+    rfb.sendKey(F4, "F4", false);
+    rfb.sendKey(ALT_LINKS, "AltLeft", false);
+  });
+  // F5 faengt der Browser des Arbeitsplatzes ab -- er wuerde diese Seite neu
+  // laden statt das Bild auf dem Geraet.
+  teil("taste-f5")?.addEventListener("click", () => {
+    if (!rfb) return;
+    rfb.sendKey(F5, "F5", true);
+    rfb.sendKey(F5, "F5", false);
+  });
 
-  if (wurzel.dataset.blockiert === "1") {
-    melden(wurzel.dataset.grund || "Diese Sitzung kann nicht aufgebaut werden.", "fehler");
-    return;
-  }
+  sitzungsknoepfe(false);
+  melden("Wird vorbereitet …");
 
-  const zugang = {};
-  if (vorgabe.username) zugang.username = vorgabe.username;
-  if (vorgabe.password) zugang.password = vorgabe.password;
-  verbinden(zugang);
+  fetch(quelle, { credentials: "same-origin", headers: { "X-Requested-With": "fetch" } })
+    .then((antwort) => antwort.json().then((inhalt) => ({ status: antwort.status, inhalt })))
+    .then(({ status, inhalt }) => {
+      if (beendet) return;
+      if (status === 409 && inhalt.reauth) {
+        melden(
+          "Für den Bildschirm ist eine frische Passwortbestätigung nötig – bitte über " +
+            "die Geräteseite öffnen.",
+          "warnung",
+        );
+        return;
+      }
+      if (status !== 200) {
+        melden(inhalt.fehler || "Diese Sitzung lässt sich nicht öffnen.", "fehler");
+        return;
+      }
+      daten = inhalt;
+      if (daten.hinderungsgrund) {
+        melden(daten.hinderungsgrund, "fehler");
+        return;
+      }
+      const zugang = {};
+      if (daten.vorgaben?.username) zugang.username = daten.vorgaben.username;
+      if (daten.vorgaben?.password) zugang.password = daten.vorgaben.password;
+      verbinden(zugang);
+    })
+    .catch(() => melden("Die Sitzungsdaten sind nicht abrufbar.", "fehler"));
+
+  return function beenden() {
+    beendet = true;
+    window.clearTimeout(aufbauUhr);
+    try {
+      rfb?.disconnect();
+    } catch (fehler) {
+      /* schon zu */
+    }
+    rfb = null;
+  };
+}
+
+// -- Die beiden Orte -------------------------------------------------------- #
+
+// 1. Die Bildschirmseite: ein Behaelter, der seine Quelle selbst mitbringt.
+const seite = document.getElementById("screen");
+if (seite?.dataset.sitzung) {
+  starteSitzung(seite, seite.dataset.sitzung);
+}
+
+// 2. Die Statusuebersicht: ein Fenster, das jede Kachel oeffnen kann. Ein
+//    Dialog fuer alle -- er bekommt beim Oeffnen, welches Geraet gemeint ist.
+const fenster = document.getElementById("vnc-fenster");
+if (fenster) {
+  let beenden = null;
+  const behaelter = fenster.querySelector("[data-rolle='behaelter']");
+  const titel = fenster.querySelector("[data-rolle='titel']");
+
+  document.addEventListener("click", (ereignis) => {
+    const knopf = ereignis.target.closest("[data-vnc-oeffnen]");
+    if (!knopf) return;
+    ereignis.preventDefault();
+    beenden?.();
+    titel.textContent = knopf.dataset.vncName || "Bildschirm";
+    if (typeof fenster.showModal === "function") fenster.showModal();
+    else fenster.setAttribute("open", "");
+    beenden = starteSitzung(behaelter, knopf.dataset.vncOeffnen, {
+      beiEnde: () => fenster.close(),
+    });
+  });
+
+  // Zu heisst zu: eine Sitzung, die im Hintergrund weiterlaeuft, haelt die
+  // Verbindung zum Geraet und bei RealVNC den einen Sitzungsplatz.
+  fenster.addEventListener("close", () => {
+    beenden?.();
+    beenden = null;
+  });
 }

packages/tesm-core/src/tesm_core/static/tesm_core/js/viewer.js

@@ -960,15 +960,22 @@ export function initFilePreview(wurzel = document) {
   const ersetzenFeld = stueck("ersetzen");
   const ersetzenKasten = stueck("ersetzenfeld");
   const pruefzeile = stueck("pruefung");
-  // Die Ordner der geoeffneten Freigabe kommen mit der Seite; die einer
-  // anderen holt das Auswahlfeld bei Bedarf nach.
-  const eigeneOrdner = () => {
-    try {
-      return JSON.parse(rumpf.dataset.viewerOrdnerliste || "[]");
-    } catch {
-      return [];
-    }
-  };
+  // Die Ordner der geoeffneten Freigabe stehen bereits in der Auswahl -- der
+  // Server hat sie dort hineingeschrieben. Gemerkt werden sie trotzdem, denn
+  // wer zwischendurch eine andere Freigabe waehlt, ersetzt die Liste; die
+  // einer anderen Freigabe holt das Auswahlfeld dann bei Bedarf nach.
+  //
+  // Vorher stand dieselbe Liste ein zweites Mal daneben, als JSON in einem
+  // Attribut -- und kam dort nie an: ``tojson`` laesst doppelte
+  // Anfuehrungszeichen stehen, und in einem doppelt gequoteten Attribut endet
+  // der Wert damit nach der oeffnenden Klammer. Die Auswahl zeigte danach nur
+  // noch das Wurzelverzeichnis, und in einen Unterordner liess sich nichts
+  // mehr speichern. Zwei Fassungen derselben Liste waren die eigentliche
+  // Ursache; jetzt gibt es nur noch eine.
+  const gelieferteOrdner = ordnerFeld
+    ? [...ordnerFeld.options].map((eintrag) => eintrag.value).filter(Boolean)
+    : [];
+  const eigeneOrdner = () => gelieferteOrdner;
   const jetzt = stueck("jetzt");
   const abbrechen = stueck("abbrechen");
   const modusFeld = stueck("modus");

packages/tesm-core/src/tesm_core/static/tesm_core/vendor/novnc/HERKUNFT.md

@@ -20,6 +20,27 @@ der einen Bildschirm fernsteuert.
 Datei -- mit Grund und Fundstelle, damit ein Wechsel auf eine neuere Fassung
 nicht stillschweigend darueberlaeuft.
 
+**Was TESM von aussen umbiegt** (also *nicht* in diesen Dateien steht, sondern
+in `js/screen.js`):
+
+* `RFB.prototype._fail` und `_socketClose` -- nur, um den Grund eines
+  Abbruchs zu erfahren. noVNC meldet ihn sonst ausschliesslich in die
+  Entwicklerkonsole, und `console.error` mitzulesen traegt nicht: die
+  Bibliothek bindet es beim Laden.
+* `RFB.prototype._isSupportedSecurityType` -- **erst nachdem** ein Verfahren
+  die Verbindung nachweislich hat abreissen lassen. Dann wird es fuer den
+  zweiten Anlauf ausgelassen, damit noVNC nicht wieder dasselbe zuerst findet.
+  Hoechstens zwei Anlaeufe, denn jeder ist eine Verbindung, und ein RealVNC
+  Server zaehlt abgebrochene mit.
+
+  Hier stand einmal das Gegenteil: eine **Vorauswahl**, die ohne hinterlegte
+  Zugangsdaten ein Verfahren ohne Anmeldung erzwang. Das war geraten und hat
+  eine laufende Sitzung gebrochen. Der Unterschied ist nicht der Code, sondern
+  der Anlass: eine Vermutung vorher gegen einen Befund hinterher.
+
+Faellt eine dieser Methoden in einer neueren Fassung weg, entfaellt nur die
+Auskunft bzw. der zweite Anlauf -- die Sitzung laeuft wie ohne sie.
+
 **Was noVNC an Sicherheitsverfahren spricht** (`core/rfb.js`,
 `_isSupportedSecurityType`): `1` None, `2` VNC-Passwort, `6` RA2ne (RSA-AES
 ohne Streckenverschluesselung), `16` Tight, `19` VeNCrypt, `22` xvp, `30` ARD,

packages/tesm-core/src/tesm_core/system/webserver.py

@@ -58,8 +58,14 @@ class WebConfig:
     #: ``listen ... ssl http2;`` und weisen die neue Direktive mit
     #: "unknown directive" ab -- der ganze Webserver startet dann nicht mehr.
     #: Auf POETEST (nginx 1.24) genau so passiert. Vorgabe ist deshalb die alte
-    #: Schreibweise: sie funktioniert ueberall und erzeugt auf neuen Versionen
-    #: nur eine Warnung.
+    #: Schreibweise: sie funktioniert ueberall.
+    #:
+    #: Wer die Konfiguration erzeugt, fragt vorher ``nginx_kann_http2()`` --
+    #: dann steht auf einem neuen Webserver auch die neue Schreibweise. Das ist
+    #: nicht nur Kosmetik gegen eine Warnung: nginx hat die alte Form als
+    #: veraltet erklaert, und was veraltet ist, faellt irgendwann weg. Ein
+    #: Release-Upgrade von Ubuntu ist genau der Moment, in dem so etwas
+    #: unbemerkt naeherrueckt (24.04 hat nginx 1.24, 26.04 hat 1.28).
     http2_directive: bool = False
 
     @property
@@ -89,6 +95,47 @@ class WebConfig:
         return "" if self.https_port == 443 else f":{self.https_port}"
 
 
+#: Ab dieser Fassung kennt nginx ``http2 on;``.
+HTTP2_DIREKTIVE_AB = (1, 25, 1)
+
+
+def fassung_aus_ausgabe(text: str) -> tuple[int, ...]:
+    """``nginx version: nginx/1.28.3 (Ubuntu)`` -> ``(1, 28, 3)``.
+
+    Getrennt vom Aufruf, damit sich die Entscheidung pruefen laesst, ohne
+    einen Webserver zu installieren. Was nicht ins Muster passt, ergibt ein
+    leeres Tupel -- und damit die Schreibweise, die ueberall funktioniert.
+    """
+    treffer = re.search(r"nginx/(\d+)\.(\d+)\.(\d+)", text or "")
+    return tuple(int(teil) for teil in treffer.groups()) if treffer else ()
+
+
+def nginx_version() -> tuple[int, ...]:
+    """Die Fassung des installierten nginx, sonst ein leeres Tupel.
+
+    ``nginx -v`` schreibt nach stderr und braucht keine Rechte. Faellt die
+    Antwort aus -- kein nginx, kein Ausfuehrungsrecht, fremdes Format --, gibt
+    es hier nichts zu raten.
+    """
+    import shutil
+    import subprocess
+
+    pfad = shutil.which("nginx") or "/usr/sbin/nginx"
+    try:
+        fertig = subprocess.run(
+            [pfad, "-v"], capture_output=True, text=True, timeout=5, check=False
+        )
+    except (OSError, subprocess.SubprocessError):
+        return ()
+    return fassung_aus_ausgabe(fertig.stderr + fertig.stdout)
+
+
+def nginx_kann_http2() -> bool:
+    """Versteht der installierte nginx ``http2 on;``?"""
+    fassung = nginx_version()
+    return bool(fassung) and fassung >= HTTP2_DIREKTIVE_AB
+
+
 def validate_domain(value: str) -> str:
     text = (value or "").strip().lower().rstrip(".")
     if not text:

packages/tesm-core/src/tesm_core/templates/tesm_core/_log_lines.html

@@ -1,5 +1,8 @@
 {% if lines %}
-<pre class="log-view" data-tail>{% for line in lines %}{{ line }}
+{# Jede Zeile in einer Huelle, damit die Stufe eine Farbe tragen kann. Der
+   Zeilenumbruch steht ausserhalb: im <pre> ist er der Umbruch selbst, und
+   eine Huelle mit display:block wuerde daraus zwei machen. #}
+<pre class="log-view" data-tail>{% for line in lines %}{% set z = line | protokollzeile %}<span class="log-view__zeile{% if z.stufe %} log-view__zeile--{{ z.stufe }}{% endif %}">{{ z.text }}</span>
 {% endfor %}</pre>
 {% else %}
 <div class="empty"><div class="empty__title">Keine Zeilen</div>

packages/tesm-core/src/tesm_core/templates/tesm_core/logs_history.html

@@ -25,7 +25,7 @@
               <tr>
                 <td><a href="{{ url_for('logs.history_file', name=entry.name) }}">{{ entry.name }}</a></td>
                 <td class="numeric fs-sm">{{ entry.size | bytes }}</td>
-                <td class="fs-sm">{{ entry.modified | int | string }}</td>
+                <td class="fs-sm">{{ entry.modified | dt }}</td>
               </tr>
             {% endfor %}
           </tbody>

packages/tesm-core/src/tesm_core/templates/tesm_core/logs_live.html

@@ -1,5 +1,5 @@
 {% extends "tesm_core/base.html" %}
-{% block page_title %}Laufendes Protokoll{% endblock %}
+{% block page_title %}Live-Protokoll{% endblock %}
 {% block page_sub %}{{ path }} · letzte {{ line_count }} Zeilen{% endblock %}
 
 {% block topbar_extra %}

packages/tesm-core/src/tesm_core/ui.py

@@ -113,6 +113,14 @@ def format_datetime(value: Any, *, with_time: bool = True) -> str:
         return "-"
     if isinstance(value, datetime):
         moment = value
+    elif isinstance(value, (int, float)) and not isinstance(value, bool):
+        # Sekunden seit 1970, wie sie aus ``stat()`` kommen. Ohne diesen Zweig
+        # stand im Protokollverlauf die nackte Zahl (1788472810) in der Spalte
+        # "Geändert" -- fuer die Datei sichtbar, fuer den Menschen nutzlos.
+        try:
+            moment = datetime.fromtimestamp(float(value), timezone.utc)
+        except (OSError, OverflowError, ValueError):
+            return str(value)
     else:
         text = str(value).strip()
         if text.endswith("Z"):
@@ -351,6 +359,38 @@ def audit_detail(text: Any) -> Markup:
     teile.append(str(escape(roh[ende:])))
     return Markup("".join(teile))
 
+#: Stufen im laufenden Protokoll und ihre Farbrolle in der Oberflaeche.
+#:
+#: Die Zuordnung ist Absicht und keine Verwechslung: die Farbrolle "warning"
+#: ist bernsteinfarben und traegt hier den **Hinweis**, "danger" ist rot und
+#: traegt die **Warnung**. Ein Geraet, das nicht antwortet, ist rot; ein
+#: Geraet, das neu gestartet wird, ist orange; alles Gelungene ist gruen.
+PROTOKOLLSTUFEN = {
+    "INFO": "info",
+    "HINWEIS": "hinweis",
+    "WARNUNG": "warnung",
+    "FEHLER": "fehler",
+}
+
+#: ``2026-09-16 09:54:03  INFO     ping       HAP02 ist wieder erreichbar``
+_PROTOKOLLZEILE = re.compile(
+    r"^\d{4}-\d\d-\d\d[ T]\d\d:\d\d:\d\d\s+([A-ZÄÖÜ]+)\s"
+)
+
+
+def protokollzeile(zeile: str) -> dict[str, str]:
+    """Zerlegt eine Protokollzeile so weit, dass die Seite sie faerben kann.
+
+    Bewusst nur so weit: der Text bleibt, wie er ist -- eine Protokollansicht,
+    die ihre Zeilen umbaut, ist keine mehr. Gebraucht wird allein die Stufe.
+    Was nicht ins Muster passt (fremde Protokolle wie das von Kea), bekommt
+    keine Farbe statt einer geratenen.
+    """
+    treffer = _PROTOKOLLZEILE.match(str(zeile or ""))
+    stufe = PROTOKOLLSTUFEN.get(treffer.group(1), "") if treffer else ""
+    return {"text": str(zeile or ""), "stufe": stufe}
+
+
 def init_app(app: Flask) -> None:
     app.jinja_env.globals.update(
         icon=icon,
@@ -371,6 +411,7 @@ def init_app(app: Flask) -> None:
         enumerate=enumerate,
     )
     app.jinja_env.filters.update(
+        protokollzeile=protokollzeile,
         bytes=format_bytes,
         dt=format_datetime,
         date=format_date,

packages/tesm-core/src/tesm_core/views/hostsettings.py

@@ -204,6 +204,8 @@ def _web_config() -> webserver.WebConfig:
         ],
     )
     return webserver.WebConfig(
+        # Die neue Schreibweise, sobald der Webserver sie kennt.
+        http2_directive=webserver.nginx_kann_http2(),
         app_key=extension.config.site_key,
         upstream=str(extension.registry.get("upstream", "127.0.0.1:5000")),
         static_root=str(extension.registry.get("static_root", extension.config.base_dir / "static")),

packages/tesm-core/src/tesm_core/views/logs.py

@@ -68,12 +68,17 @@ def live_fragment():
 def history():
     extension = core()
     rotated = []
-    for path in sorted(extension.config.log_dir.glob("*.log.*"), reverse=True):
+    for path in extension.config.log_dir.glob("*.log.*"):
         try:
             stat = path.stat()
         except OSError:
             continue
         rotated.append({"name": path.name, "size": stat.st_size, "modified": stat.st_mtime})
+    # Nach Alter, nicht nach Namen: ``sorted(..., reverse=True)`` ueber die
+    # Dateinamen stellte "live.log.9" vor "live.log.27", weil "9" hinter "2"
+    # kommt. Gefragt ist aber die juengste Kopie zuerst, und das steht im
+    # Zeitstempel.
+    rotated.sort(key=lambda eintrag: eintrag["modified"], reverse=True)
     return render_template(
         "tesm_core/logs_history.html",
         rotated=rotated,