Drucker wird in der App gewaehlt, nicht auf dem Pi

Das Einrichtungsskript fragte bisher am Pi, welcher Drucker bedient werden
soll. Damit stand die Einstellung an einem Ort, an den man nur mit einem
Terminal kommt - und ein zweiter Drucker am Pi bedeutete: Skript nochmal.

Jetzt fragt die App den Pi, was angeschlossen ist, und der Bediener waehlt in
den Einstellungen. Die Bruecke bekam dafuer /devices; sie liest die
Klartextnamen aus dem sysfs, damit dort "EPSON TM-T88IV" steht und nicht
"lp0" - bei zwei Druckern der Unterschied zwischen Wissen und Raten.

Der gewaehlte Pfad geht bei jedem Auftrag im Kopf X-Print-Device mit. Die
Bruecke haelt dazu bewusst keinen Zustand und das Skript schreibt kein
PRINT_DEVICE mehr: es soll genau eine Stelle geben, die weiss, welcher Drucker
gemeint ist, naemlich die, an der es bedient wird. Leer bleibt "automatisch" -
das erste gefundene Geraet, zugleich der Rueckfall, wenn aus lp0 nach dem
Umstecken ein lp1 geworden ist.

Der Pfad kommt damit von aussen und wird an beiden Enden geprueft, in
PUT /api/settings und noch einmal in der Bruecke. Eine Schranke, die nur an
einem Ende steht, ist keine: ohne die Pruefung auf dem Pi liesse sich der
Dienst dazu bringen, in eine beliebige Datei zu schreiben.

Nebenbei: ein nicht bereiter Drucker meldete sich in der Oberflaeche als
"HTTP 503". Das verriet niemandem, dass nur ein Stecker lose ist. Die 503 der
Bruecke ist kein Protokollfehler, und ihr Rumpf sagt, was fehlt - der wird
jetzt ausgewertet.

Geprueft am echten Pi (Debian 13, TM-T88IV): Einrichtung ohne Rueckfrage,
Geraeteliste mit Namen, ausdrueckliche Wahl, Druck darauf, Rueckkehr auf
automatisch, Druck darauf. Dazu die Abweise: /etc/passwd und ein Pfad mit
angehaengtem Befehl werden zurueckgewiesen, ein erlaubtes aber fehlendes
/dev/usb/lp7 ergibt eine Meldung im Klartext.

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

deploy/bondrucker/README.md

@@ -23,10 +23,16 @@ curl -fsSL "<Link aus der Timer-App>" -o bondrucker.sh
 sudo bash bondrucker.sh
 ```
 
-Das Skript fragt, welcher Drucker verwendet werden soll, richtet alles ein und
-meldet den Pi anschließend selbst bei der Timer-App an. In der Oberfläche
-springt die Anzeige von „wartet auf den Pi" auf den fertigen Drucker um. In der
-`.env` ist **nichts** einzutragen.
+Das Skript richtet alles ein und meldet den Pi anschließend selbst bei der
+Timer-App an — ohne Rückfrage. In der Oberfläche springt die Anzeige von
+„wartet auf den Pi" auf den fertigen Drucker um. In der `.env` ist **nichts**
+einzutragen.
+
+**Welcher Drucker bedient wird, wird danach in der Timer-App ausgewählt**
+(Einstellungen → *Drucker am Pi* → **🔄 Suchen**). Die App fragt den Pi über
+`/devices`, was angeschlossen ist, und schickt den gewählten Pfad bei jedem
+Auftrag im Kopf `X-Print-Device` mit. Dieser Dienst hält dazu keinen Zustand:
+es gibt genau eine Stelle, die weiß, welcher Drucker gemeint ist.
 
 Der Pi braucht dafür nur Python 3, systemd, `curl` und den Drucker am
 USB-Anschluss. Ein frisch aufgesetztes Raspberry Pi OS erfüllt das ab Werk.
@@ -49,7 +55,7 @@ deshalb nicht in einen Chatverlauf.
 |---|---|
 | Dienstbenutzer `bondrucker` (Gruppe `lp`) | — |
 | Programm | `/opt/bondrucker/print-server.py` |
-| Token und Gerät | `/etc/bondrucker/env` (`0640`, root:bondrucker) |
+| Token und Port | `/etc/bondrucker/env` (`0640`, root:bondrucker) |
 | udev-Regel | `/etc/udev/rules.d/99-bondrucker.rules` |
 | Dienst | `bondrucker.service`, aktiviert und gestartet |
 
@@ -57,10 +63,10 @@ Das Skript ist wiederholbar: ein erneuter Aufruf überschreibt Programm und
 Token und **startet den Dienst neu**. Ohne den Neustart liefe er mit dem alten
 Token weiter und würde jeden Druckauftrag mit HTTP 403 ablehnen.
 
-Schalter für den Fall, dass nicht gefragt werden soll:
+Abweichender Port der Brücke:
 
 ```bash
