fix: VERSION ins Dockerfile, STABLE_RELEASE_API fix, Version im Header (#14)

- README.md (EN), README.de.md (DE) – README.en.md entfernt
- CHANGELOG.md (EN), CHANGELOG.de.md (DE)
- config_loader.py neu (config.ini statt .env)
- kobrax_moonraker_bridge.py, kobrax_client.py, env_loader.py aktualisiert
- Dockerfile, docker-compose.yml, VERSION auf 0.9.2

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

CHANGELOG.de.md

@@ -0,0 +1,212 @@
+# Changelog
+
+## [0.9.2] – 2026-04-29
+
+### ⚠️ Breaking Change: Konfiguration wechselt von `.env` zu `config/config.ini`
+
+**Migration erfolgt automatisch** beim ersten Start — keine manuelle Aktion nötig.
+
+- Einstellungen werden ab sofort aus `config/config.ini` gelesen statt aus `.env`
+- Beim ersten Start ohne `config.ini` wird die Datei automatisch aus `.env` erstellt
+- **Docker:** Volume `./config:/app/config` in `docker-compose.yml` ist der persistente Speicherort — Einstellungen überleben `docker-compose restart` und Updates
+- **Standalone:** `config/config.ini` liegt neben der Binary und wird bei Updates nicht überschrieben
+- `.env` bleibt als read-only Fallback gemountet — kann liegen bleiben
+- Zum manuellen Anlegen einer `config.ini`: Vorlage unter `config/config.ini.example`
+
+### Neu
+- **Persistente Einstellungen:** `config/config.ini` ersetzt `.env` — Einstellungen gehen nach `docker-compose restart` nicht mehr verloren (Issue #9)
+- **Verbindungsfehler-Banner:** Roter Banner oben in der Web-UI wenn MQTT-Verbindung fehlschlägt (z.B. falsches Passwort, Drucker nicht erreichbar) (Issue #11)
+- **Slicer-Schätzzeit:** Geschätzte Gesamtdruckzeit aus dem GCode-Header wird im Fortschritts-Panel angezeigt
+
+### Fixes
+- README: OrcaSlicer-Verbindung explizit mit `http://` und Port `:7125` dokumentiert (Issue #12)
+- README: Direkter Download-Link für `extract_credentials` auf Gitea-Releases (Issue #13)
+
+---
+
+## [0.9.1-dev] – laufend (dev-Branch)
+
+### Neu
+- **Dev-Branch-Infrastruktur:** Versionsschema `0.9.1-dev+<hash>` — jeder Build eindeutig identifizierbar
+- **Separater Update-Kanal:** Dev-Versionen prüfen auf Gitea Pre-Releases mit `-dev+` im Tag
+- **AMS-Slot-Auswahl:** Einstellung „Standard-Slot (Einfarbdruck)" im Settings-Modal — fixiert einen bestimmten AMS-Kanal oder Auto (alle belegten Slots)
+- **Auto-Leveling:** Checkbox im Settings-Modal — steuert `task_settings.auto_leveling` beim Druckstart
+- **MQTT-Logging:** Strukturiertes TX/RX-Log mit Duplikat-Filter (`kobrax.mqtt` Logger)
+- **Server-Log im Browser:** Live-Stream via SSE (`/api/log/stream`) — alle Server-Logs erscheinen im Log-Tab der UI
+- **Log-Tab Verbesserungen:**
+  - Auto-Scroll ein/aus — deaktiviert sich beim manuellen Hochscrollen, Button zum Reaktivieren
+  - Textfilter — Live-Filterung der Log-Einträge
+  - Error-Badge — roter Zähler im Tab-Button bei Fehlern/Warnungen
+  - Clear-Button — Buffer leeren
+  - Download-Button — letzte 500 Einträge als `kx-bridge.log`
+  - Log-Fenster füllt den gesamten verfügbaren Platz (statt fester Höhe 160px)
+- **Log-Buffer:** 500 Einträge (Server + Browser vereinheitlicht)
+- **Changelog im Update-Dialog:** Release-Notes aus Gitea werden direkt im Update-Dialog angezeigt
+- **Slicer-Schätzzeit:** Geschätzte Gesamtdruckzeit aus dem GCode-Header im Fortschritts-Panel
+
+---
+
+## [0.9.1-beta15] – 2026-04-26
+
+### Fixes
+- AMS: Leere Slots werden beim Druckstart übersprungen — kein `filament runout` mehr bei unbelegten Kanälen (Issue #5)
+- AMS: Material-Typ wird jetzt korrekt aus dem Drucker-Protokoll gelesen (Feld `type` statt `material_type`)
+- AMS UI: Leere Slots werden grau/transparent mit „Leer"-Label dargestellt
+
+---
+
+## [0.9.1-beta14] – 2026-04-26
+
+### Fixes
+- Z-Achse: ▲ fährt jetzt aufwärts (Z+), ▼ abwärts (Z−) — Pfeile waren vertauscht (Issue #4)
+- Home All: korrekter Achsen-Code 5 — homed alle Achsen XYZ (Issue #4)
+- Neuer Button „Home XY" (axis=4) in der UI
+- Neuer Button „Motoren aus" (axis turnOff) in der UI
+
+---
+
+## [0.9.1-beta13] – 2026-04-26
+
+### Fixes (Windows)
+- Self-Update / Settings-Neustart: `os.execv` funktioniert jetzt korrekt in der PyInstaller-Binary
+- Kamera: `ffmpeg nicht gefunden` crasht nicht mehr — saubere 503-Antwort wenn ffmpeg fehlt
+- Reconnect-Loop: Kurze leere TCP-Reads unter Windows lösen keine sofortigen Reconnects mehr aus
+
+### Struktur
+- `bridge/`: Bridge-Dateien aus `05_scripts/` herausgelöst
+- `tools/`: `extract_credentials.py` als eigenständiges Tool mit eigenem README
+- `_archive/`: RE-Forschungsordner, Analyse-Tools und alte Release-Checksums archiviert
+- README komplett neu: klarer 3-Schritte-Schnellstart
+
+---
+
+## [0.9.1-beta12] – 2026-04-25
+
+### Fixes
+- Falsche MQTT-Zugangsdaten zeigen jetzt eine verständliche Fehlermeldung statt des kryptischen `CONNACK failed: 20020005`
+
+---
+
+## [0.9.1-beta11] – 2026-04-25
+
+### Fixes
+- Drucker-IP wird automatisch bereinigt wenn der Nutzer versehentlich den Port miteingibt (z.B. `192.168.1.102:9883` → `192.168.1.102`)
+- Settings-Modal: Hinweis erscheint wenn ein `:` in der IP erkannt wird
+- `docker-compose.yml`: `.env` als Volume gemountet — Einstellungen bleiben nach `docker-compose restart` erhalten
+
+---
+
+## [0.9.1-beta10] – 2026-04-25
+
+### Neu
+- `start.sh` — startet die Bridge per Docker, baut das Image automatisch beim ersten Aufruf
+- Tests: pytest-Suite (19 Tests) für API-State, Moonraker-Endpunkte, Settings; Installations-Smoke-Test (`test_install.sh`)
+- Settings-Modal öffnet sich beim ersten Start automatisch wenn keine Zugangsdaten hinterlegt sind
+
+### Geändert
+- README: Schnellstart zeigt jetzt `./start.sh` statt manuellem `docker build`
+- README: LAN-Modus korrekt als Drucker-Menüoption beschrieben
+- README: Versionsnummer wird ab jetzt automatisch bei jedem Release aktualisiert
+- `extract_credentials`: `--write-env` nicht mehr empfohlen — Werte im ⚙-Menü eintragen
+- Dockerfile im Release-Repo: Pfade ohne `05_scripts/`-Präfix
+- `release.sh`: Dockerfile für Release-Repo automatisch per `sed` angepasst
+
+### Fixes
+- Restdruckzeit (`remain_time`) wird jetzt korrekt aus `print/report` übernommen und in der UI angezeigt
+- Übersetzungen: „Schrittweite" und „Ziel"-Placeholder in Temperatureingaben korrekt übersetzt
+
+---
+
+## [0.9.1-beta9] – 2026-04-25
+
+### Neu
+- OrcaSlicer-Profil (`kobra_x_orcaslicer_preset.zip`) als Release-Asset
+- `release.sh`: OrcaSlicer-Profil wird automatisch ins Release-Repo kopiert und hochgeladen
+
+### Geändert
+- README: `extract_credentials` ohne `--write-env`, Werte manuell im ⚙-Menü eintragen
+- README: Docker-Schnellstart vereinfacht
+
+---
+
+## [0.9.1-beta8] – 2026-04-25
+
+### Neu
+- Restdruckzeit-Anzeige in der UI (≈ Xh Ym verbleibend) aus `remain_time`-Feld
+- Settings-Modal: Verbindungseinstellungen und Self-Update direkt im Browser
+- Self-Update: Bridge prüft Gitea-Release-API auf neue Versionen und aktualisiert sich selbst
+
+### Geändert
+- Bridge startet im Offline-Modus wenn Drucker nicht erreichbar (kein Absturz)
+- Verbinden/Trennen-Button im Header
+
+---
+
+## [0.9.1-beta7] – 2026-04-22
+
+### Neu
+- Offline-Start: Bridge läuft auch ohne MQTT-Verbindung, verbindet automatisch sobald Drucker erreichbar
+- Verbinden/Trennen-Button im Header
+
+---
+
+## [0.9.1-beta6] – 2026-04-20
+
+### Neu
+- Release-ZIPs: `kx-bridge-linux.zip`, `kx-bridge-windows.zip`, `anycubic-certs.zip` mit Zertifikaten
+
+### Fixes
+- PyInstaller frozen-Binary: `__file__` durch `sys.executable`-Pfad ersetzt (Cert-Pfad-Fix)
+
+---
+
+## [0.9.1-beta5] – 2026-04-19
+
+### Neu
+- `kx-bridge.exe` (Windows) wird automatisch via GitHub Actions gebaut
+
+---
+
+## [0.9.1-beta4] – 2026-04-18
+
+### Neu
+- `release.sh`: baut Linux-Binary und Windows-EXE, lädt alle Assets auf Gitea hoch
+- Englische README (`README.en.md`)
+
+### Fixes
+- `progress` und `filename` werden bei `stoped`/`canceled` korrekt auf 0 zurückgesetzt
+
+---
+
+## [0.9.1-beta3] – 2026-04-17
+
+### Neu
+- Druckgeschwindigkeit-Karte (Leise / Normal / Sport)
+- Übersetzungen (DE/EN) vervollständigt
+
+---
+
+## [0.9.1-beta2] – 2026-04-17
+
+### Fixes
+- Temperatursteuerung während eines laufenden Drucks
+
+---
+
+## [0.9.1-beta1] – 2026-04-17
+
+### Neu
+- UI-Komplettüberarbeitung: Settings-Modal, Self-Update, Dashboard, Responsive Design
+- Neue Drucker-Zustände: `pausing`, `paused`, `resuming`, `resumed`, `stopping`
+- `release.sh`: Version-Bump und Release-Sync Skript
+
+---
+
+## [0.9.0-beta1] – 2026-04-10
+
+### Neu
+- Erster öffentlicher Release
+- Docker-Deployment, Linux-Binary, `extract_credentials`-Tool
+- Moonraker-kompatible HTTP/WebSocket-Bridge für den Anycubic Kobra X
+- AMS Einziehen/Ausziehen, Licht- und Lüftersteuerung
+- Web-UI mit Dashboard, Temperaturkarten, Achsensteuerung

CHANGELOG.md

@@ -1,166 +1,212 @@
 # Changelog
 
+## [0.9.2] – 2026-04-29
+
+### ⚠️ Breaking Change: Configuration moves from `.env` to `config/config.ini`
+
+**Migration is automatic** on first start — no manual action required.
+
+- Settings are now read from `config/config.ini` instead of `.env`
+- On first start without `config.ini`, the file is created automatically from `.env`
+- **Docker:** Volume `./config:/app/config` in `docker-compose.yml` is the persistent storage — settings survive `docker-compose restart` and updates
+- **Standalone:** `config/config.ini` sits next to the binary and is not overwritten on update
+- `.env` stays mounted read-only as a migration source — you can leave it in place
+- To create a `config.ini` manually: copy `config/config.ini.example`
+
+### New
+- **Persistent settings:** `config/config.ini` replaces `.env` — settings no longer lost after `docker-compose restart` (Issue #9)
+- **Connection error banner:** Red banner at the top of the Web-UI when MQTT connection fails (e.g. wrong password, printer unreachable) (Issue #11)
+- **Slicer estimated time:** Estimated total print time from GCode header shown in the progress panel
+
+### Fixes
+- README: OrcaSlicer connection documented explicitly with `http://` and port `:7125` (Issue #12)
+- README: Direct download link for `extract_credentials` pointing to Gitea releases (Issue #13)
+
+---
+
+## [0.9.1-dev] – ongoing (dev branch)
+
+### New
+- **Dev branch infrastructure:** Version scheme `0.9.1-dev+<hash>` — every build uniquely identifiable
+- **Separate update channel:** Dev versions check for Gitea pre-releases with `-dev+` in the tag
+- **AMS slot selection:** Setting "Default slot (single color)" in the Settings modal — pins a specific AMS channel or Auto (all loaded slots)
+- **Auto-leveling:** Checkbox in Settings modal — controls `task_settings.auto_leveling` on print start
+- **MQTT logging:** Structured TX/RX log with duplicate filter (`kobrax.mqtt` logger)
+- **Server log in browser console:** Live stream via SSE (`/api/log/stream`) — all server logs appear in the Log tab
+- **Log tab improvements:**
+  - Auto-scroll on/off — disables automatically on manual scroll-up, button to re-enable
+  - Text filter — live filtering of log entries
+  - Error badge — red counter on the tab button when errors/warnings occur while on another tab
+  - Clear button — empty the buffer
+  - Download button — last 500 entries as `kx-bridge.log`
+  - Log window now fills all available space (instead of fixed 160px height)
+- **Log buffer:** 500 entries (server + browser unified)
+- **Changelog in update dialog:** Release notes from Gitea loaded and shown directly in the update dialog
+- **Slicer estimated time:** Estimated total print time from GCode header shown in the progress panel
+
+---
+
 ## [0.9.1-beta15] – 2026-04-26
 
 ### Fixes
-- AMS: Leere Slots werden beim Druckstart übersprungen – kein `filament runout` mehr bei unbelegten Kanälen (Issue #5)
+- AMS: Empty slots are skipped on print start — no more `filament runout` for unloaded channels (Issue #5)
-- AMS: Material-Typ wird jetzt korrekt aus dem Drucker-Protokoll gelesen (Feld `type` statt `material_type`)
+- AMS: Material type is now correctly read from the printer protocol (field `type` instead of `material_type`)
-- AMS UI: Leere Slots werden grau und transparent dargestellt mit „Leer"-Label
+- AMS UI: Empty slots shown grey/transparent with "Empty" label
 
 ---
 
 ## [0.9.1-beta14] – 2026-04-26
 
 ### Fixes
-- Z-Achse: ▲ fährt jetzt aufwärts (Z+), ▼ abwärts (Z−) – Pfeile waren vertauscht (Issue #4)
+- Z axis: ▲ now moves up (Z+), ▼ moves down (Z−) — arrows were reversed (Issue #4)
-- Home All: korrekter axis-Code 5 – homed alle Achsen XYZ (Issue #4)
+- Home All: correct axis code 5 — homes all axes XYZ (Issue #4)
-- Neuer Button „Home XY" (axis=4) in der UI
+- New "Home XY" button (axis=4) in the UI
-- Neuer Button „Motors Off" (axis turnOff) in der UI
+- New "Motors Off" button (axis turnOff) in the UI
 
 ---
 
 ## [0.9.1-beta13] – 2026-04-26
 
 ### Fixes (Windows)
-- Self-Update / Settings-Neustart: `os.execv` funktioniert jetzt korrekt in der PyInstaller-Binary (kein doppelter Pfad als Argument mehr)
+- Self-update / Settings restart: `os.execv` now works correctly in PyInstaller binary
-- Kamera: `ffmpeg nicht gefunden` crasht nicht mehr – saubere 503-Antwort wenn ffmpeg nicht installiert ist
+- Camera: `ffmpeg not found` no longer crashes — clean 503 response when ffmpeg is not installed
-- Reconnect-Loop: Kurzeitige leere TCP-Reads unter Windows führen nicht mehr sofort zu Reconnects
+- Reconnect loop: Short empty TCP reads on Windows no longer trigger immediate reconnects
 
-### Struktur
+### Structure
-- `bridge/`: Bridge-Dateien aus `05_scripts/` herausgelöst
+- `bridge/`: Bridge files extracted from `05_scripts/`
-- `tools/`: `extract_credentials.py` als eigenständiges Tool mit eigenem README
+- `tools/`: `extract_credentials.py` as standalone tool with its own README
-- `_archive/`: RE-Forschungsordner, Analyse-Tools und alte Release-Checksums archiviert
+- `_archive/`: RE research folders, analysis tools and old release checksums archived
-- README komplett neu: klarer 3-Schritte-Schnellstart
+- README fully rewritten: clear 3-step quick start
 
 ---
 
 ## [0.9.1-beta12] – 2026-04-25
 
 ### Fixes
-- Fehlermeldung bei falschen MQTT-Zugangsdaten ist jetzt verständlich: `Falsche MQTT-Zugangsdaten (falscher Benutzername, Passwort oder Device-ID)` statt kryptischem `CONNACK failed: 20020005`
+- Wrong MQTT credentials now shows a human-readable error instead of cryptic `CONNACK failed: 20020005`
 
 ---
 
 ## [0.9.1-beta11] – 2026-04-25
 
 ### Fixes
-- Drucker-IP wird automatisch bereinigt wenn der Nutzer versehentlich den Port miteingibt (z.B. `192.168.1.102:9883` → `192.168.1.102`)
+- Printer IP is automatically cleaned if the user accidentally includes the port (e.g. `192.168.1.102:9883` → `192.168.1.102`)
-- Settings-Modal: Hinweis erscheint wenn ein `:` in der IP erkannt wird
+- Settings modal: hint shown when `:` is detected in the IP field
-- `docker-compose.yml`: `.env` wird als Volume in den Container gemountet – Einstellungen bleiben nach `docker-compose restart` erhalten
+- `docker-compose.yml`: `.env` mounted as volume into the container — settings persist after `docker-compose restart`
 
 ---
 
 ## [0.9.1-beta10] – 2026-04-25
 
-### Neu
+### New
-- `start.sh` – startet die Bridge per Docker, baut das Image automatisch beim ersten Aufruf
+- `start.sh` — starts the bridge via Docker, builds the image automatically on first run
-- Tests: pytest-Suite (19 Tests) für API-State, Moonraker-Endpunkte, Settings; Installations-Smoke-Test (`test_install.sh`)
+- Tests: pytest suite (19 tests) for API state, Moonraker endpoints, settings; install smoke test (`test_install.sh`)
-- Settings-Modal öffnet sich beim ersten Start automatisch wenn keine Zugangsdaten hinterlegt sind
+- Settings modal opens automatically on first start when no credentials are configured
 
-### Geändert
+### Changed
-- README (DE + EN): Schnellstart zeigt jetzt `./start.sh` statt manuellem `docker build`
+- README: Quick start now shows `./start.sh` instead of manual `docker build`
-- README: LAN-Modus korrekt als Drucker-Menüoption beschrieben (kein WLAN-Bezug)
+- README: LAN mode correctly described as a printer menu option
-- README: Versionsnummer wird ab jetzt automatisch bei jedem Release aktualisiert
+- README: Version number now updated automatically on each release
-- `extract_credentials`: kein `--write-env` mehr empfohlen – Werte im ⚙-Menü eintragen
+- `extract_credentials`: `--write-env` no longer recommended — enter values in the ⚙ menu
-- Dockerfile im Release-Repo: Pfade ohne `05_scripts/`-Präfix (direkt aus Repo-Root)
+- Dockerfile in release repo: paths without `05_scripts/` prefix
-- `release.sh`: Dockerfile für Release-Repo automatisch per `sed` angepasst
+- `release.sh`: Dockerfile for release repo automatically patched via `sed`
 
 ### Fixes
-- Restdruckzeit (`remain_time`) wird jetzt korrekt aus `print/report` übernommen und in der UI angezeigt
+- Remaining print time (`remain_time`) now correctly taken from `print/report` and shown in UI
-- Übersetzung: „Schrittweite" und „Ziel"-Placeholder in Temperatureingaben werden jetzt korrekt übersetzt
+- Translation: "Step size" and "Target" placeholders in temperature inputs now correctly translated
 
 ---
 
 ## [0.9.1-beta9] – 2026-04-25
 
-### Neu
+### New
-- OrcaSlicer-Profil (`kobra_x_orcaslicer_preset.zip`) als Release-Asset
+- OrcaSlicer profile (`kobra_x_orcaslicer_preset.zip`) as release asset
-- `release.sh`: OrcaSlicer-Profil wird automatisch ins Release-Repo kopiert und hochgeladen
+- `release.sh`: OrcaSlicer profile automatically copied to release repo and uploaded
 
-### Geändert
+### Changed
-- README: `extract_credentials` ohne `--write-env`, Werte manuell ins ⚙-Menü eintragen
+- README: `extract_credentials` without `--write-env`, values entered manually in the ⚙ menu
-- README: Docker-Schnellstart vereinfacht (kein `.env` anlegen vor dem Start nötig)
+- README: Docker quick start simplified
 
 ---
 
 ## [0.9.1-beta8] – 2026-04-25
 
-### Neu
+### New
-- Restdruckzeit-Anzeige in der UI (≈ Xh Ym verbleibend) aus `remain_time`-Feld des Druckers
+- Remaining print time display in UI (≈ Xh Ym remaining) from `remain_time` field
-- Settings-Modal: Verbindungseinstellungen und Self-Update direkt im Browser
+- Settings modal: connection settings and self-update directly in the browser
-- Self-Update: Bridge prüft Gitea-Release-API auf neue Versionen und aktualisiert sich selbst
+- Self-update: bridge checks Gitea release API for new versions and updates itself
 
-### Geändert
+### Changed
-- Bridge startet im Offline-Modus wenn Drucker nicht erreichbar (kein Absturz)
+- Bridge starts in offline mode when printer is unreachable (no crash)
-- Verbinden/Trennen-Button im Header
+- Connect/Disconnect button in header
 
 ---
 
 ## [0.9.1-beta7] – 2026-04-22
 
-### Neu
+### New
-- Offline-Start: Bridge läuft auch ohne MQTT-Verbindung, verbindet automatisch sobald Drucker erreichbar
+- Offline start: bridge runs without MQTT connection, reconnects automatically when printer is reachable
-- Verbinden/Trennen-Button im Header
+- Connect/Disconnect button in header
 
 ---
 
 ## [0.9.1-beta6] – 2026-04-20
 
-### Neu
+### New
-- Release-ZIPs: `kx-bridge-linux.zip`, `kx-bridge-windows.zip`, `anycubic-certs.zip` mit Zertifikaten
+- Release ZIPs: `kx-bridge-linux.zip`, `kx-bridge-windows.zip`, `anycubic-certs.zip` with certificates
 
 ### Fixes
-- PyInstaller frozen-Binary: `__file__` durch `sys.executable`-Pfad ersetzt (Cert-Pfad-Fix)
+- PyInstaller frozen binary: `__file__` replaced with `sys.executable` path (cert path fix)
 
 ---
 
 ## [0.9.1-beta5] – 2026-04-19
 
-### Neu
+### New
-- `kx-bridge.exe` (Windows) wird automatisch via GitHub Actions gebaut
+- `kx-bridge.exe` (Windows) built automatically via GitHub Actions
 
 ---
 
 ## [0.9.1-beta4] – 2026-04-18
 
-### Neu
+### New
-- `release.sh`: baut Linux-Binary und Windows-EXE, lädt alle Assets auf Gitea hoch
+- `release.sh`: builds Linux binary and Windows EXE, uploads all assets to Gitea
-- Englische README (`README.en.md`)
+- English README (`README.en.md`)
 
 ### Fixes
-- `progress` und `filename` werden bei `stoped`/`canceled` korrekt auf 0 zurückgesetzt
+- `progress` and `filename` correctly reset to 0 on `stoped`/`canceled`
 
 ---
 
 ## [0.9.1-beta3] – 2026-04-17
 
-### Neu
+### New
-- Print-Speed-Card (Leise / Normal / Sport)
+- Print speed card (Silent / Normal / Sport)
-- Übersetzungen (DE/EN) vervollständigt
+- Translations (DE/EN) completed
 
 ---
 
 ## [0.9.1-beta2] – 2026-04-17
 
 ### Fixes
-- Temperatursteuerung während eines laufenden Drucks
+- Temperature control during an active print
 
 ---
 
 ## [0.9.1-beta1] – 2026-04-17
 
-### Neu
+### New
-- UI-Komplettüberarbeitung: Settings-Modal, Self-Update, Dashboard, Responsive Design
+- Complete UI overhaul: Settings modal, self-update, dashboard, responsive design
-- Neue Drucker-Zustände: `pausing`, `paused`, `resuming`, `resumed`, `stopping`
+- New printer states: `pausing`, `paused`, `resuming`, `resumed`, `stopping`
-- `release.sh`: Version-Bump und Release-Sync Skript
+- `release.sh`: version bump and release sync script
 
 ---
 
 ## [0.9.0-beta1] – 2026-04-10
 
-### Neu
+### New
-- Erster öffentlicher Release
+- First public release
-- Docker-Deployment, Linux-Binary, `extract_credentials`-Tool
+- Docker deployment, Linux binary, `extract_credentials` tool
-- Moonraker-kompatible HTTP/WebSocket-Bridge für den Anycubic Kobra X
+- Moonraker-compatible HTTP/WebSocket bridge for the Anycubic Kobra X
-- AMS Einziehen/Ausziehen, Licht- und Lüftersteuerung
+- AMS load/unload, light and fan control
-- Web-UI mit Dashboard, Temperaturkarten, Achsensteuerung
+- Web-UI with dashboard, temperature cards, motion control

Dockerfile

@@ -2,14 +2,21 @@ FROM python:3.11-slim
 
 WORKDIR /app
 
-COPY requirements.txt .
+COPY bridge/requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY kobrax_moonraker_bridge.py .
+COPY bridge/kobrax_moonraker_bridge.py .
-COPY env_loader.py .
+COPY bridge/config_loader.py .
-COPY kobrax_client.py .
+COPY bridge/env_loader.py .
-COPY anycubic_slicer.crt .
+COPY bridge/kobrax_client.py .
-COPY anycubic_slicer.key .
+COPY VERSION .
+COPY bridge/anycubic_slicer.crt .
+COPY bridge/anycubic_slicer.key .
+COPY bridge/config/config.ini.example /app/config/config.ini.example
+
+# config/ ist ein Volume-Mountpoint – beim Start wird config.ini aus .env migriert
+# falls noch keine config.ini vorhanden ist.
+RUN mkdir -p /app/config
 
 EXPOSE 7125
 

README.de.md

@@ -0,0 +1,137 @@
+<p align="center"><img src="knlogo.png" alt="KX-Bridge Logo" width="180"/></p>
+
+# KX-Bridge – Anycubic Kobra X
+
+**Version:** 0.9.2
+
+Steuere deinen **Anycubic Kobra X** mit OrcaSlicer — ohne Klipper, ohne Raspberry Pi.  
+KX-Bridge ist eine Moonraker-kompatible Bridge die direkt mit dem Drucker kommuniziert.
+
+---
+
+## Schnellstart in 3 Schritten
+
+### Schritt 1 – Drucker vorbereiten
+
+Den Kobra X in den LAN-Modus versetzen:  
+**Drucker-Display → Einstellungen → LAN-Modus einschalten**
+
+### Schritt 2 – Credentials holen
+
+Die MQTT-Zugangsdaten sind druckerspezifisch. So holst du sie:
+
+1. **AnycubicSlicerNext** öffnen und Drucker verbinden (bis Status angezeigt wird)
+2. **`extract_credentials.exe`** (Windows) oder **`extract_credentials`** (Linux) ausführen — gibt Username, Password, Device-ID und Drucker-IP aus
+3. Werte merken / kopieren
+
+> **Download:** [gitea.it-drui.de/viewit/KX-Bridge-Release/releases](https://gitea.it-drui.de/viewit/KX-Bridge-Release/releases) → `extract_credentials.exe` (Windows) / `extract_credentials` (Linux) im jeweiligen Release-Asset
+
+### Schritt 3 – Bridge starten
+
+```bash
+./start.sh
+```
+
+Das Skript baut das Docker-Image automatisch beim ersten Aufruf.
+
+**Web-UI öffnen:** `http://BRIDGE-IP:7125`  
+→ Das ⚙-Menü öffnet sich beim ersten Start automatisch  
+→ Credentials aus Schritt 2 eintragen → **Speichern & Neustart**
+
+**OrcaSlicer verbinden:**  
+Drucker → Verbindungstyp **Moonraker** → Host: `http://BRIDGE-IP:7125`
+
+> **Wichtig:** Verbindungstyp muss **Moonraker** sein (nicht „Bambu" oder „Klipper").  
+> Im Host-Feld vollständige URL mit `http://` und Port `:7125` angeben.
+
+---
+
+## ⚠️ Update von 0.9.1 oder älter
+
+Ab **0.9.2** speichert KX-Bridge Einstellungen in `config/config.ini` statt in `.env`.
+
+**Migration erfolgt automatisch** — keine manuelle Aktion nötig:
+- Beim ersten Start nach dem Update liest die Bridge die vorhandene `.env` und erstellt `config/config.ini` automatisch
+- Einstellungen bleiben ab sofort nach `docker-compose restart` und zukünftigen Updates erhalten
+- Die `.env`-Datei bleibt read-only gemountet als Migrationsquelle — kann liegen bleiben
+- Zum manuellen Anlegen einer `config.ini`: Vorlage unter `config/config.ini.example` kopieren
+
+---
+
+## Was wird unterstützt?
+
+| Funktion | Details |
+|----------|---------|
+| Druckerstatus | Temperatur, Fortschritt, Zustand, Restzeit |
+| Drucksteuerung | Start, Pause, Fortsetzen, Abbrechen |
+| Temperaturregelung | Nozzle und Bett während des Drucks |
+| Druckgeschwindigkeit | Leise / Normal / Sport |
+| AMS-Farbwechsel | Filament einziehen / ausziehen |
+| Licht & Lüfter | Drucklicht und Lüfterdrehzahl |
+| Web-UI | Dashboard, Achsensteuerung, Kameraansicht |
+| Self-Update | Neue Versionen direkt im Browser installieren |
+| OrcaSlicer | Moonraker-Protokoll (HTTP + WebSocket) |
+
+---
+
+## Alternativen zu Docker
+
+**Linux Binary** (kein Docker nötig):
+```bash
+chmod +x kx-bridge
+./kx-bridge
+```
+
+**Python direkt:**
+```bash
+pip install aiohttp
+python bridge/kobrax_moonraker_bridge.py
+```
+
+Web-UI jeweils unter `http://localhost:7125` — ⚙-Menü führt durch die Erstkonfiguration.
+
+---
+
+## Nützliche Befehle
+
+```bash
+# Logs anzeigen
+docker-compose logs -f
+
+# Bridge stoppen
+docker-compose down
+
+# Bridge neu starten (nach Update)
+./start.sh
+```
+
+---
+
+## Fehlerbehebung
+
+**„Falsche MQTT-Zugangsdaten"** beim Start:
+- AnycubicSlicerNext neu starten, Drucker verbinden, `extract_credentials` erneut ausführen
+- Nur die IP-Adresse ins Feld eintragen, keinen Port (✗ `192.168.1.102:9883` → ✓ `192.168.1.102`)
+
+**Drucker nicht gefunden / kein LAN-Modus:**
+- Am Drucker-Display: Einstellungen → LAN-Modus einschalten
+- Drucker und Bridge müssen im selben Netzwerk sein
+
+**Docker: Permission denied:**
+```bash
+sudo usermod -aG docker $USER  # dann neu einloggen
+```
+
+---
+
+## Sicherheitshinweise
+
+- Die Bridge ist im lokalen Netzwerk erreichbar unter `http://<Host-IP>:7125` — nicht ins Internet freigeben
+- `config/config.ini` enthält Drucker-Credentials — nicht öffentlich teilen
+- Credentials haben keinen Zugang zu Anycubic-Cloud-Diensten
+
+---
+
+## Lizenz & Rechtliches
+
+Interoperabilitätsforschung gem. §69e UrhG — ausschließlich private, nicht-kommerzielle Nutzung.

README.en.md

@@ -1,258 +0,0 @@
-<p align="center"><img src="knlogo.png" alt="KX-Bridge Logo" width="180"/></p>
-
-# KX-Bridge – Anycubic Kobra X Klipper Bridge
-
-**Version:** 0.9.1-beta15
-**Status:** Public Beta – suitable for home users, feedback welcome
-
-KX-Bridge is a Moonraker-compatible HTTP/WebSocket bridge for the **Anycubic Kobra X** 3D printer. It allows you to control the printer through OrcaSlicer and other Moonraker-compatible software — no Klipper, no Raspberry Pi required.
-
----
-
-## What's supported?
-
-- Printer status (temperature, progress, state)
-- File transfer and print start
-- Print control: pause, resume, cancel
-- Temperature control during an active print
-- Print speed (Silent / Normal / Sport)
-- AMS filament change (load / unload)
-- Light and fan control
-- Web UI with dashboard, temperature cards, axis control, and camera view
-- Settings and self-update directly in the browser (⚙ menu)
-- OrcaSlicer connection (Moonraker protocol)
-
----
-
-## Requirements
-
-- Anycubic Kobra X on your local network, with **LAN mode enabled** (printer menu → enable LAN mode)
-- Printer MQTT credentials (→ see [Extracting credentials](#extracting-credentials))
-- Docker **or** Python 3.9+ **or** the pre-built Linux binary
-
----
-
-## Quick start – Docker (recommended)
-
-```bash
-# 1. Start the bridge
-./start.sh
-```
-
-`start.sh` builds the Docker image automatically on first run and starts the bridge.
-
-```
-# 2. Open the web UI: http://BRIDGE-IP:7125
-#    → Settings (⚙) open automatically on first start
-#    → Enter your credentials (→ see Extracting credentials)
-
-# 3. In OrcaSlicer: add printer → "Moonraker" → http://BRIDGE-IP:7125
-```
-
-Check logs:
-```bash
-docker-compose logs -f
-```
-
-Stop:
-```bash
-docker-compose down
-```
-
----
-
-## Quick start – Binary (Linux)
-
-```bash
-chmod +x kx-bridge
-./kx-bridge
-```
-
-Open the web UI: `http://localhost:7125`  
-→ Settings (⚙) open automatically and guide you through the initial setup.
-
----
-
-## Quick start – Python directly
-
-```bash
-pip install aiohttp
-python kobrax_moonraker_bridge.py
-```
-
-Open the web UI: `http://localhost:7125`  
-→ Settings (⚙) open automatically on first start.
-
----
-
-## Extracting credentials
-
-The MQTT credentials are printer-specific and are generated on first connection with AnycubicSlicerNext. The `extract_credentials` tool reads them from the memory of the running slicer.
-
-**Requirement:** AnycubicSlicerNext must be running and connected to the printer (printer status is shown).
-
-### Windows
-
-```
-extract_credentials.exe
-```
-
-### Linux
-
-```bash
-chmod +x extract_credentials
-./extract_credentials
-```
-
-### Output
-
-```
-[*] Process found: AnycubicSlicerNext.exe (PID 1234)
-[*] 1986 memory segments read (738.8 MB)
-[*] Analyzing ... 100% (739 MB)
-
-=======================================================
-  RESULTS
-=======================================================
-  Username      userXXXXXXXXXX  (hits: 47)
-  Password      ***************  (hits: 1046)
-  Device-ID     xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  (hits: 3504)
-  Printer IP    192.168.x.x  (hits: 3036)
-=======================================================
-```
-
-Enter the displayed values in the bridge settings:  
-Open web UI → **⚙ Settings** → fill in the fields → **Save & Restart**
-
-> If the result looks uncertain: `--verbose` shows all found candidates.
-
-All credentials are **processed locally only** — nothing is sent to external servers.
-
----
-
-## Configuration (.env)
-
-```env
-PRINTER_IP=192.168.x.x       # Printer IP address
-MQTT_PORT=9883                # Default, do not change
-MQTT_USERNAME=userXXXXXXXX   # Starts with "user"
-MQTT_PASSWORD=XXXXXXXXXXXXXX  # ~15 characters, mixed case
-DEVICE_ID=xxxxxxxx...         # 32-character hex string
-MODE_ID=20030                 # Kobra X default
-```
-
----
-
-## OrcaSlicer setup
-
-1. Add printer → **Anycubic Kobra X** (or generic Klipper printer)
-2. Connection type: **Moonraker**
-3. Host: `http://BRIDGE-HOST:7125`
-4. Test connection → should show "Online"
-
----
-
-## Web UI
-
-The bridge serves a web interface at `http://BRIDGE-HOST:7125`:
-
-| Section | Function |
-|---------|----------|
-| Dashboard | Printer status, progress, temperature overview |
-| Temperatures | Set nozzle and bed temperature directly |
-| Motion | X/Y/Z movement, motor release |
-| Print Speed | Silent / Normal / Sport |
-| Fan / Light | Fan speed and work light |
-| AMS | Load / unload filament |
-| Camera | Live preview (if supported by printer) |
-| ⚙ Settings | MQTT credentials, poll interval, self-update |
-
-### Self-update
-
-The ⚙ menu in the web UI lets you check for new versions and update the bridge in place — no reinstallation needed. After the download the bridge restarts automatically with the new version.
-
----
-
-## bridge.sh (Linux service manager)
-
-```bash
-./bridge.sh start    # Start bridge in background
-./bridge.sh stop     # Stop bridge
-./bridge.sh restart  # Restart
-./bridge.sh status   # Check status and port
-./bridge.sh log 50   # Show last 50 log lines
-```
-
----
-
-## Printer states
-
-The bridge translates internal Kobra states into Moonraker-compatible states:
-
-| Kobra state | Meaning |
-|-------------|---------|
-| free | Ready |
-| printing / busy | Printing |
-| pausing / paused | Paused |
-| resuming / resumed | Resuming |
-| stopping / stoped | Stopping |
-| finished | Complete |
-| canceled | Cancelled |
-| failed | Error |
-
----
-
-## Troubleshooting
-
-**Port 7125 already in use:**
-```bash
-./bridge.sh stop    # or: fuser -k 7125/tcp
-./bridge.sh start
-```
-
-**Invalid credentials / connection refused:**
-- Start AnycubicSlicerNext, connect to the printer, then run `extract_credentials` again
-- If the result looks uncertain: `extract_credentials --verbose` shows all candidates
-- Manually enter the correct candidate in `.env` and restart the bridge
-
-**Temperature changes are ignored:**
-- During an active print, temperature changes are sent via a separate channel — this is normal and the bridge handles it automatically.
-
-**Docker: Permission denied:**
-```bash
-sudo usermod -aG docker $USER
-# Log out and back in
-```
-
-**Docker: .env not found:**
-```bash
-# .env must be in the same directory as docker-compose.yml
-cp .env.example .env && nano .env
-```
-
----
-
-## Logs
-
-```bash
-# Docker
-docker compose logs -f kx-bridge
-
-# Binary / Python
-tail -f /tmp/bridge.log   # when using bridge.sh
-```
-
----
-
-## Security notes
-
-- The bridge is accessible on your local network via `http://<your-host-ip>:7125` — do not expose to the internet
-- `.env` contains printer credentials — do not share publicly
-- The credentials are printer-specific and have no access to Anycubic cloud services
-
----
-
-## License & legal
-
-This project was created through interoperability research under §69e UrhG (German copyright law).  
-For private, non-commercial use only.

README.md

@@ -1,258 +1,137 @@
 <p align="center"><img src="knlogo.png" alt="KX-Bridge Logo" width="180"/></p>
 
-# KX-Bridge – Anycubic Kobra X Klipper Bridge
+# KX-Bridge – Anycubic Kobra X
 
-**Version:** 0.9.1-beta15
+**Version:** 0.9.2
-**Status:** Public Beta – für Heimanwender geeignet, Feedback willkommen
 
-KX-Bridge ist eine Moonraker-kompatible HTTP/WebSocket-Bridge für den **Anycubic Kobra X** 3D-Drucker. Sie ermöglicht die Steuerung des Druckers über OrcaSlicer und andere Moonraker-kompatible Software, ohne dass Klipper oder ein Raspberry Pi benötigt wird.
+Control your **Anycubic Kobra X** with OrcaSlicer — no Klipper, no Raspberry Pi.  
+KX-Bridge is a Moonraker-compatible bridge that communicates directly with the printer.
 
 ---
 
-## Was wird unterstützt?
+## Quick Start in 3 Steps
 
-- Druckerstatus (Temperatur, Fortschritt, Zustand)
+### Step 1 – Prepare the printer
-- Dateiübertragung und Druckstart
-- Drucksteuerung: Pause, Fortsetzen, Abbrechen
-- Temperaturregelung während des laufenden Drucks
-- Druckgeschwindigkeit (Leise / Normal / Sport)
-- AMS-Farbwechsel (Einziehen / Ausziehen)
-- Licht- und Lüftersteuerung
-- Web-UI mit Dashboard, Temperaturkarten, Achsensteuerung und Kameraansicht
-- Einstellungen und Self-Update direkt im Browser (⚙-Menü)
-- OrcaSlicer-Verbindung (Moonraker-Protokoll)
 
----
+Enable LAN mode on the Kobra X:  
+**Printer display → Settings → Enable LAN mode**
 
-## Voraussetzungen
+### Step 2 – Get credentials
 
-- Anycubic Kobra X im lokalen Netzwerk, mit aktiviertem **LAN-Modus** (Drucker-Menü → LAN-Modus einschalten)
+The MQTT credentials are printer-specific. Here's how to get them:
-- MQTT-Credentials des Druckers (→ siehe [Credentials extrahieren](#credentials-extrahieren))
-- Docker **oder** Python 3.9+ **oder** direkt die Linux-Binary
 
----
+1. Open **AnycubicSlicerNext** and connect the printer (wait until status is shown)
+2. Run **`extract_credentials.exe`** (Windows) or **`extract_credentials`** (Linux) — outputs Username, Password, Device ID and printer IP
+3. Note / copy the values
 
-## Schnellstart – Docker (empfohlen)
+> **Download:** [gitea.it-drui.de/viewit/KX-Bridge-Release/releases](https://gitea.it-drui.de/viewit/KX-Bridge-Release/releases) → `extract_credentials.exe` (Windows) / `extract_credentials` (Linux) in the release assets
+
+### Step 3 – Start the bridge
 
 ```bash
-# 1. Bridge starten
 ./start.sh
 ```
 
-`start.sh` baut das Docker-Image automatisch beim ersten Aufruf und startet die Bridge.
+The script builds the Docker image automatically on first run.
 
-```
+**Open Web-UI:** `http://BRIDGE-IP:7125`  
-# 2. Web-UI öffnen: http://BRIDGE-IP:7125
+→ The ⚙ menu opens automatically on first start  
-#    → Einstellungen (⚙) öffnen sich automatisch beim ersten Start
+→ Enter credentials from Step 2 → **Save & Restart**
-#    → Zugangsdaten eintragen (→ siehe Credentials extrahieren)
 
-# 3. In OrcaSlicer: Drucker → "Moonraker" → http://BRIDGE-IP:7125
+**Connect OrcaSlicer:**  
-```
+Printer → Connection type **Moonraker** → Host: `http://BRIDGE-IP:7125`
 
-Logs prüfen:
+> **Important:** Connection type must be **Moonraker** (not "Bambu" or "Klipper").  
-```bash
+> Enter the full URL including `http://` and port `:7125` in the host field.
-docker-compose logs -f
-```
-
-Stoppen:
-```bash
-docker-compose down
-```
 
 ---
 
-## Schnellstart – Binary (Linux)
+## ⚠️ Upgrading from 0.9.1 or earlier
 
+Starting with **0.9.2**, KX-Bridge stores settings in `config/config.ini` instead of `.env`.
+
+**Migration is automatic** — no manual action required:
+- On first start after upgrade, the bridge reads your existing `.env` and creates `config/config.ini` automatically
+- Settings now survive `docker-compose restart` and future updates
+- The `.env` file stays mounted read-only as a migration source — you can keep it in place
+- If you want to create a `config.ini` manually: copy `config/config.ini.example`
+
+---
+
+## What's supported?
+
+| Feature | Details |
+|---------|---------|
+| Printer status | Temperature, progress, state, remaining time |
+| Print control | Start, pause, resume, cancel |
+| Temperature control | Nozzle and bed during print |
+| Print speed | Silent / Normal / Sport |
+| AMS filament change | Load / unload filament |
+| Light & fan | Print light and fan speed |
+| Web-UI | Dashboard, motion control, camera view |
+| Self-update | Install new versions directly in the browser |
+| OrcaSlicer | Moonraker protocol (HTTP + WebSocket) |
+
+---
+
+## Alternatives to Docker
+
+**Linux binary** (no Docker needed):
 ```bash
 chmod +x kx-bridge
 ./kx-bridge
 ```
 
-Web-UI öffnen: `http://localhost:7125`  
+**Python directly:**
-→ Einstellungen (⚙) öffnen sich automatisch und führen durch die Erstkonfiguration.
-
----
-
-## Schnellstart – Python direkt
-
 ```bash
 pip install aiohttp
-python kobrax_moonraker_bridge.py
+python bridge/kobrax_moonraker_bridge.py
 ```
 
-Web-UI öffnen: `http://localhost:7125`  
+Web-UI available at `http://localhost:7125` — the ⚙ menu guides through initial setup.
-→ Einstellungen (⚙) öffnen sich automatisch beim ersten Start.
 
 ---
 
-## Credentials extrahieren
+## Useful commands
-
-Die MQTT-Zugangsdaten sind druckerspezifisch und werden beim ersten Verbindungsaufbau mit dem AnycubicSlicerNext generiert. Das Tool `extract_credentials` liest sie aus dem RAM des laufenden Slicers aus.
-
-**Voraussetzung:** AnycubicSlicerNext muss gestartet und mit dem Drucker verbunden sein (Drucker-Status wird angezeigt).
-
-### Windows
-
-```
-extract_credentials.exe
-```
-
-### Linux
 
 ```bash
-chmod +x extract_credentials
+# Show logs
-./extract_credentials
+docker-compose logs -f
-```
 
-### Ausgabe
+# Stop bridge
+docker-compose down
 
-```
+# Restart bridge (after update)
-[*] Prozess gefunden: AnycubicSlicerNext.exe (PID 1234)
+./start.sh
-[*] 1986 Speichersegmente gelesen (738.8 MB)
-[*] Analysiere ... 100% (739 MB)
-
-=======================================================
-  ERGEBNISSE
-=======================================================
-  Username      userXXXXXXXXXX  (Treffer: 47)
-  Password      ***************  (Treffer: 1046)
-  Device-ID     xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx  (Treffer: 3504)
-  Drucker-IP    192.168.x.x  (Treffer: 3036)
-=======================================================
-```
-
-Die angezeigten Werte in die Bridge-Einstellungen übertragen:  
-Web-UI öffnen → **⚙ Einstellungen** → Felder ausfüllen → **Speichern & Neustart**
-
-> Falls das Ergebnis unsicher wirkt: `--verbose` zeigt alle gefundenen Kandidaten.
-
-Alle Credentials werden **ausschließlich lokal verarbeitet** — keine Übertragung an externe Server.
-
----
-
-## Konfiguration (.env)
-
-```env
-PRINTER_IP=192.168.x.x       # IP des Druckers
-MQTT_PORT=9883                # Standard, nicht ändern
-MQTT_USERNAME=userXXXXXXXX   # Beginnt mit "user"
-MQTT_PASSWORD=XXXXXXXXXXXXXX  # ~15 Zeichen, gemischt
-DEVICE_ID=xxxxxxxx...         # 32-stelliger Hex-String
-MODE_ID=20030                 # Kobra X Standard
 ```
 
 ---
 
-## OrcaSlicer verbinden
+## Troubleshooting
 
-1. Drucker hinzufügen → **Anycubic Kobra X** (oder generischer Klipper-Drucker)
+**"Wrong MQTT credentials"** on start:
-2. Verbindungstyp: **Moonraker**
+- Restart AnycubicSlicerNext, reconnect the printer, run `extract_credentials` again
-3. IP: `http://BRIDGE-HOST:7125`
+- Enter only the IP address, no port (✗ `192.168.1.102:9883` → ✓ `192.168.1.102`)
-4. Verbindung testen → sollte "Online" anzeigen
 
----
+**Printer not found / no LAN mode:**
-
+- On the printer display: Settings → Enable LAN mode
-## Web-UI
+- Printer and bridge must be on the same network
-
-Die Bridge stellt unter `http://BRIDGE-HOST:7125` eine Web-Oberfläche bereit:
-
-| Bereich | Funktion |
-|---------|----------|
-| Dashboard | Druckerstatus, Fortschritt, Temperaturübersicht |
-| Temperaturen | Nozzle und Bett direkt setzen |
-| Achsen | X/Y/Z-Bewegung, Motorfreigabe |
-| Druckgeschwindigkeit | Leise / Normal / Sport |
-| Lüfter / Licht | Lüfterdrehzahl und Drucklicht |
-| AMS | Filament einziehen / ausziehen |
-| Kamera | Live-Vorschau (falls Drucker unterstützt) |
-| ⚙ Einstellungen | MQTT-Zugangsdaten, Poll-Intervall, Self-Update |
-
-### Self-Update
-
-Über das ⚙-Menü in der Web-UI kann die Bridge auf neue Versionen prüfen und sich selbst aktualisieren — ohne Neuinstallation. Nach dem Download startet die Bridge automatisch mit der neuen Version neu.
-
----
-
-## bridge.sh (Linux Service-Manager)
-
-```bash
-./bridge.sh start    # Bridge im Hintergrund starten
-./bridge.sh stop     # Bridge beenden
-./bridge.sh restart  # Neustarten
-./bridge.sh status   # Status und Port prüfen
-./bridge.sh log 50   # Letzte 50 Log-Zeilen
-```
-
----
-
-## Druckerzustände
-
-Die Bridge übersetzt die internen Kobra-Zustände in Moonraker-kompatible Zustände:
-
-| Kobra-Zustand | Bedeutung |
-|---------------|-----------|
-| free | Bereit |
-| printing / busy | Druckt |
-| pausing / paused | Pausiert |
-| resuming / resumed | Wird fortgesetzt |
-| stopping / stoped | Wird gestoppt |
-| finished | Abgeschlossen |
-| canceled | Abgebrochen |
-| failed | Fehler |
-
----
-
-## Fehlerbehebung
-
-**Port 7125 bereits belegt:**
-```bash
-./bridge.sh stop    # oder: fuser -k 7125/tcp
-./bridge.sh start
-```
-
-**Credentials ungültig / Verbindung abgelehnt:**
-- AnycubicSlicerNext starten, mit Drucker verbinden, `extract_credentials` erneut ausführen
-- Falls das Ergebnis unsicher wirkt: `extract_credentials --verbose` zeigt alle Kandidaten an
-- Den richtigen Kandidaten manuell in `.env` eintragen und Bridge neu starten
-
-**Temperaturänderungen werden ignoriert:**
-- Während eines laufenden Drucks werden Temperaturänderungen über einen separaten Kanal gesendet — das ist normal und wird von der Bridge automatisch erkannt.
 
 **Docker: Permission denied:**
 ```bash
-sudo usermod -aG docker $USER
+sudo usermod -aG docker $USER  # then log out and back in
-# Neu einloggen
-```
-
-**Docker: .env nicht gefunden:**
-```bash
-# .env muss im gleichen Verzeichnis wie docker-compose.yml liegen
-cp .env.example .env && nano .env
 ```
 
 ---
 
-## Logs
+## Security
 
-```bash
+- The bridge is accessible on the local network at `http://<host-IP>:7125` — do not expose to the internet
-# Docker
+- `config/config.ini` contains printer credentials — do not share publicly
-docker compose logs -f kx-bridge
+- Credentials do not grant access to Anycubic cloud services
-
-# Binary / Python
-tail -f /tmp/bridge.log   # bei Nutzung von bridge.sh
-```
 
 ---
 
-## Sicherheitshinweise
+## License
 
-- Die Bridge ist im lokalen Netzwerk erreichbar unter `http://<Host-IP>:7125` — nicht ins Internet freigeben
+Interoperability research under §69e UrhG — private, non-commercial use only.
-- `.env` enthält Drucker-Credentials — nicht öffentlich teilen
-- Die Credentials sind druckerspezifisch und haben keinen Zugang zu Anycubic-Cloud-Diensten
-
----
-
-## Lizenz & Rechtliches
-
-Dieses Projekt entstand durch Interoperabilitätsforschung gem. §69e UrhG.  
-Ausschließlich für private, nicht-kommerzielle Nutzung.

VERSION

@@ -1 +1 @@
-0.9.1-beta15
+0.9.2

config.ini.example

@@ -0,0 +1,34 @@
+# KX-Bridge Konfigurationsdatei
+# Kopiere diese Datei nach config.ini und trage deine Werte ein:
+#   cp config.ini.example config.ini
+#
+# Credentials mit extract_credentials.exe (Windows) oder
+# extract_credentials (Linux) aus dem laufenden AnycubicSlicerNext auslesen.
+
+[connection]
+# IP-Adresse des Druckers im lokalen Netzwerk
+printer_ip   = 192.168.x.x
+
+# MQTT-Port (Anycubic Kobra X Standard: 9883)
+mqtt_port    = 9883
+
+# MQTT-Zugangsdaten (druckerspezifisch, beginnt mit "user")
+username     = userXXXXXXXXXX
+password     = XXXXXXXXXXXXXXX
+
+# Geräte-ID (32-stelliger Hex-String, druckerspezifisch)
+device_id    = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# Modell-ID (Kobra X Standard: 20030)
+mode_id      = 20030
+
+[print]
+# Standard-AMS-Slot für Einfarbdruck (auto = alle belegten Slots, 0-3 = fixer Slot)
+default_ams_slot = auto
+
+# Auto-Leveling vor jedem Druck (1 = an, 0 = aus)
+auto_leveling    = 1
+
+[bridge]
+# Poll-Intervall in Sekunden
+poll_interval    = 3

config_loader.py

@@ -0,0 +1,143 @@
+"""
+config_loader.py – lädt Verbindungsparameter aus config/config.ini (primär)
+oder .env (Fallback / Migration).
+Umgebungsvariablen haben immer Vorrang.
+"""
+import os
+import sys
+import pathlib
+import configparser
+
+_BASE = pathlib.Path(sys.executable).parent if getattr(sys, "frozen", False) else pathlib.Path(__file__).parent
+
+CONFIG_SECTION_CONNECTION = "connection"
+CONFIG_SECTION_PRINT      = "print"
+CONFIG_SECTION_BRIDGE     = "bridge"
+
+
+def _find_config_file() -> pathlib.Path | None:
+    for base in (_BASE, _BASE.parent):
+        p = base / "config" / "config.ini"
+        if p.is_file():
+            return p
+    return None
+
+
+def _find_env_file() -> pathlib.Path | None:
+    for base in (_BASE, _BASE.parent):
+        p = base / ".env"
+        if p.is_file():
+            return p
+    return None
+
+
+def _load_env_file(path: pathlib.Path):
+    """Lädt .env-Datei als Fallback – setzt nur Keys die noch nicht in os.environ sind."""
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            key, _, val = line.partition("=")
+            key = key.strip()
+            val = val.strip()
+            if key and key not in os.environ:
+                os.environ[key] = val
+
+
+def _load_config_file(path: pathlib.Path):
+    """Lädt config.ini und setzt Keys in os.environ (nur wenn nicht bereits gesetzt)."""
+    cfg = configparser.ConfigParser()
+    cfg.read(path, encoding="utf-8")
+
+    mapping = {
+        "PRINTER_IP":       (CONFIG_SECTION_CONNECTION, "printer_ip"),
+        "MQTT_PORT":        (CONFIG_SECTION_CONNECTION, "mqtt_port"),
+        "MQTT_USERNAME":    (CONFIG_SECTION_CONNECTION, "username"),
+        "MQTT_PASSWORD":    (CONFIG_SECTION_CONNECTION, "password"),
+        "MODE_ID":          (CONFIG_SECTION_CONNECTION, "mode_id"),
+        "DEVICE_ID":        (CONFIG_SECTION_CONNECTION, "device_id"),
+        "DEFAULT_AMS_SLOT": (CONFIG_SECTION_PRINT,      "default_ams_slot"),
+        "AUTO_LEVELING":    (CONFIG_SECTION_PRINT,      "auto_leveling"),
+    }
+    for env_key, (section, option) in mapping.items():
+        if env_key not in os.environ:
+            try:
+                val = cfg.get(section, option)
+                if val:
+                    os.environ[env_key] = val
+            except (configparser.NoSectionError, configparser.NoOptionError):
+                pass
+
+
+def migrate_env_to_config(env_path: pathlib.Path, config_path: pathlib.Path):
+    """Einmalige Migration: .env → config.ini anlegen."""
+    env_vals: dict[str, str] = {}
+    with open(env_path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#") or "=" not in line:
+                continue
+            k, _, v = line.partition("=")
+            env_vals[k.strip()] = v.strip()
+
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    cfg = configparser.ConfigParser()
+    cfg[CONFIG_SECTION_CONNECTION] = {
+        "printer_ip": env_vals.get("PRINTER_IP", ""),
+        "mqtt_port":  env_vals.get("MQTT_PORT",  "9883"),
+        "username":   env_vals.get("MQTT_USERNAME", ""),
+        "password":   env_vals.get("MQTT_PASSWORD", ""),
+        "mode_id":    env_vals.get("MODE_ID",    ""),
+        "device_id":  env_vals.get("DEVICE_ID",  ""),
+    }
+    cfg[CONFIG_SECTION_PRINT] = {
+        "default_ams_slot": env_vals.get("DEFAULT_AMS_SLOT", "auto"),
+        "auto_leveling":    env_vals.get("AUTO_LEVELING",    "1"),
+    }
+    cfg[CONFIG_SECTION_BRIDGE] = {
+        "poll_interval": "3",
+    }
+    with open(config_path, "w", encoding="utf-8") as f:
+        f.write("# KX-Bridge Konfigurationsdatei\n")
+        f.write("# Automatisch migriert aus .env\n\n")
+        cfg.write(f)
+
+
+def find_config_path() -> pathlib.Path:
+    """Gibt den Pfad zur config.ini zurück (auch wenn sie noch nicht existiert)."""
+    for base in (_BASE, _BASE.parent):
+        config_dir = base / "config"
+        if config_dir.is_dir():
+            return config_dir / "config.ini"
+    return _BASE / "config" / "config.ini"
+
+
+# ─── Laden ───────────────────────────────────────────────────────────────────
+
+_config_path = _find_config_file()
+_env_path    = _find_env_file()
+
+if _config_path:
+    _load_config_file(_config_path)
+elif _env_path:
+    # Kein config.ini vorhanden → aus .env migrieren
+    _target = find_config_path()
+    migrate_env_to_config(_env_path, _target)
+    _load_config_file(_target)
+    _config_path = _target
+
+
+def get(key: str, default: str = "") -> str:
+    return os.environ.get(key, default)
+
+
+# Häufig verwendete Shortcuts
+PRINTER_IP       = get("PRINTER_IP",       "")
+MQTT_PORT        = int(get("MQTT_PORT",    "9883"))
+USERNAME         = get("MQTT_USERNAME",    "")
+PASSWORD         = get("MQTT_PASSWORD",    "")
+MODE_ID          = get("MODE_ID",          "")
+DEVICE_ID        = get("DEVICE_ID",        "")
+DEFAULT_AMS_SLOT = get("DEFAULT_AMS_SLOT", "auto")
+AUTO_LEVELING    = int(get("AUTO_LEVELING","1"))

docker-compose.yml

@@ -2,9 +2,9 @@ services:
   kx-bridge:
     image: kx-bridge:latest
     build: .
-    env_file: .env
     volumes:
-      - ./.env:/app/.env
+      - ./config:/app/config
+      - ./.env:/app/.env:ro
     ports:
       - "7125:7125"
     restart: unless-stopped

env_loader.py

@@ -40,9 +40,11 @@ def get(key: str, default: str = "") -> str:
 
 
 # Häufig verwendete Shortcuts
-PRINTER_IP   = get("PRINTER_IP",   "")
+PRINTER_IP       = get("PRINTER_IP",       "")
-MQTT_PORT    = int(get("MQTT_PORT", "9883"))
+MQTT_PORT        = int(get("MQTT_PORT", "9883"))
-USERNAME     = get("MQTT_USERNAME", "")
+USERNAME         = get("MQTT_USERNAME",    "")
-PASSWORD     = get("MQTT_PASSWORD", "")
+PASSWORD         = get("MQTT_PASSWORD",    "")
-MODE_ID      = get("MODE_ID",      "")
+MODE_ID          = get("MODE_ID",          "")
-DEVICE_ID    = get("DEVICE_ID",    "")
+DEVICE_ID        = get("DEVICE_ID",        "")
+DEFAULT_AMS_SLOT = get("DEFAULT_AMS_SLOT", "auto")
+AUTO_LEVELING    = int(get("AUTO_LEVELING", "1"))

kobrax_client.py

@@ -16,7 +16,9 @@ Verwendung:
   client.disconnect()
 """
 
+import hashlib
 import json
+import logging
 import os
 import socket
 import ssl
@@ -28,6 +30,8 @@ from datetime import datetime
 
 import env_loader
 
+log = logging.getLogger("kobrax.mqtt")
+
 _SCRIPT_DIR = os.path.dirname(sys.executable) if getattr(sys, "frozen", False) else os.path.dirname(os.path.abspath(__file__))
 CERT_FILE = os.path.join(_SCRIPT_DIR, "anycubic_slicer.crt")
 KEY_FILE  = os.path.join(_SCRIPT_DIR, "anycubic_slicer.key")
@@ -119,6 +123,13 @@ class KobraXClient:
         # Optional callbacks: topic_suffix → callable(payload_dict)
         self.callbacks: dict[str, callable] = {}
 
+        # Dedup: last hash per topic suffix to suppress repeated identical messages
+        self._last_rx_hash: dict[str, str] = {}
+        # Fields that change every tick and should be stripped before dedup-hashing
+        _VOLATILE = {"timestamp", "msgid", "progress", "curr_layer",
+                     "curr_nozzle_temp", "curr_hotbed_temp",
+                     "target_nozzle_temp", "target_hotbed_temp"}
+
     # -- Topics --------------------------------------------------------------
 
     def _pub_topic(self, msg_type: str) -> str:
@@ -144,18 +155,19 @@ class KobraXClient:
 
         raw        = socket.create_connection((self.host, self.port), timeout=5)
         self._sock = ctx.wrap_socket(raw)
-        print(f"[kobrax] TLS: {self._sock.cipher()[0]}")
+        log.info("TLS connected  cipher=%s", self._sock.cipher()[0])
 
         self._sock.sendall(_build_connect(self.client_id, self.username, self.password))
         self._sock.settimeout(3)
         r = self._sock.recv(64)
         if len(r) < 4 or r[0] != 0x20 or r[3] != 0:
             raise RuntimeError(f"CONNACK failed: {r.hex()}")
-        print(f"[kobrax] CONNACK rc=0")
+        log.info("CONNACK rc=0")
 
         self._sock.settimeout(0.2)
         self._buf = b""
         self._subscribe(self._sub_topic())
+        log.debug("MQTT connected to %s:%s", self.host, self.port)
 
     def connect(self):
         self._do_connect()
@@ -172,7 +184,7 @@ class KobraXClient:
             pass
 
     def _reconnect(self):
-        print("[kobrax] Verbindung verloren – reconnect…")
+        log.warning("Verbindung verloren – reconnect…")
         try:
             self._sock.close()
         except Exception:
@@ -180,10 +192,10 @@ class KobraXClient:
         for delay in [2, 4, 8, 15, 30]:
             try:
                 self._do_connect()
-                print("[kobrax] Reconnect erfolgreich")
+                log.info("Reconnect erfolgreich")
                 return True
             except Exception as e:
-                print(f"[kobrax] Reconnect fehlgeschlagen ({e}), warte {delay}s…")
+                log.warning("Reconnect fehlgeschlagen (%s), warte %ss…", e, delay)
                 time.sleep(delay)
         return False
 
@@ -192,7 +204,7 @@ class KobraXClient:
             pid = self._pid
             self._pid += 1
             self._sock.sendall(_build_subscribe(topic, pid))
-        print(f"[kobrax] SUB {topic}")
+        log.info("SUB %s", topic)
 
     # -- Read loop -----------------------------------------------------------
 
@@ -227,7 +239,7 @@ class KobraXClient:
                 continue
             except Exception as e:
                 if self._running:
-                    print(f"[kobrax] reader error: {e}")
+                    log.warning("reader error: %s", e)
                     if not self._reconnect():
                         break
                     last_ping = time.time()
@@ -266,9 +278,40 @@ class KobraXClient:
 
         self._buf = buf[idx:]
 
+    def _dedup_hash(self, suffix: str, payload: dict) -> str:
+        """Hash payload ignoring volatile per-tick fields for dedup check."""
+        stable = {k: v for k, v in payload.items()
+                  if k not in {"timestamp", "msgid", "progress", "curr_layer",
+                               "curr_nozzle_temp", "curr_hotbed_temp",
+                               "target_nozzle_temp", "target_hotbed_temp"}}
+        return hashlib.md5(json.dumps(stable, sort_keys=True).encode(), usedforsecurity=False).hexdigest()
+
     def _dispatch(self, topic: str, payload: dict):
-        # Resolve by report topic suffix (e.g. "info/report")
         suffix = "/".join(topic.split("/")[-2:])
+
+        # Structured RX log with dedup suppression
+        h = self._dedup_hash(suffix, payload)
+        is_dup = self._last_rx_hash.get(suffix) == h
+        self._last_rx_hash[suffix] = h
+        if is_dup:
+            log.debug("RX [dup] %-25s  state=%-12s", suffix, payload.get("state", ""))
+        else:
+            data = payload.get("data") or {}
+            state = payload.get("state", "")
+            if "progress" in data:
+                log.info("RX %-25s  state=%-12s  progress=%s%%  layer=%s/%s",
+                         suffix, state, data["progress"],
+                         data.get("curr_layer", "?"), data.get("total_layers", "?"))
+            elif "curr_nozzle_temp" in data:
+                log.info("RX %-25s  nozzle=%s°C/%s°C  bed=%s°C/%s°C",
+                         suffix,
+                         data["curr_nozzle_temp"], data.get("target_nozzle_temp", 0),
+                         data.get("curr_hotbed_temp", "?"), data.get("target_hotbed_temp", 0))
+            else:
+                log.info("RX %-25s  state=%-12s  data=%s",
+                         suffix, state, json.dumps(payload.get("data"), ensure_ascii=False)[:120])
+
+        # Resolve by report topic suffix (e.g. "info/report")
         if suffix in self._pending_report:
             entry = self._pending_report[suffix]
             entry["result"] = payload
@@ -282,19 +325,18 @@ class KobraXClient:
             entry["event"].set()
 
         # User callbacks by topic suffix (last two path components)
-        suffix = "/".join(topic.split("/")[-2:])
         if suffix in self.callbacks:
             try:
                 self.callbacks[suffix](payload)
             except Exception as e:
-                print(f"[kobrax] callback error for {suffix}: {e}")
+                log.error("callback error for %s: %s", suffix, e)
 
         # Generic wildcard callback
         if "*" in self.callbacks:
             try:
                 self.callbacks["*"](topic, payload)
             except Exception as e:
-                print(f"[kobrax] wildcard callback error: {e}")
+                log.error("wildcard callback error: %s", e)
 
     # -- Publish + request/response ------------------------------------------
 
@@ -322,11 +364,14 @@ class KobraXClient:
             report_registered = True
 
         topic = self._pub_topic(msg_type)
+        log.info("TX %-25s  action=%-12s  data=%s",
+                 f"{msg_type}/request", action,
+                 json.dumps(data, ensure_ascii=False)[:120] if data else "null")
         try:
             with self._lock:
                 self._sock.sendall(_build_publish(topic, payload))
         except Exception as e:
-            print(f"[kobrax] send error: {e}, reconnecting…")
+            log.error("send error: %s, reconnecting…", e)
             self._pending_msgid.pop(msgid, None)
             if report_registered:
                 self._pending_report.pop(report_key, None)
@@ -367,11 +412,14 @@ class KobraXClient:
             "data":      data,
         }, separators=(",", ":"))
         topic = self._web_topic(msg_type)
+        log.info("TX(web) %-23s  action=%-12s  data=%s",
+                 f"{msg_type}/request", action,
+                 json.dumps(data, ensure_ascii=False)[:120] if data else "null")
         try:
             with self._lock:
                 self._sock.sendall(_build_publish(topic, payload))
         except Exception as e:
-            print(f"[kobrax] web send error: {e}")
+            log.error("web send error: %s", e)
 
     # -- High-level commands -------------------------------------------------
 

kobrax_moonraker_bridge.py

@@ -11,7 +11,10 @@ OrcaSlicer-Konfiguration:
 """
 
 import argparse
-import env_loader
+try:
+    import config_loader as env_loader
+except ImportError:
+    import env_loader
 import asyncio
 import hashlib
 import json
@@ -49,10 +52,37 @@ except ImportError:
     print("Fehler: aiohttp nicht installiert. Bitte: pip install aiohttp")
     sys.exit(1)
 
-logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(levelname)s %(message)s",
+logging.basicConfig(level=logging.INFO,
+                    format="[%(asctime)s] %(levelname)-5s %(name)s: %(message)s",
                     datefmt="%H:%M:%S")
 log = logging.getLogger("bridge")
 
+# Ring-Buffer für Browser-Log-Stream (letzte 200 Einträge)
+import collections as _collections
+_log_buffer: "_collections.deque[dict]" = _collections.deque(maxlen=500)
+_log_sse_queues: "list[asyncio.Queue]" = []
+
+class _BrowserLogHandler(logging.Handler):
+    """Sendet Log-Records in den Ring-Buffer und alle offenen SSE-Queues."""
+    _fmt = logging.Formatter(datefmt="%H:%M:%S")
+
+    def emit(self, record: logging.LogRecord):
+        entry = {
+            "ts":    self._fmt.formatTime(record, "%H:%M:%S"),
+            "lvl":   record.levelname,
+            "name":  record.name,
+            "msg":   record.getMessage(),
+        }
+        _log_buffer.append(entry)
+        for q in list(_log_sse_queues):
+            try:
+                q.put_nowait(entry)
+            except Exception:
+                pass
+
+_browser_handler = _BrowserLogHandler()
+logging.getLogger().addHandler(_browser_handler)
+
 KOBRA_TO_KLIPPER_STATE = {
     "free":          "standby",
     "busy":          "printing",
@@ -77,6 +107,23 @@ MOONRAKER_VERSION = "v0.9.3-1"
 KLIPPER_VERSION   = "v0.12.0-1"
 
 
+def _parse_gcode_estimated_time(data: bytes) -> int:
+    """Liest '; estimated printing time (normal mode) = Xh Ym Zs' aus GCode-Header.
+    Gibt Sekunden zurück, 0 wenn nicht gefunden. Sucht nur in den ersten 8KB."""
+    import re
+    header = data[:8192].decode("utf-8", errors="ignore")
+    m = re.search(r";\s*estimated printing time \(normal mode\)\s*=\s*(.*)", header)
+    if not m:
+        return 0
+    parts = re.findall(r"(\d+)\s*([hms])", m.group(1))
+    secs = 0
+    for val, unit in parts:
+        if unit == "h":   secs += int(val) * 3600
+        elif unit == "m": secs += int(val) * 60
+        elif unit == "s": secs += int(val)
+    return secs
+
+
 class KobraXBridge:
     def __init__(self, client: KobraXClient, args=None):
         self.client = client
@@ -91,6 +138,7 @@ class KobraXBridge:
             "print_state":        "standby",
             "kobra_state":        "free",
             "filename":           "",
+            "slicer_time":        0,
             "progress":           0.0,
             "print_duration":     0,
             "remain_time":        0,
@@ -105,6 +153,7 @@ class KobraXBridge:
             "light_brightness":   80,
             "taskid":             "-1",
             "print_speed_mode":   2,
+            "connection_error":   "",
         }
         self._ams_slots: list[dict] = []
         self._ams_loaded_slot: int = -1
@@ -112,7 +161,7 @@ class KobraXBridge:
         self._serve_dir = tempfile.TemporaryDirectory(prefix="kobrax_serve_")
         self._serve_dir_path: str = self._serve_dir.name
 
-        self._thumbnail_b64: str = ""  # base64-PNG aus file/report
+        self._thumbnail_b64: str = ""
 
         # Register MQTT push callbacks
         client.callbacks["tempature/report"]      = self._on_temp
@@ -226,6 +275,74 @@ class KobraXBridge:
             log.info(f"AMS-Slots empfangen: {len(slots)}, loaded_slot={self._ams_loaded_slot}")
             self._push_status_update()
 
+    # OrcaSlicer filament preset IDs (MoonrakerPrinterAgent.cpp mapping)
+    _TRAY_INFO_IDX = {
+        "PLA":      "OGFL99", "PLA-CF":   "OGFL98", "PLA SILK": "OGFL96",
+        "PETG":     "OGFG99", "PETG-CF":  "OGFG98",
+        "ABS":      "OGFB99", "ASA":      "OGFB98",
+        "TPU":      "OGFT99", "PA":       "OGFP99", "PA-CF":    "OGFP98",
+        "PC":       "OGFC99", "HIPS":     "OGFH99", "PVA":      "OGFV99",
+    }
+
+    def _build_lane_data(self) -> dict:
+        """Baut BBL-AMS-JSON für OrcaSlicer DevFilaSystemParser::ParseV1_0."""
+        slots = self._ams_slots
+        total = len(slots)
+        if total == 0:
+            return {"ams": [], "ams_exist_bits": "0", "tray_exist_bits": "0"}
+
+        ams_count = (total + 3) // 4
+        ams_exist_bits = 0
+        tray_exist_bits = 0
+        ams_array = []
+
+        for ams_id in range(ams_count):
+            ams_exist_bits |= (1 << ams_id)
+            tray_array = []
+            max_slot = min(3, total - ams_id * 4 - 1)
+            for slot_id in range(max_slot + 1):
+                slot_index = ams_id * 4 + slot_id
+                slot = slots[slot_index] if slot_index < total else {}
+                occupied = slot.get("status") == 5
+
+                if occupied:
+                    tray_exist_bits |= (1 << slot_index)
+                    color_raw = slot.get("color", [255, 255, 255])
+                    if isinstance(color_raw, list) and len(color_raw) >= 3:
+                        color_hex = "{:02X}{:02X}{:02X}FF".format(
+                            int(color_raw[0]), int(color_raw[1]), int(color_raw[2])
+                        )
+                    elif isinstance(color_raw, str) and len(color_raw) >= 6:
+                        color_hex = color_raw[:6].upper() + "FF"
+                    else:
+                        color_hex = "FFFFFFFF"
+                    material = slot.get("type", "PLA").upper()
+                    tray_info_idx = self._TRAY_INFO_IDX.get(material, "OGFL99")
+                    tray_array.append({
+                        "id":           str(slot_id),
+                        "tag_uid":      "0000000000000000",
+                        "tray_info_idx": tray_info_idx,
+                        "tray_type":    material,
+                        "tray_color":   color_hex,
+                    })
+                else:
+                    tray_array.append({
+                        "id":                str(slot_id),
+                        "tag_uid":           "0000000000000000",
+                        "tray_info_idx":     "",
+                        "tray_type":         "",
+                        "tray_color":        "00000000",
+                        "tray_slot_placeholder": "1",
+                    })
+
+            ams_array.append({"id": str(ams_id), "info": "0002", "tray": tray_array})
+
+        return {
+            "ams":             ams_array,
+            "ams_exist_bits":  format(ams_exist_bits, "X"),
+            "tray_exist_bits": format(tray_exist_bits, "X"),
+        }
+
     # -------------------------------------------------------------------------
     # WebSocket push
     # -------------------------------------------------------------------------
@@ -408,6 +525,9 @@ class KobraXBridge:
         file_md5  = hashlib.md5(file_data).hexdigest()
         file_size = len(file_data)
 
+        # Slicer-Zeitschätzung aus GCode-Header auslesen
+        self._state["slicer_time"] = _parse_gcode_estimated_time(file_data)
+
         # Datei auf Disk ablegen (temp-Verzeichnis) damit Drucker sie per HTTP abrufen kann
         safe_name = os.path.basename(remote_filename)  # keine Pfad-Traversal
         serve_path = os.path.join(self._serve_dir_path, safe_name)
@@ -458,7 +578,19 @@ class KobraXBridge:
         }, status=201)
 
     def _start_print(self, filename: str, url: str = "", md5: str = "", filesize: int = 0):
-        loaded = [(i, s) for i, s in enumerate(self._ams_slots) if s.get("status") == 5]
+        default_slot = getattr(self._args, "default_ams_slot", "auto")
+        all_loaded = [(i, s) for i, s in enumerate(self._ams_slots) if s.get("status") == 5]
+        if default_slot != "auto":
+            try:
+                slot_idx = int(default_slot)
+                loaded = [(i, s) for i, s in all_loaded if i == slot_idx]
+                if not loaded:
+                    log.warning(f"Standard-Slot {slot_idx} ist leer – fallback auf Auto")
+                    loaded = all_loaded
+            except ValueError:
+                loaded = all_loaded
+        else:
+            loaded = all_loaded
         use_ams = len(loaded) > 0
         ams_box_mapping = [
             {
@@ -471,6 +603,7 @@ class KobraXBridge:
             for i, s in loaded
         ]
         log.info(f"AMS-Slots: {len(loaded)}/{len(self._ams_slots)} belegt → {[i for i,_ in loaded]}")
+        auto_leveling = getattr(self._args, "auto_leveling", 1)
         payload = {
             "taskid":       "-1",
             "url":          url,
@@ -485,7 +618,7 @@ class KobraXBridge:
                 "ams_box_mapping": ams_box_mapping,
             },
             "task_settings": {
-                "auto_leveling":            1,
+                "auto_leveling":            auto_leveling,
                 "vibration_compensation":   0,
                 "flow_calibration":         0,
                 "dry_mode":                 0,
@@ -519,16 +652,34 @@ class KobraXBridge:
         log.info(f"Druck starten: {filename}")
 
         # AMS-Mapping aus gecachtem State — leere Slots (status != 5) überspringen
+        default_slot = getattr(self._args, "default_ams_slot", "auto")
         ams_box_mapping = []
         for i, slot in enumerate(self._ams_slots):
             if slot.get("status") != 5:
                 log.info(f"AMS-Slot {i} leer (status={slot.get('status')}) – übersprungen")
                 continue
+            if default_slot != "auto":
+                try:
+                    if i != int(default_slot):
+                        continue
+                except ValueError:
+                    pass
             ams_box_mapping.append({
                 "slot_index": i,
                 "material_type": slot.get("type", "PLA"),
                 "color": slot.get("color", [255, 255, 255]),
             })
+        # Fallback auf alle belegten Slots wenn gewählter Slot leer war
+        if default_slot != "auto" and not ams_box_mapping:
+            log.warning(f"Standard-Slot {default_slot} leer – fallback auf alle belegten Slots")
+            for i, slot in enumerate(self._ams_slots):
+                if slot.get("status") != 5:
+                    continue
+                ams_box_mapping.append({
+                    "slot_index": i,
+                    "material_type": slot.get("type", "PLA"),
+                    "color": slot.get("color", [255, 255, 255]),
+                })
 
         use_ams = len(ams_box_mapping) > 0
 
@@ -758,7 +909,7 @@ canvas.tchart{width:100%;height:60px;display:block;border-radius:6px;background:
 
 /* ── CONSOLE ── */
 .console{background:#0a0a0e;border-radius:8px;padding:10px;font-family:var(--mono);
-  font-size:11px;color:#8888aa;height:160px;overflow-y:auto;line-height:1.6}
+  font-size:11px;color:#8888aa;overflow-y:auto;line-height:1.6}
 .console .ts{color:#444;margin-right:6px}
 .console .msg-info{color:#8888aa}
 .console .msg-ok{color:var(--ok)}
@@ -858,9 +1009,11 @@ nav.bottom-nav{display:none;position:fixed;bottom:0;left:0;right:0;
 </head>
 <body>
 
+<div id="conn-error-banner" style="display:none;background:#c0392b;color:#fff;padding:10px 18px;font-size:14px;text-align:center;position:sticky;top:0;z-index:999;"></div>
+
 <header>
   <div class="logo">⬡ KX-Bridge</div>
-  <div class="hname" id="h-pname">Anycubic Kobra X</div>
+  <div class="hname" id="h-pname">Anycubic Kobra X</div><span id="h-version" style="font-size:11px;opacity:.5;margin-left:6px"></span>
   <div class="hbadge" id="h-badge"><span class="dot"></span><span id="h-state">Standby</span></div>
   <button class="theme-btn" onclick="toggleTheme()">☀ / ☾</button>
   <button class="theme-btn" onclick="toggleLang()" id="lang-btn">EN</button>
@@ -905,6 +1058,24 @@ nav.bottom-nav{display:none;position:fixed;bottom:0;left:0;right:0;
       </div>
     </div>
 
+    <div>
+      <div class="modal-section" id="modal-sec-print">Druckeinstellungen</div>
+      <div class="modal-field">
+        <label id="lbl-default-slot">Standard-Slot (Einfarbdruck)</label>
+        <select id="s-default-slot">
+          <option value="auto" id="opt-slot-auto">Auto (alle belegten Slots)</option>
+          <option value="0" id="opt-slot-0">Slot 1</option>
+          <option value="1" id="opt-slot-1">Slot 2</option>
+          <option value="2" id="opt-slot-2">Slot 3</option>
+          <option value="3" id="opt-slot-3">Slot 4</option>
+        </select>
+      </div>
+      <div class="modal-field" style="flex-direction:row;align-items:center;gap:10px">
+        <input type="checkbox" id="s-auto-leveling" style="width:auto;margin:0">
+        <label id="lbl-auto-leveling" style="margin:0;cursor:pointer" for="s-auto-leveling">Auto-Leveling vor Druck</label>
+      </div>
+    </div>
+
     <div>
       <div class="modal-section" id="modal-sec-poll">Poll-Intervall</div>
       <div class="poll-btns">
@@ -924,6 +1095,7 @@ nav.bottom-nav{display:none;position:fixed;bottom:0;left:0;right:0;
       <button class="btn btn-sm btn-accent" id="btn-update-apply" style="display:none;margin-top:8px" onclick="applyUpdate()">
         <span id="lbl-update-apply">Jetzt installieren</span>
       </button>
+      <div id="update-changelog" style="display:none;margin-top:10px;background:var(--raised);border-radius:6px;padding:10px;font-size:11px;font-family:var(--mono);color:var(--txt2);white-space:pre-wrap;max-height:180px;overflow-y:auto;line-height:1.6"></div>
     </div>
 
     <button class="modal-save" onclick="saveSettings()" id="btn-save-settings">Speichern &amp; Neustart</button>
@@ -934,8 +1106,8 @@ nav.bottom-nav{display:none;position:fixed;bottom:0;left:0;right:0;
   <nav class="sidebar">
     <button class="nav-btn active" onclick="showPanel('dashboard')" id="nb-dashboard">
       <span class="nav-icon">⊞</span><span class="nav-text">Dashboard</span></button>
-    <button class="nav-btn" onclick="showPanel('console')" id="nb-console">
+    <button class="nav-btn" onclick="showPanel('console');clearLogBadge()" id="nb-console">
-      <span class="nav-icon">≡</span><span class="nav-text">Konsole</span></button>
+      <span class="nav-icon">≡</span><span class="nav-text">Konsole</span><span id="log-badge" style="display:none;margin-left:4px;background:var(--err);color:#fff;border-radius:10px;font-size:10px;padding:1px 5px;font-weight:700"></span></button>
   </nav>
 
   <main>
@@ -977,6 +1149,9 @@ nav.bottom-nav{display:none;position:fixed;bottom:0;left:0;right:0;
             <span id="d-remain" style="color:var(--acc)">–</span>
             <span id="d-layers" class="layer-badge">–</span>
           </div>
+          <div class="meta-row" style="margin-top:4px;font-size:0.82em;opacity:0.7" id="d-slicer-row">
+            <span id="d-slicer-label"></span><span id="d-slicer-time" style="margin-left:4px">–</span>
+          </div>
           <div class="fname" id="d-fname" title="" style="margin-top:6px">–</div>
           <div class="ctrl-btns" id="d-ctrl-btns" style="margin-top:12px">
             <button class="btn btn-pause btn-sm" id="d-btn-pause" onclick="printAction('pause')">⏸ Pause</button>
@@ -1128,8 +1303,21 @@ nav.bottom-nav{display:none;position:fixed;bottom:0;left:0;right:0;
     <!-- ═══ CONSOLE ═══ -->
     <div class="panel" id="panel-console">
       <div class="card">
-        <div class="card-title"><span>≡</span> <span id="ptitle-console">Ereignis-Log</span></div>
+        <div class="card-title" style="display:flex;justify-content:space-between;align-items:center">
-        <div class="console" id="console-log"></div>
+          <span><span>≡</span> <span id="ptitle-console">Ereignis-Log</span></span>
+          <a id="btn-log-dl" href="/api/log/download" download="kx-bridge.log"
+             style="font-size:12px;padding:4px 10px;background:var(--raised);border-radius:6px;color:var(--txt2);text-decoration:none">⬇ Download</a>
+        </div>
+        <div style="display:flex;gap:8px;margin-bottom:8px;flex-wrap:wrap;align-items:center">
+          <input id="log-filter" type="text" placeholder="Filter…"
+            oninput="renderLog()"
+            style="flex:1;min-width:120px;padding:5px 10px;background:var(--raised);border:1px solid var(--border);border-radius:6px;color:var(--txt);font-size:12px;font-family:var(--mono)">
+          <button id="btn-autoscroll" onclick="toggleAutoScroll()"
+            style="font-size:12px;padding:5px 10px;border-radius:6px;border:1px solid var(--border);background:var(--accent);color:#fff;cursor:pointer;white-space:nowrap">⬇ Auto</button>
+          <button onclick="consoleLogs=[];renderLog()"
+            style="font-size:12px;padding:5px 10px;border-radius:6px;border:1px solid var(--border);background:var(--raised);color:var(--txt2);cursor:pointer">✕ Clear</button>
+        </div>
+        <div class="console" id="console-log" style="height:calc(100vh - 220px);min-height:200px" onscroll="onLogScroll()"></div>
       </div>
     </div>
   </main>
@@ -1137,7 +1325,7 @@ nav.bottom-nav{display:none;position:fixed;bottom:0;left:0;right:0;
 
 <nav class="bottom-nav">
   <button class="bnav-btn active" onclick="showPanel('dashboard')" id="bnb-dashboard"><span class="bnav-icon">⊞</span>Dashboard</button>
-  <button class="bnav-btn" onclick="showPanel('console')" id="bnb-console"><span class="bnav-icon">≡</span>Log</button>
+  <button class="bnav-btn" onclick="showPanel('console');clearLogBadge()" id="bnb-console"><span class="bnav-icon">≡</span>Log<span id="log-badge-bot" style="display:none;margin-left:3px;background:var(--err);color:#fff;border-radius:10px;font-size:10px;padding:1px 4px;font-weight:700"></span></button>
 </nav>
 
 <script>
@@ -1164,7 +1352,7 @@ var LANG_DE={
   header_status_standby:'Bereit',header_status_printing:'Druckt',header_status_complete:'Fertig',header_status_error:'Fehler',
   kobra_free:'Bereit',kobra_busy:'Beschäftigt',kobra_printing:'Druckt',kobra_preheating:'Aufheizen',kobra_auto_leveling:'Nivellierung',kobra_checking:'Prüfung',kobra_updated:'Aktualisierung',kobra_init:'Initialisierung',kobra_pausing:'Pausiert...',kobra_paused:'Pausiert',kobra_resuming:'Fortsetzen...',kobra_resumed:'Fortgesetzt',kobra_stopping:'Stoppt...',kobra_stoped:'Gestoppt',kobra_finished:'Abgeschlossen',kobra_failed:'Fehler',kobra_canceled:'Abgebrochen',kobra_offline:'Offline',
   nav_dashboard:'Dashboard',nav_print:'Druck',nav_temps:'Temperaturen',nav_motion:'Achsen',nav_ams:'AMS',nav_extras:'Licht / Lüfter',nav_console:'Konsole',
-  card_progress:'Fortschritt',card_temps:'Temperaturen',card_light_fan:'Lüfter',card_speed:'Druckgeschwindigkeit',card_cam:'Kamera',lbl_elapsed:'Verstrichen',lbl_remaining:'verbleibend',
+  card_progress:'Fortschritt',card_temps:'Temperaturen',card_light_fan:'Lüfter',card_speed:'Druckgeschwindigkeit',card_cam:'Kamera',lbl_elapsed:'Verstrichen',lbl_remaining:'verbleibend',lbl_slicer_time:'Slicer-Schätzung:',
   speed_silent:'🐢 Leise',speed_normal:'⚡ Normal',speed_sport:'🚀 Sport',
   lbl_light:'💡 Licht',lbl_feed:'Einziehen',lbl_unload:'Ausziehen',
   cam_placeholder:'📷 Kamera nicht gestartet',btn_cam_start:'▶ Kamera',btn_cam_stop:'◼ Kamera',
@@ -1179,18 +1367,20 @@ var LANG_DE={
   panel_console_title:'Ereignis-Log',
   log_light_on:'Licht an',log_light_off:'Licht aus',log_fan:'Lüfter →',log_nozzle:'Nozzle →',log_bed:'Bett →',log_axis:'Achse',log_home:'Home',log_home_all:'Home All',log_cam_start:'Kamera gestartet:',log_cam_stop:'Kamera gestoppt',log_poll_error:'Poll-Fehler:',log_error:'Fehler:',
   confirm_cancel:'Druck wirklich abbrechen?',
-  settings_title:'Einstellungen',settings_connection:'Verbindung',settings_poll:'Poll-Intervall',settings_version:'Version',
+  settings_title:'Einstellungen',settings_connection:'Verbindung',settings_print:'Druckeinstellungen',settings_poll:'Poll-Intervall',settings_version:'Version',
   settings_save:'Speichern & Neustart',settings_printer_ip:'Drucker-IP',settings_mqtt_port:'MQTT-Port',
   settings_username:'MQTT-Benutzername',settings_password:'MQTT-Passwort',settings_device_id:'Device-ID',settings_mode_id:'Mode-ID',hint_ip_no_port:'Nur IP-Adresse, kein Port (z.B. 192.168.1.102)',
+  settings_default_slot:'Standard-Slot (Einfarbdruck)',settings_slot_auto:'Auto (alle belegten Slots)',settings_auto_leveling:'Auto-Leveling vor Druck',
   update_check:'Auf Updates prüfen',update_checking:'Prüfe...',update_available:'verfügbar',update_none:'Bereits aktuell',
   update_apply:'Jetzt installieren',update_applying:'Lade herunter...',update_restarting:'Starte neu...',update_error:'Fehler',
-  btn_connect:'⚡ Verbinden',btn_disconnect:'✕ Trennen'
+  btn_connect:'⚡ Verbinden',btn_disconnect:'✕ Trennen',
+  lbl_conn_error:'Verbindungsfehler:'
 };
 var LANG_EN={
   header_status_standby:'Ready',header_status_printing:'Printing',header_status_complete:'Complete',header_status_error:'Error',
   kobra_free:'Ready',kobra_busy:'Busy',kobra_printing:'Printing',kobra_preheating:'Preheating',kobra_auto_leveling:'Auto Leveling',kobra_checking:'Checking',kobra_updated:'Updating',kobra_init:'Initializing',kobra_pausing:'Pausing...',kobra_paused:'Paused',kobra_resuming:'Resuming...',kobra_resumed:'Resumed',kobra_stopping:'Stopping...',kobra_stoped:'Stopped',kobra_finished:'Finished',kobra_failed:'Error',kobra_canceled:'Cancelled',kobra_offline:'Offline',
   nav_dashboard:'Dashboard',nav_print:'Print',nav_temps:'Temperatures',nav_motion:'Motion',nav_ams:'AMS',nav_extras:'Light / Fan',nav_console:'Console',
-  card_progress:'Progress',card_temps:'Temperatures',card_light_fan:'Fan',card_speed:'Print Speed',card_cam:'Camera',lbl_elapsed:'Elapsed',lbl_remaining:'remaining',
+  card_progress:'Progress',card_temps:'Temperatures',card_light_fan:'Fan',card_speed:'Print Speed',card_cam:'Camera',lbl_elapsed:'Elapsed',lbl_remaining:'remaining',lbl_slicer_time:'Slicer estimate:',
   speed_silent:'🐢 Silent',speed_normal:'⚡ Normal',speed_sport:'🚀 Sport',
   lbl_light:'💡 Light',lbl_feed:'Load',lbl_unload:'Unload',
   cam_placeholder:'📷 Camera not started',btn_cam_start:'▶ Camera',btn_cam_stop:'◼ Camera',
@@ -1205,12 +1395,14 @@ var LANG_EN={
   panel_console_title:'Event Log',
   log_light_on:'Light on',log_light_off:'Light off',log_fan:'Fan →',log_nozzle:'Nozzle →',log_bed:'Bed →',log_axis:'Axis',log_home:'Home',log_home_all:'Home All',log_cam_start:'Camera started:',log_cam_stop:'Camera stopped',log_poll_error:'Poll error:',log_error:'Error:',
   confirm_cancel:'Really cancel the print?',
-  settings_title:'Settings',settings_connection:'Connection',settings_poll:'Poll Interval',settings_version:'Version',
+  settings_title:'Settings',settings_connection:'Connection',settings_print:'Print Settings',settings_poll:'Poll Interval',settings_version:'Version',
   settings_save:'Save & Restart',settings_printer_ip:'Printer IP',settings_mqtt_port:'MQTT Port',
   settings_username:'MQTT Username',settings_password:'MQTT Password',settings_device_id:'Device ID',settings_mode_id:'Mode ID',hint_ip_no_port:'IP address only, no port (e.g. 192.168.1.102)',
+  settings_default_slot:'Default Slot (single color)',settings_slot_auto:'Auto (all loaded slots)',settings_auto_leveling:'Auto-Leveling before print',
   update_check:'Check for Updates',update_checking:'Checking...',update_available:'available',update_none:'Already up to date',
   update_apply:'Install Now',update_applying:'Downloading...',update_restarting:'Restarting...',update_error:'Error',
-  btn_connect:'⚡ Connect',btn_disconnect:'✕ Disconnect'
+  btn_connect:'⚡ Connect',btn_disconnect:'✕ Disconnect',
+  lbl_conn_error:'Connection error:'
 };
 var currentLang='de';
 var T=LANG_DE;
@@ -1262,6 +1454,7 @@ function applyLang(){
   // Settings modal
   setText('modal-title-settings',T.settings_title);
   setText('modal-sec-connection',T.settings_connection);
+  setText('modal-sec-print',T.settings_print);
   setText('modal-sec-poll',T.settings_poll);
   setText('modal-sec-version',T.settings_version);
   setText('btn-save-settings',T.settings_save);
@@ -1271,6 +1464,10 @@ function applyLang(){
   setText('lbl-password',T.settings_password);
   setText('lbl-device-id',T.settings_device_id);
   setText('lbl-mode-id',T.settings_mode_id);
+  setText('lbl-default-slot',T.settings_default_slot);
+  setText('opt-slot-auto',T.settings_slot_auto);
+  setText('lbl-auto-leveling',T.settings_auto_leveling);
+
   setText('lbl-update-check',T.update_check);
   setText('lbl-update-apply',T.update_apply);
   // Speed buttons
@@ -1311,15 +1508,71 @@ function showPanel(id){
 
 // ── Console log ──
 var consoleLogs=[];
+var logAutoScroll=true;
+var logBadgeCount=0;
+
 function clog(msg,cls){
   cls=cls||'msg-info';
   var ts=new Date().toLocaleTimeString('de',{hour:'2-digit',minute:'2-digit',second:'2-digit'});
-  consoleLogs.push({ts,msg,cls});
+  _appendLog({ts:ts,lvl:'',name:'ui',msg:msg},cls);
-  if(consoleLogs.length>100)consoleLogs.shift();
-  var el=document.getElementById('console-log');
-  el.innerHTML=consoleLogs.map(l=>`<div><span class="ts">${l.ts}</span><span class="${l.cls}">${l.msg}</span></div>`).join('');
-  el.scrollTop=el.scrollHeight;
 }
+function _lvlCls(lvl){
+  if(lvl==='ERROR'||lvl==='CRITICAL')return'msg-err';
+  if(lvl==='WARNING')return'msg-warn';
+  if(lvl==='DEBUG')return'msg-info';
+  return'msg-ok';
+}
+function _appendLog(entry,forceCls){
+  var cls=forceCls||_lvlCls(entry.lvl);
+  var label=entry.name?'['+entry.name+'] ':'';
+  consoleLogs.push({ts:entry.ts,msg:label+entry.msg,cls:cls});
+  if(consoleLogs.length>500)consoleLogs.shift();
+  // Badge wenn Tab nicht aktiv und Fehler/Warnungen
+  if(currentPanel!=='console'&&(cls==='msg-err'||cls==='msg-warn')){
+    logBadgeCount++;
+    var bc=logBadgeCount>99?'99+':logBadgeCount;
+    ['log-badge','log-badge-bot'].forEach(function(id){var b=document.getElementById(id);if(b){b.style.display='inline';b.textContent=bc;}});
+  }
+  renderLog();
+}
+function renderLog(){
+  var el=document.getElementById('console-log');
+  if(!el)return;
+  var filter=(document.getElementById('log-filter')||{}).value||'';
+  var fl=filter.toLowerCase();
+  var rows=fl?consoleLogs.filter(l=>l.msg.toLowerCase().includes(fl)):consoleLogs;
+  el.innerHTML=rows.map(l=>`<div><span class="ts">${l.ts}</span><span class="${l.cls}">${escHtml(l.msg)}</span></div>`).join('');
+  if(logAutoScroll)el.scrollTop=el.scrollHeight;
+}
+function onLogScroll(){
+  var el=document.getElementById('console-log');
+  if(!el)return;
+  var atBottom=el.scrollHeight-el.scrollTop-el.clientHeight<30;
+  if(!atBottom&&logAutoScroll){setAutoScroll(false);}
+}
+function toggleAutoScroll(){
+  setAutoScroll(!logAutoScroll);
+  if(logAutoScroll){var el=document.getElementById('console-log');if(el)el.scrollTop=el.scrollHeight;}
+}
+function setAutoScroll(on){
+  logAutoScroll=on;
+  var btn=document.getElementById('btn-autoscroll');
+  if(btn){btn.style.background=on?'var(--accent)':'var(--raised)';btn.style.color=on?'#fff':'var(--txt2)';}
+}
+function clearLogBadge(){
+  logBadgeCount=0;
+  ['log-badge','log-badge-bot'].forEach(function(id){var b=document.getElementById(id);if(b)b.style.display='none';});
+}
+function escHtml(s){return s.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;');}
+// SSE server-log stream
+(function(){
+  function connect(){
+    var es=new EventSource('/api/log/stream');
+    es.onmessage=function(e){try{_appendLog(JSON.parse(e.data));}catch(_){}};
+    es.onerror=function(){es.close();setTimeout(connect,3000);};
+  }
+  window.addEventListener('DOMContentLoaded',connect);
+})();
 
 // ── Helpers ──
 function fmtTime(s){if(!s||s<0)return'–';var m=Math.floor(s/60),h=Math.floor(m/60);m%=60;return h>0?h+'h '+m+'m':m+'m'}
@@ -1329,11 +1582,16 @@ function clamp(v,lo,hi){return Math.min(hi,Math.max(lo,v))}
 // ── Apply state to DOM ──
 function applyState(){
   var s=S;
+  // connection error banner
+  var banner=document.getElementById('conn-error-banner');
+  if(banner){if(s.connection_error){banner.textContent='⚠ '+(T.lbl_conn_error||'Connection error:')+' '+s.connection_error;banner.style.display='block';}else{banner.style.display='none';}}
   // header
   var b=document.getElementById('h-badge');
   b.className='hbadge '+s.print_state;
   document.getElementById('h-state').textContent=T['kobra_'+s.kobra_state]||s.kobra_state||T.header_status_standby;
   document.getElementById('h-pname').textContent=s.printer_name;
+  var hv=document.getElementById('h-version');if(hv&&s.version)hv.textContent='v'+s.version;
+
 
   // temps
   var nt=document.getElementById('d-nt');if(nt)nt.textContent=s.nozzle_temp.toFixed(1);
@@ -1358,6 +1616,14 @@ function applyState(){
   var remain=s.remain_time>0?'≈ '+fmtTime(s.remain_time)+' '+T.lbl_remaining:'';
   var dremain=document.getElementById('d-remain');if(dremain)dremain.textContent=remain;
 
+  var dslrow=document.getElementById('d-slicer-row');
+  var dsltime=document.getElementById('d-slicer-time');
+  var dsllbl=document.getElementById('d-slicer-label');
+  if(dslrow&&dsltime){
+    if(s.slicer_time>0){dslrow.style.display='';if(dsllbl)dsllbl.textContent=T.lbl_slicer_time;dsltime.textContent=fmtTime(s.slicer_time);}
+    else{dslrow.style.display='none';}
+  }
+
   var fn=s.filename||'–';
   var dfname=document.getElementById('d-fname');if(dfname){dfname.textContent=fn;dfname.title=fn};
   var pfname=document.getElementById('p-fname');if(pfname){pfname.textContent=fn;pfname.title=fn};
@@ -1484,6 +1750,8 @@ function openSettings(){
     document.getElementById('s-password').value=d.password||'';
     document.getElementById('s-device-id').value=d.device_id||'';
     document.getElementById('s-mode-id').value=d.mode_id||'';
+    document.getElementById('s-default-slot').value=d.default_ams_slot||'auto';
+    document.getElementById('s-auto-leveling').checked=(d.auto_leveling===undefined?true:!!d.auto_leveling);
   });
   var v=localStorage.getItem('pollInterval')||'2000';
   document.querySelectorAll('.poll-btn').forEach(function(b){b.classList.remove('active')});
@@ -1492,6 +1760,7 @@ function openSettings(){
   document.getElementById('s-version-label').textContent='v'+('__VERSION__'||'?');
   document.getElementById('update-status').textContent='';
   document.getElementById('btn-update-apply').style.display='none';
+  var cl=document.getElementById('update-changelog');if(cl)cl.style.display='none';
   _updateTag='';_updateUrl='';
   document.getElementById('settings-modal').classList.add('open');
 }
@@ -1517,12 +1786,14 @@ function saveSettings(){
   var btn=document.getElementById('btn-save-settings');
   btn.disabled=true;btn.textContent='…';
   post('/api/settings',{
-    printer_ip: document.getElementById('s-printer-ip').value,
+    printer_ip:       document.getElementById('s-printer-ip').value,
-    mqtt_port:  parseInt(document.getElementById('s-mqtt-port').value)||9883,
+    mqtt_port:        parseInt(document.getElementById('s-mqtt-port').value)||9883,
-    username:   document.getElementById('s-username').value,
+    username:         document.getElementById('s-username').value,
-    password:   document.getElementById('s-password').value,
+    password:         document.getElementById('s-password').value,
-    device_id:  document.getElementById('s-device-id').value,
+    device_id:        document.getElementById('s-device-id').value,
-    mode_id:    document.getElementById('s-mode-id').value,
+    mode_id:          document.getElementById('s-mode-id').value,
+    default_ams_slot: document.getElementById('s-default-slot').value,
+    auto_leveling:    document.getElementById('s-auto-leveling').checked?1:0,
   }).then(function(){
     btn.textContent=T.update_restarting;
     setTimeout(function(){
@@ -1543,6 +1814,9 @@ function checkUpdate(){
   _updateTag='';_updateUrl='';
   fetch('/api/update/check').then(function(r){return r.json()}).then(function(d){
     if(d.error){sb.textContent=T.update_error+': '+d.error;return;}
+    var cl=document.getElementById('update-changelog');
+    if(d.changelog&&d.changelog.trim()){cl.textContent=d.changelog;cl.style.display='block';}
+    else{cl.style.display='none';}
     if(d.update_available){
       sb.textContent='v'+d.latest+' '+T.update_available;
       sb.style.color='var(--ok)';
@@ -1908,6 +2182,36 @@ function toggleCam(){if(camOn)camStop();else camStart()}
         ))
         return web.json_response({"result": "ok"})
 
+    async def handle_api_camera_snapshot(self, request):
+        """Einzelner JPEG-Frame aus dem Kamera-Stream – für Obico und andere Snapshot-Clients."""
+        url = self._state.get("camera_url", "")
+        if not url:
+            return web.Response(status=503, text="Keine Kamera-URL bekannt")
+        is_rtsp = url.lower().startswith("rtsp://")
+        input_args = ["-fflags", "nobuffer", "-flags", "low_delay"]
+        if is_rtsp:
+            input_args += ["-probesize", "32", "-analyzeduration", "0", "-rtsp_transport", "tcp"]
+        else:
+            input_args += ["-probesize", "1000000", "-analyzeduration", "1000000"]
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                _find_ffmpeg(), "-loglevel", "quiet",
+                *input_args, "-i", url,
+                "-frames:v", "1", "-f", "mjpeg", "-q:v", "3",
+                "pipe:1",
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.DEVNULL,
+            )
+            jpeg, _ = await asyncio.wait_for(proc.communicate(), timeout=20)
+        except asyncio.TimeoutError:
+            return web.Response(status=504, text="Snapshot-Timeout")
+        except Exception as e:
+            return web.Response(status=503, text=str(e))
+        if not jpeg:
+            return web.Response(status=503, text="Kein Frame empfangen")
+        return web.Response(body=jpeg, content_type="image/jpeg",
+                            headers={"Cache-Control": "no-cache"})
+
     async def handle_camera_stream(self, request):
         """MJPEG proxy: FLV → MJPEG via ffmpeg, served as multipart/x-mixed-replace."""
         url = self._state.get("camera_url", "")
@@ -2022,6 +2326,7 @@ function toggleCam(){if(camOn)camStop();else camStart()}
             "curr_layer":       s["curr_layer"],
             "total_layers":     s["total_layers"],
             "filename":         s["filename"],
+            "slicer_time":      s["slicer_time"],
             "camera_url":       s["camera_url"],
             "fan_speed":        s["fan_speed"],
             "print_speed_mode": s["print_speed_mode"],
@@ -2030,46 +2335,40 @@ function toggleCam(){if(camOn)camStop();else camStart()}
             "ams_slots":        self._ams_slots,
             "ams_loaded_slot":  self._ams_loaded_slot,
             "thumbnail":        self._thumbnail_b64,
+            "connection_error": s["connection_error"],
+            "version":          self._read_version(),
         })
 
     async def handle_moonraker_database(self, request):
-        """OrcaSlicer 'Synchronize filament list from AMS' liest /server/database/item?namespace=lane_data"""
+        """OrcaSlicer Filament-Sync: /server/database/item?namespace=lane_data&key=lanes (AFC-Format)"""
         namespace = request.rel_url.query.get("namespace", "")
-        if namespace != "lane_data":
+        key       = request.rel_url.query.get("key", "")
-            return web.json_response({"result": {"namespace": namespace, "value": {}}})
+
-        loop = asyncio.get_event_loop()
+        if namespace == "lane_data":
-        slots = await loop.run_in_executor(None, lambda: self._get_ams_slots_fresh())
+            await asyncio.get_event_loop().run_in_executor(None, self._get_ams_slots_fresh)
-        lane_data = {}
+            lanes = self._build_lane_data()
-        for i, slot in enumerate(slots):
+            log.info(f"AMS-Sync: {len(lanes)} Lanes an OrcaSlicer")
-            rgb = slot.get("color", [128, 128, 128])
+            return web.json_response({
-            if isinstance(rgb, list) and len(rgb) >= 3:
+                "result": {
-                alpha = rgb[3] if len(rgb) == 4 else 255
+                    "namespace": "lane_data",
-                color_hex = f"{rgb[0]:02X}{rgb[1]:02X}{rgb[2]:02X}{alpha:02X}"
+                    "key":       key or "lanes",
-            else:
+                    "value":     lanes,
-                color_hex = "808080FF"
+                }
-            material = slot.get("type", "")
+            })
-            default_temps = {
+
-                "PLA":  {"nozzle": 220, "bed": 60},
+        if namespace in ("AFC", "afc-install", "happy_hare"):
-                "PETG": {"nozzle": 240, "bed": 70},
+            return web.json_response({
-                "ABS":  {"nozzle": 250, "bed": 100},
+                "result": {"namespace": namespace, "key": key, "value": None}
-                "TPU":  {"nozzle": 230, "bed": 40},
+            })
-            }
+
-            temps = default_temps.get(material.upper(), {"nozzle": 220, "bed": 60})
+        return web.json_response(
-            lane_data[f"lane{i}"] = {
+            {"error": {"code": 404, "message": f"Namespace '{namespace}' not found"}},
-                "vendor_name": "Anycubic",
+            status=404
-                "name":        material,
+        )
-                "color":       color_hex,
+
-                "material":    material,
+    async def handle_database_list(self, request):
-                "bed_temp":    temps["bed"],
+        """OrcaSlicer prüft welche Namespaces vorhanden sind um MMU-Typ zu erkennen."""
-                "nozzle_temp": temps["nozzle"],
+        return web.json_response({"result": {"namespaces": ["lane_data"]}})
-                "scan_time":   None,
-                "td":          None,
-                "lane":        str(i),
-                "spool_id":    None,
-                "filament_id": None,
-            }
-        log.info(f"AMS-Sync: {len(lane_data)} Slots an OrcaSlicer")
-        return web.json_response({"result": {"namespace": "lane_data", "value": lane_data}})
 
     def _get_ams_slots_fresh(self):
         """Frische Slot-Daten per getInfo holen, Fallback auf gecachte."""
@@ -2084,64 +2383,62 @@ function toggleCam(){if(camOn)camStop();else camStart()}
 
     # ─── Settings ────────────────────────────────────────────────────────────
 
-    def _find_env_path(self) -> pathlib.Path:
+    def _find_config_path(self) -> pathlib.Path:
-        """Gibt den Pfad zur .env-Datei zurück (neben Script oder im Parent)."""
+        """Gibt den Pfad zur config.ini zurück."""
+        if hasattr(env_loader, "find_config_path"):
+            return env_loader.find_config_path()
+        # Fallback für alten env_loader
         script_dir = pathlib.Path(_BASE)
         for base in (script_dir, script_dir.parent):
-            p = base / ".env"
+            p = base / "config" / "config.ini"
             if p.is_file():
                 return p
-        return script_dir.parent / ".env"
+        return script_dir / "config" / "config.ini"
 
     async def handle_api_settings_get(self, request):
         return web.json_response({
-            "printer_ip":  self._args.printer_ip,
+            "printer_ip":       self._args.printer_ip,
-            "mqtt_port":   self._args.mqtt_port,
+            "mqtt_port":        self._args.mqtt_port,
-            "username":    self._args.username,
+            "username":         self._args.username,
-            "password":    self._args.password,
+            "password":         self._args.password,
-            "mode_id":     self._args.mode_id,
+            "mode_id":          self._args.mode_id,
-            "device_id":   self._args.device_id,
+            "device_id":        self._args.device_id,
+            "default_ams_slot": getattr(self._args, "default_ams_slot", "auto"),
+            "auto_leveling":    getattr(self._args, "auto_leveling", 1),
         })
 
     async def handle_api_settings_post(self, request):
+        import configparser
         data = await request.json()
-        env_path = self._find_env_path()
+        config_path = self._find_config_path()
-        # Bestehende .env einlesen um Kommentare/Extra-Keys zu erhalten
+        config_path.parent.mkdir(parents=True, exist_ok=True)
-        existing: "dict[str, str]" = {}
+
-        lines: "list[str]" = []
+        # Bestehende config.ini lesen (Kommentare gehen verloren, aber Werte bleiben)
-        if env_path.is_file():
+        cfg = configparser.ConfigParser()
-            for line in env_path.read_text(encoding="utf-8").splitlines():
+        if config_path.is_file():
-                stripped = line.strip()
+            cfg.read(config_path, encoding="utf-8")
-                if stripped and not stripped.startswith("#") and "=" in stripped:
+
-                    k, _, v = stripped.partition("=")
+        # Sections sicherstellen
-                    existing[k.strip()] = v.strip()
+        for section in ("connection", "print", "bridge"):
-                lines.append(line)
+            if not cfg.has_section(section):
-        # Werte aktualisieren
+                cfg.add_section(section)
-        mapping = {
+
-            "PRINTER_IP":    str(data.get("printer_ip",  existing.get("PRINTER_IP",  ""))).split(":")[0],
+        printer_ip = str(data.get("printer_ip", self._args.printer_ip or "")).split(":")[0]
-            "MQTT_PORT":     str(data.get("mqtt_port",   existing.get("MQTT_PORT",   "9883"))),
+        cfg.set("connection", "printer_ip", printer_ip)
-            "MQTT_USERNAME": str(data.get("username",    existing.get("MQTT_USERNAME",""))),
+        cfg.set("connection", "mqtt_port",  str(data.get("mqtt_port",  self._args.mqtt_port or 9883)))
-            "MQTT_PASSWORD": str(data.get("password",    existing.get("MQTT_PASSWORD",""))),
+        cfg.set("connection", "username",   str(data.get("username",   self._args.username  or "")))
-            "MODE_ID":       str(data.get("mode_id",     existing.get("MODE_ID",      ""))),
+        cfg.set("connection", "password",   str(data.get("password",   self._args.password  or "")))
-            "DEVICE_ID":     str(data.get("device_id",   existing.get("DEVICE_ID",    ""))),
+        cfg.set("connection", "mode_id",    str(data.get("mode_id",    self._args.mode_id   or "")))
-        }
+        cfg.set("connection", "device_id",  str(data.get("device_id",  self._args.device_id or "")))
-        # Zeilen ersetzen oder neue Keys anhängen
+        cfg.set("print",      "default_ams_slot", str(data.get("default_ams_slot", getattr(self._args, "default_ams_slot", "auto"))))
-        written: "set[str]" = set()
+        cfg.set("print",      "auto_leveling",    str(data.get("auto_leveling",    getattr(self._args, "auto_leveling",    1))))
-        new_lines: "list[str]" = []
+        if not cfg.has_option("bridge", "poll_interval"):
-        for line in lines:
+            cfg.set("bridge", "poll_interval", "3")
-            stripped = line.strip()
+
-            if stripped and not stripped.startswith("#") and "=" in stripped:
+        with open(config_path, "w", encoding="utf-8") as f:
-                k = stripped.partition("=")[0].strip()
+            f.write("# KX-Bridge Konfigurationsdatei\n\n")
-                if k in mapping:
+            cfg.write(f)
-                    new_lines.append(f"{k}={mapping[k]}")
+        log.info(f"Settings gespeichert in {config_path}")
-                    written.add(k)
-                    continue
-            new_lines.append(line)
-        for k, v in mapping.items():
-            if k not in written:
-                new_lines.append(f"{k}={v}")
-        env_path.write_text("\n".join(new_lines) + "\n", encoding="utf-8")
-        log.info(f"Settings gespeichert in {env_path}")
         # Response senden, dann Neustart
         response = web.json_response({"status": "restarting"})
         asyncio.get_event_loop().call_later(0.3, self._restart_bridge)
@@ -2158,8 +2455,9 @@ function toggleCam(){if(camOn)camStop();else camStart()}
 
     # ─── Update ──────────────────────────────────────────────────────────────
 
-    GITEA_RELEASE_API = "https://gitea.it-drui.de/api/v1/repos/viewit/KX-Bridge-Release/releases?limit=1&pre-release=true"
+    STABLE_RELEASE_API = "https://gitea.it-drui.de/api/v1/repos/viewit/KX-Bridge-Release/releases?limit=1"
-    GITEA_RAW_BASE    = "https://gitea.it-drui.de/viewit/KX-Bridge-Release/raw/tag"
+    DEV_RELEASE_API    = "https://gitea.it-drui.de/api/v1/repos/viewit/KX-Bridge-Release/releases?limit=10&pre-release=true"
+    GITEA_RAW_BASE     = "https://gitea.it-drui.de/viewit/KX-Bridge-Release/raw/tag"
 
     def _read_version(self) -> str:
         for base in (pathlib.Path(_BASE), pathlib.Path(_BASE).parent):
@@ -2189,20 +2487,70 @@ function toggleCam(){if(camOn)camStop();else camStart()}
                 break
         return tuple(result) or (0,)
 
+    async def handle_api_log_stream(self, request):
+        """SSE-Endpoint: sendet Log-Einträge live an den Browser."""
+        resp = web.StreamResponse(headers={
+            "Content-Type":  "text/event-stream",
+            "Cache-Control": "no-cache",
+            "X-Accel-Buffering": "no",
+        })
+        await resp.prepare(request)
+        # Zuerst Ring-Buffer senden
+        for entry in list(_log_buffer):
+            data = json.dumps(entry, ensure_ascii=False)
+            await resp.write(f"data: {data}\n\n".encode())
+        # Dann live streamen
+        q: asyncio.Queue = asyncio.Queue()
+        _log_sse_queues.append(q)
+        try:
+            while True:
+                entry = await asyncio.wait_for(q.get(), timeout=25)
+                data = json.dumps(entry, ensure_ascii=False)
+                await resp.write(f"data: {data}\n\n".encode())
+        except asyncio.TimeoutError:
+            await resp.write(b": keepalive\n\n")
+        except (ConnectionResetError, Exception):
+            pass
+        finally:
+            _log_sse_queues.remove(q) if q in _log_sse_queues else None
+        return resp
+
+    async def handle_api_log_download(self, request):
+        """Gibt alle gepufferten Log-Einträge als Plaintext zum Download."""
+        lines = [f"[{e['ts']}] {e['lvl']:<5} {e['name']}: {e['msg']}" for e in _log_buffer]
+        text = "\n".join(lines)
+        return web.Response(
+            body=text.encode("utf-8"),
+            content_type="text/plain",
+            headers={"Content-Disposition": 'attachment; filename="kx-bridge.log"'},
+        )
+
     async def handle_api_update_check(self, request):
         current = self._read_version()
+        is_dev = "-dev+" in current
+        api_url = self.DEV_RELEASE_API if is_dev else self.STABLE_RELEASE_API
         try:
             async with aiohttp.ClientSession() as session:
-                async with session.get(self.GITEA_RELEASE_API, timeout=aiohttp.ClientTimeout(total=10)) as resp:
+                async with session.get(api_url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
                     if resp.status != 200:
                         return web.json_response({"error": f"Gitea HTTP {resp.status}"}, status=502)
                     releases = await resp.json(content_type=None)
             if not releases:
                 return web.json_response({"error": "Keine Releases gefunden"}, status=404)
-            data = releases[0]
+            # Dev: neuestes Release mit "-dev+" im Tag suchen
+            if is_dev:
+                dev_releases = [r for r in releases if "-dev+" in r.get("tag_name", "")]
+                if not dev_releases:
+                    return web.json_response({"error": "Keine Dev-Releases gefunden"}, status=404)
+                data = dev_releases[0]
+            else:
+                data = releases[0]
             tag = data.get("tag_name", "")
             latest = tag.lstrip("v")
-            update_available = self._parse_version(tag) > self._parse_version(current)
+            if is_dev:
+                update_available = tag != f"v{current}"
+            else:
+                update_available = self._parse_version(tag) > self._parse_version(current)
             download_url = f"{self.GITEA_RAW_BASE}/{tag}/kobrax_moonraker_bridge.py"
             return web.json_response({
                 "current":          current,
@@ -2210,6 +2558,7 @@ function toggleCam(){if(camOn)camStop();else camStart()}
                 "update_available": update_available,
                 "tag":              tag,
                 "download_url":     download_url,
+                "changelog":        data.get("body", ""),
             })
         except Exception as e:
             return web.json_response({"error": str(e)}, status=502)
@@ -2410,9 +2759,12 @@ function toggleCam(){if(camOn)camStop();else camStart()}
                         _offline = False
                         self._state["print_state"] = "standby"
                         self._state["kobra_state"] = "free"
+                        self._state["connection_error"] = ""
                         log.info("MQTT-Verbindung wiederhergestellt")
                     except Exception as e:
-                        log.warning(f"Verbindungsaufbau fehlgeschlagen: {_mqtt_error_msg(e)}")
+                        err = _mqtt_error_msg(e)
+                        self._state["connection_error"] = err
+                        log.warning(f"Verbindungsaufbau fehlgeschlagen: {err}")
                         stop_event.wait(_probe_interval)
                         continue
                 else:
@@ -2443,6 +2795,7 @@ function toggleCam(){if(camOn)camStop();else camStart()}
                     log.info("Drucker nicht erreichbar – wechsle in Offline-Modus")
                     self._state["print_state"] = "error"
                     self._state["kobra_state"] = "offline"
+                    self._state["connection_error"] = f"Printer unreachable ({self._args.printer_ip})"
                     try:
                         self.client.disconnect()
                     except Exception:
@@ -2458,7 +2811,7 @@ function toggleCam(){if(camOn)camStop();else camStart()}
 def _mqtt_error_msg(exc: Exception) -> str:
     msg = str(exc)
     if "20020005" in msg:
-        return "Falsche MQTT-Zugangsdaten (falscher Benutzername, Passwort oder Device-ID)"
+        return "Wrong MQTT credentials (username, password or device ID incorrect)"
     return msg
 
 
@@ -2488,6 +2841,7 @@ def build_app(bridge: KobraXBridge) -> web.Application:
 
     # Moonraker database (OrcaSlicer AMS-Sync)
     r.add_get("/server/database/item",       bridge.handle_moonraker_database)
+    r.add_get("/server/database/list",       bridge.handle_database_list)
 
     # New API endpoints
     r.add_post("/api/light",               bridge.handle_api_light)
@@ -2500,6 +2854,7 @@ def build_app(bridge: KobraXBridge) -> web.Application:
     r.add_post("/api/temperature",         bridge.handle_api_temperature)
     r.add_get("/api/camera",               bridge.handle_api_camera)
     r.add_get("/api/camera/stream",        bridge.handle_camera_stream)
+    r.add_get("/api/camera/snapshot",      bridge.handle_api_camera_snapshot)
     r.add_post("/api/camera/start",        bridge.handle_api_camera_start)
     r.add_post("/api/camera/stop",         bridge.handle_api_camera_stop)
     r.add_get("/api/state",                bridge.handle_api_state)
@@ -2507,6 +2862,8 @@ def build_app(bridge: KobraXBridge) -> web.Application:
     r.add_post("/api/settings",            bridge.handle_api_settings_post)
     r.add_get("/api/update/check",         bridge.handle_api_update_check)
     r.add_post("/api/update/apply",        bridge.handle_api_update_apply)
+    r.add_get("/api/log/stream",           bridge.handle_api_log_stream)
+    r.add_get("/api/log/download",         bridge.handle_api_log_download)
     r.add_get("/serve/{filename}",         bridge.handle_serve_file)
 
     # Root + favicon (OrcaSlicer öffnet / in eingebettetem Browser)
@@ -2542,9 +2899,11 @@ async def run_bridge(args):
         await loop.run_in_executor(None, client.connect)
         log.info("MQTT verbunden")
     except Exception as e:
-        log.warning(f"Verbindung fehlgeschlagen: {_mqtt_error_msg(e)} – starte im Offline-Modus")
+        err = _mqtt_error_msg(e)
+        log.warning(f"Verbindung fehlgeschlagen: {err} – starte im Offline-Modus")
         bridge._state["print_state"] = "error"
         bridge._state["kobra_state"] = "offline"
+        bridge._state["connection_error"] = err
     app     = build_app(bridge)
 
     stop_event = threading.Event()
@@ -2558,8 +2917,16 @@ async def run_bridge(args):
     site = web.TCPSite(runner, args.host, args.port)
     await site.start()
 
-    log.info(f"Bridge läuft auf http://{args.host}:{args.port}")
+    import socket as _socket
-    log.info(f"OrcaSlicer → Klipper → Host: {args.host}  Port: {args.port}")
+    try:
+        with _socket.socket(_socket.AF_INET, _socket.SOCK_DGRAM) as _s:
+            _s.connect(("8.8.8.8", 80))
+            _local_ip = _s.getsockname()[0]
+    except Exception:
+        _local_ip = args.host
+    log.info(f"Bridge läuft auf http://{_local_ip}:{args.port}")
+    log.info(f"OrcaSlicer → Klipper → Host: {_local_ip}  Port: {args.port}")
+
     log.info("Ctrl-C zum Beenden")
 
     try:
@@ -2582,8 +2949,11 @@ def main():
     parser.add_argument("--username",    default=env_loader.USERNAME)
     parser.add_argument("--password",    default=env_loader.PASSWORD)
     parser.add_argument("--mode-id",     default=env_loader.MODE_ID)
-    parser.add_argument("--device-id",   default=env_loader.DEVICE_ID)
+    parser.add_argument("--device-id",       default=env_loader.DEVICE_ID)
-    parser.add_argument("--host",        default="0.0.0.0",
+    parser.add_argument("--default-ams-slot",default=env_loader.DEFAULT_AMS_SLOT)
+    parser.add_argument("--auto-leveling",   type=int, default=env_loader.AUTO_LEVELING)
+
+    parser.add_argument("--host",            default="0.0.0.0",
                         help="Bind-Adresse für den Bridge-Server")
     parser.add_argument("--port",        type=int, default=7125,
                         help="HTTP/WS-Port (Moonraker-Standard: 7125)")