-sudo bash bondrucker.sh --device /dev/usb/lp1 --port 9100
+sudo bash bondrucker.sh --port 9100
 ```
 
 ## Installation ohne die Timer-App
@@ -71,8 +77,8 @@ Ausliefern. Direkt ausführbar ist sie deshalb nicht.
 
 Ohne die App werden die Dateien von Hand abgelegt — `print-server.py` nach
 `/opt/bondrucker/`, `bondrucker.service` nach `/etc/systemd/system/`, dazu
-`/etc/bondrucker/env` mit `PRINT_TOKEN=` und `PRINT_DEVICE=`. Adresse, Port und
-Token kommen anschließend von Hand in die Einstellungen der Timer-App.
+`/etc/bondrucker/env` mit `PRINT_TOKEN=`. Adresse, Port und Token kommen
+anschließend von Hand in die Einstellungen der Timer-App.
 
 ## Timer-Server konfigurieren
 
@@ -104,8 +110,18 @@ Antwortet `/status` mit `"ok": true`, ist das Gerät da und beschreibbar.
 | Aufruf | Wirkung |
 |---|---|
 | `GET /status` | JSON mit Gerät, Beschreibbarkeit, letztem Fehler. HTTP 503, wenn kein Drucker da ist |
+| `GET /devices` | alle `/dev/usb/lp*` mit Klartextnamen. Token nötig |
 | `POST /print` | Rumpf = rohe ESC/POS-Bytes, Kopfzeile `X-Print-Token`. Antwortet `{"ok":true,"bytes":N}` |
 
+`/status` und `/print` beachten den Kopf **`X-Print-Device`**. Fehlt er, nimmt
+die Brücke das eingestellte Gerät und sonst das erste gefundene. Der Pfad wird
+gegen `^/dev/(usb/)?lp[0-9]{1,3}$` geprüft — er kommt von außen, und ohne diese
+Schranke ließe sich der Dienst dazu bringen, in eine beliebige Datei zu
+schreiben. Ein unerlaubter Pfad ergibt HTTP 400.
+
+`/devices` verlangt ein Token: welche Geräte am Pi hängen, ist zwar kein
+Geheimnis, aber auch keine Auskunft für jeden im Netz.
+
 `/status` verlangt **kein** Token — der Zustand des Druckers ist nicht geheim
 und soll für Health-Checks abfragbar bleiben. Wird trotzdem eines mitgeschickt,
 meldet die Antwort in `tokenAccepted`, ob es passt. Die App nutzt das nach der

deploy/bondrucker/einrichten.sh

@@ -13,11 +13,14 @@
 #
 # Der Link steht in der Timer-App unter Einstellungen -> Drucker einrichten.
 #
+# Dieses Skript installiert nur die Software. WELCHER Drucker bedient wird,
+# wird anschliessend in der Timer-App ausgewaehlt - sie fragt den Pi, was
+# angeschlossen ist. Hier ist dazu nichts einzustellen.
+#
 # Ohne Netz zur Timer-App laeuft das Skript trotzdem durch; es zeigt am Ende
 # Adresse und Token an, die dann von Hand in die Einstellungen gehoeren.
 #
 # Schalter:
-#     --device /dev/usb/lp0   Drucker vorgeben, statt danach zu fragen
 #     --port 9100             Lausch-Port der Bruecke
 # ---------------------------------------------------------------------------
 set -euo pipefail
@@ -27,16 +30,14 @@ APP_URL="@@APP_URL@@"
 SETUP_CODE="@@SETUP_CODE@@"
 
 ZIEL=/opt/bondrucker
-GERAET=""
 PORT=9100
 
 # --- Schalter --------------------------------------------------------------
 
 while [ $# -gt 0 ]; do
     case "$1" in
-        --device) GERAET="${2:-}"; shift 2 ;;
         --port)   PORT="${2:-9100}"; shift 2 ;;
-        -h|--help) sed -n '2,22p' "$0"; exit 0 ;;
+        -h|--help) sed -n '2,26p' "$0"; exit 0 ;;
         *) echo "Unbekannter Schalter: $1" >&2; exit 1 ;;
     esac
 done
@@ -55,24 +56,8 @@ punkt() { printf '    %s\n' "$1"; }
 warnung() { printf '    \033[33m%s\033[0m\n' "$1"; }
 fehler() { printf '\n\033[31m%s\033[0m\n' "$1" >&2; exit 1; }
 
-# Fragt den Benutzer und gibt die Antwort auf stdout zurueck.
-#
-# Die Umleitung auf /dev/tty ist der Grund, warum auch
-# "curl ... | sudo bash" noch bedienbar bleibt: dort ist die Standardeingabe
-# die Pipe und nicht die Tastatur. Gibt es gar kein Terminal, wird die Vorgabe
-# genommen, statt in einer Endlosschleife zu haengen.
-frage() {
-    local text="$1" vorgabe="${2:-}" antwort=""
-    if [ -t 0 ]; then
-        read -r -p "$text" antwort || true
-    elif [ -e /dev/tty ]; then
-        read -r -p "$text" antwort < /dev/tty || true
-    fi
-    printf '%s' "${antwort:-$vorgabe}"
-}
-
-# Klartextname eines USB-Druckers aus dem sysfs, damit in der Auswahl nicht
-# nur "lp0" steht, sondern "EPSON TM-T88IV".
+# Klartextname eines USB-Druckers aus dem sysfs. Nur zur Anzeige - ausgewaehlt
+# wird spaeter in der Timer-App, die dieselbe Liste ueber /devices abfragt.
 usb_name() {
     local pfad
     pfad=$(readlink -f "/sys/class/usbmisc/$(basename "$1")/device" 2>/dev/null) || return 1
@@ -99,41 +84,27 @@ punkt "$(. /etc/os-release 2>/dev/null && echo "$PRETTY_NAME" || uname -s) ($(un
 punkt "$(python3 --version)"
 
 # ---------------------------------------------------------------------------
-# 2. Drucker auswaehlen
+# 2. Angeschlossene Drucker anzeigen
 # ---------------------------------------------------------------------------
 
-titel "2. Drucker"
+titel "2. Angeschlossene Drucker"
 
-if [ -z "$GERAET" ]; then
-    GEFUNDEN=()
-    for d in /dev/usb/lp* /dev/lp*; do
-        [ -e "$d" ] && GEFUNDEN+=("$d")
-    done
+gefunden=0
+for d in /dev/usb/lp* /dev/lp*; do
+    [ -e "$d" ] || continue
+    gefunden=$((gefunden + 1))
+    printf '    %-16s %s\n' "$d" "$(usb_name "$d" || echo '')"
+done
 
-    if [ "${#GEFUNDEN[@]}" -eq 0 ]; then
-        warnung "Gerade haengt kein Drucker unter /dev/usb/lp* am Pi."
-        warnung "Das ist kein Hindernis: der Dienst findet ihn, sobald er angesteckt wird."
-        GERAET=$(frage "    Geraetepfad [/dev/usb/lp0]: " "/dev/usb/lp0")
-    else
-        echo
-        for i in "${!GEFUNDEN[@]}"; do
-            printf '    %d) %-16s %s\n' "$((i + 1))" "${GEFUNDEN[$i]}" "$(usb_name "${GEFUNDEN[$i]}" || echo '')"
-        done
-        printf '    a) anderer Pfad\n\n'
-
-        WAHL=$(frage "    Welcher Drucker? [1]: " "1")
-        if [ "$WAHL" = "a" ] || [ "$WAHL" = "A" ]; then
-            GERAET=$(frage "    Geraetepfad: " "/dev/usb/lp0")
-        elif [ "$WAHL" -ge 1 ] 2>/dev/null && [ "$WAHL" -le "${#GEFUNDEN[@]}" ]; then
-            GERAET="${GEFUNDEN[$((WAHL - 1))]}"
-        else
-            fehler "Ungueltige Auswahl: $WAHL"
-        fi
-    fi
+if [ "$gefunden" -eq 0 ]; then
+    warnung "Gerade haengt kein Drucker unter /dev/usb/lp* am Pi."
+    warnung "Das ist kein Hindernis: der Dienst findet ihn, sobald er angesteckt"
+    warnung "wird. Danach in der Timer-App die Liste neu abrufen."
+else
+    echo
+    punkt "Welcher davon genommen wird, wird in der Timer-App ausgewaehlt."
 fi
 
-punkt "gewaehlt: $GERAET"
-
 # ---------------------------------------------------------------------------
 # 3. Dienstbenutzer
 # ---------------------------------------------------------------------------
@@ -177,9 +148,11 @@ titel "5. Konfiguration"
 TOKEN="$(head -c 24 /dev/urandom | base64 | tr -d '/+=' | head -c 32)"
 
 install -d -m 750 /etc/bondrucker
+# Bewusst OHNE PRINT_DEVICE: welcher Drucker bedient wird, schickt die
+# Timer-App bei jedem Auftrag mit. Stuende die Wahl auch hier, gaebe es zwei
+# Stellen, die es zu wissen glauben - und eine davon waere irgendwann falsch.
 {
     printf 'PRINT_TOKEN=%s\n' "$TOKEN"
-    printf 'PRINT_DEVICE=%s\n' "$GERAET"
     printf 'PRINT_PORT=%s\n' "$PORT"
 } > /etc/bondrucker/env
 chmod 640 /etc/bondrucker/env
@@ -226,11 +199,6 @@ case "$ANTWORT" in
     *)  warnung "Die Bruecke antwortet, lehnt das Token aber ab: $ANTWORT" ;;
 esac
 
-case "$ANTWORT" in
-    *'"deviceExists": false'*|*'"deviceExists":false'*)
-        warnung "Das Geraet $GERAET ist gerade nicht da - Kabel pruefen." ;;
-esac
-
 # ---------------------------------------------------------------------------
 # 7. Bei der Timer-App anmelden
 # ---------------------------------------------------------------------------
@@ -249,13 +217,13 @@ case "$APP_URL" in
         if ! command -v curl >/dev/null; then
             warnung "curl fehlt - die Anmeldung muss von Hand erfolgen."
         else
-            RUMPF="$(printf '{"code":"%s","port":%s,"token":"%s","device":"%s","hostHint":"%s"}' \
-                     "$SETUP_CODE" "$PORT" "$TOKEN" "$GERAET" "$IP")"
+            RUMPF="$(printf '{"code":"%s","port":%s,"token":"%s","hostHint":"%s"}' \
+                     "$SETUP_CODE" "$PORT" "$TOKEN" "$IP")"
             if ERGEBNIS="$(curl -fsS -m 15 -X POST \
                     -H 'Content-Type: application/json' \
                     -d "$RUMPF" "$APP_URL/api/setup/register" 2>&1)"; then
                 punkt "Bei $APP_URL angemeldet."
-                punkt "Die Timer-App druckt ab jetzt auf diesen Pi."
+                punkt "Jetzt dort unter Einstellungen den Drucker auswaehlen."
                 angemeldet=1
             else
                 warnung "Anmeldung fehlgeschlagen: $ERGEBNIS"
@@ -270,7 +238,6 @@ esac
 # ---------------------------------------------------------------------------
 
 titel "Fertig"
-punkt "Drucker:  $GERAET"
 punkt "Adresse:  ${IP:-<IP des Pi>}"
 punkt "Port:     $PORT"
 

deploy/bondrucker/print-server.py

@@ -10,12 +10,21 @@ Geraet. Die Timer-App baut den Bon, der Pi druckt ihn nur noch.
 Bewusst nur Python-Standardbibliothek: auf dem Pi muss dafuer nichts
 nachinstalliert werden (kein pip, kein CUPS, kein node).
 
+Welcher Drucker genommen wird, entscheidet die Timer-App: sie fragt ueber
+/devices ab, was angeschlossen ist, und schickt den gewaehlten Pfad bei jedem
+Auftrag im Kopf X-Print-Device mit. Dieser Dienst haelt dazu keinen Zustand -
+die Einstellung lebt an einer Stelle, naemlich dort, wo sie bedient wird.
+
 Endpunkte
     GET  /status   Zustand des Druckers als JSON (fuer Health-Checks)
+    GET  /devices  angeschlossene Drucker mit Klartextnamen (Token noetig)
     POST /print    Rumpf = rohe ESC/POS-Bytes, wird 1:1 an den Drucker gereicht
 
+/status und /print beachten den Kopf X-Print-Device. Fehlt er, wird das
+eingestellte Geraet genommen und sonst das erste gefundene.
+
 Konfiguration ueber Umgebungsvariablen (siehe bondrucker.service):
-    PRINT_DEVICE   Geraetedatei, Standard /dev/usb/lp0
+    PRINT_DEVICE   Rueckfall, wenn die App nichts vorgibt; Standard /dev/usb/lp0
     PRINT_HOST     Lausch-Adresse, Standard 0.0.0.0
     PRINT_PORT     Lausch-Port,    Standard 9100
     PRINT_TOKEN    gemeinsames Geheimnis; leer = ohne Anmeldung (nur im LAN!)
@@ -26,15 +35,21 @@ import glob
 import hmac
 import json
 import os
+import re
 import socketserver
 import sys
 import threading
 import time
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 
-VERSION = "1.1"
+VERSION = "1.2"
 
 DEVICE = os.environ.get("PRINT_DEVICE", "/dev/usb/lp0")
+
+# Welcher Drucker genommen wird, entscheidet die Timer-App und schickt es bei
+# jedem Auftrag mit. Der Pfad kommt damit von aussen - ohne diese Schranke
+# liesse sich der Dienst dazu bringen, in eine beliebige Datei zu schreiben.
+DEVICE_MUSTER = re.compile(r"^/dev/(usb/)?lp[0-9]{1,3}$")
 HOST = os.environ.get("PRINT_HOST", "0.0.0.0")
 PORT = int(os.environ.get("PRINT_PORT", "9100"))
 TOKEN = os.environ.get("PRINT_TOKEN", "").strip()
@@ -52,21 +67,87 @@ def log(msg):
     print(msg, flush=True)
 
 
-def find_device():
-    """Konfiguriertes Geraet, sonst das erste vorhandene /dev/usb/lp*.
+def _lies(pfad):
+    try:
+        with open(pfad) as f:
+            return f.read().strip()
+    except OSError:
+        return ""
 
-    Nach dem Aus- und Wiedereinstecken des USB-Kabels kann aus lp0 ein lp1
-    werden. Ohne diesen Fallback druckt danach nichts mehr, bis jemand den
-    Dienst anfasst.
+
+def usb_name(geraet):
+    """Klartextname eines USB-Druckers, etwa "EPSON TM-T88IV".
+
+    Dahinter steckt ein Aufstieg im sysfs: die Geraetedatei zeigt auf die
+    USB-Schnittstelle, die Bezeichnungen haengen aber am Geraet darueber.
+    Ohne diesen Namen steht in der Auswahl nur "lp0" und "lp1" - bei zwei
+    Druckern ist das Raten.
     """
+    basis = os.path.basename(geraet)
+    start = "/sys/class/usbmisc/%s/device" % basis
+    if not os.path.exists(start):
+        start = "/sys/class/printer/%s/device" % basis
+    if not os.path.exists(start):
+        return ""
+
+    pfad = os.path.realpath(start)
+    while pfad and pfad != "/":
+        if os.path.isfile(os.path.join(pfad, "product")):
+            name = _lies(os.path.join(pfad, "manufacturer")) + " " + \
+                   _lies(os.path.join(pfad, "product"))
+            return " ".join(name.split())
+        pfad = os.path.dirname(pfad)
+    return ""
+
+
+def list_devices():
+    """Alle angeschlossenen Druckergeraete - die Auswahl fuer die Timer-App."""
+    pfade = sorted(set(glob.glob("/dev/usb/lp*")) | set(glob.glob("/dev/lp*")))
+    return [
+        {
+            "path": p,
+            "name": usb_name(p),
+            "writable": os.access(p, os.W_OK),
+        }
+        for p in pfade
+        if DEVICE_MUSTER.match(p)
+    ]
+
+
+def find_device(requested=None):
+    """Welches Geraet bedient werden soll.
+
+    Mit Angabe: genau dieses, sofern der Pfad ueberhaupt ein Druckergeraet sein
+    kann. Ohne Angabe das eingestellte, und wenn es das nicht gibt, das erste
+    vorhandene - nach dem Aus- und Wiedereinstecken des USB-Kabels kann aus lp0
+    naemlich ein lp1 werden, und ohne diesen Rueckfall druckt danach nichts
+    mehr, bis jemand den Dienst anfasst.
+    """
+    if requested:
+        if not DEVICE_MUSTER.match(requested):
+            raise ValueError("Unerlaubter Geraetepfad: %s" % requested)
+        return requested
     if os.path.exists(DEVICE):
         return DEVICE
     found = sorted(glob.glob("/dev/usb/lp*"))
     return found[0] if found else None
 
 
-def device_status(token_accepted=None):
-    dev = find_device()
+def device_status(token_accepted=None, requested=None):
+    try:
+        dev = find_device(requested)
+    except ValueError as err:
+        return {
+            "ok": False,
+            "version": VERSION,
+            "tokenRequired": bool(TOKEN),
+            "tokenAccepted": token_accepted,
+            "device": requested,
+            "deviceExists": False,
+            "writable": False,
+            "lastError": str(err),
+            "lastPrintAt": _last_ok,
+        }
     status = {
         "ok": False,
         "version": VERSION,
@@ -79,23 +160,24 @@ def device_status(token_accepted=None):
         "tokenAccepted": token_accepted,
         "device": dev or DEVICE,
         "deviceConfigured": DEVICE,
-        "deviceExists": dev is not None,
+        "deviceRequested": requested or None,
+        "deviceExists": dev is not None and os.path.exists(dev),
         "writable": False,
         "lastError": _last_error,
         "lastPrintAt": _last_ok,
     }
-    if dev:
+    if dev and os.path.exists(dev):
         status["writable"] = os.access(dev, os.W_OK)
         status["ok"] = status["writable"]
     return status
 
 
-def write_to_printer(data):
+def write_to_printer(data, requested=None):
     """Schreibt einen Auftrag auf den Drucker. Wirft bei Fehlern OSError."""
     global _last_error, _last_ok
 
     with _print_lock:
-        dev = find_device()
+        dev = find_device(requested)
         if dev is None:
             raise OSError("Kein Druckergeraet gefunden (/dev/usb/lp*). Kabel? Strom?")
 
@@ -133,16 +215,29 @@ class Handler(BaseHTTPRequestHandler):
         self.wfile.write(body)
 
     def do_GET(self):
-        if self.path.rstrip("/") in ("/status", "/health", ""):
-            st = device_status(token_ok(self.headers.get("X-Print-Token")))
+        pfad = self.path.split("?")[0].rstrip("/")
+
+        if pfad in ("/status", "/health", ""):
+            st = device_status(
+                token_ok(self.headers.get("X-Print-Token")),
+                self.headers.get("X-Print-Device"),
+            )
             self._send(200 if st["ok"] else 503, st)
+
+        elif pfad == "/devices":
+            # Anders als /status mit Token: welche Geraete am Pi haengen, ist
+            # zwar kein Geheimnis, aber auch keine Auskunft fuer jeden im Netz.
+            if not token_ok(self.headers.get("X-Print-Token")):
+                return self._send(403, {"ok": False, "error": "Token ungueltig"})
+            self._send(200, {"ok": True, "devices": list_devices(), "fallback": find_device()})
+
         else:
             self._send(404, {"ok": False, "error": "Unbekannter Pfad"})
 
     def do_POST(self):
         global _last_error
 
-        if self.path.rstrip("/") != "/print":
+        if self.path.split("?")[0].rstrip("/") != "/print":
             return self._send(404, {"ok": False, "error": "Unbekannter Pfad"})
 
         if not token_ok(self.headers.get("X-Print-Token")):
@@ -162,7 +257,10 @@ class Handler(BaseHTTPRequestHandler):
         data = self.rfile.read(length)
 
         try:
-            written = write_to_printer(data)
+            written = write_to_printer(data, self.headers.get("X-Print-Device"))
+        except ValueError as err:
+            log("[abgelehnt] %s" % err)
+            return self._send(400, {"ok": False, "error": str(err)})
         except OSError as err:
             _last_error = str(err)
             log(f"[fehler] {self.client_address[0]}: {err}")
@@ -186,6 +284,8 @@ def main():
     st = device_status()
     log(f"Bondrucker-Bruecke {VERSION}")
     log(f"  Geraet:  {st['device']}  (vorhanden: {st['deviceExists']}, beschreibbar: {st['writable']})")
+    for g in list_devices():
+        log(f"  gefunden: {g['path']}  {g['name']}")
     log(f"  Lauscht: {HOST}:{PORT}")
     log(f"  Token:   {'gesetzt' if TOKEN else 'NICHT gesetzt - jeder im Netz darf drucken'}")