docs: add API.md and MANUAL.md, link them from README

API.md documents the full HTTP/WebSocket surface (Moonraker-compatible
endpoints for Mainsail/Fluidd/OrcaSlicer/moonraker-obico compatibility,
plus the bridge-specific /api and /kx routes) for integrators and plugin
authors.

MANUAL.md is a task-oriented end-user guide covering day-to-day usage:
dashboard, printing, filament/AMS management, multi-printer setup, the
power-switch feature, settings reference, and basic troubleshooting.

NIGHTLY_CHANGELOG.md

@@ -1,3 +1,2 @@
 ## Changes in this build
 
-- Fix: a range of smaller robustness issues found in an internal code review — a single malformed MQTT message from the printer could get permanently stuck at the front of the receive buffer and force a reconnect on every subsequent poll; concurrent requests of the same type could occasionally have their responses mixed up; the camera stream could leak an orphaned ffmpeg process after a printer reboot rotated its stream URL while a new stream was already starting; `/api/settings` and `/api/update/apply` returned an unhandled server error instead of a clean "invalid request" for a malformed request body; a typo'd numeric value in `config.ini` (e.g. a stray character in the port number) could prevent the bridge from starting at all instead of falling back to the default; and a rare filament-profile-name collision during import is now logged instead of silently resolved. None of these were reported as user-facing bugs — added as defense-in-depth after a targeted review, with new tests covering each case.

VERSION

@@ -1 +1 @@
-0.9.27
+0.9.29

config_loader.py

@@ -7,11 +7,8 @@ import os
 import sys
 import pathlib
 import configparser
-import logging
 from typing import Optional
 
-log = logging.getLogger("kobrax.config")
-
 _BASE = pathlib.Path(sys.executable).parent if getattr(sys, "frozen", False) else pathlib.Path(__file__).parent
 
 CONFIG_SECTION_CONNECTION = "connection"
@@ -62,15 +59,11 @@ CONFIG_ENV_MAPPING = {
     "MQTT_PASSWORD":    (CONFIG_SECTION_CONNECTION, "password"),
     "MODE_ID":          (CONFIG_SECTION_CONNECTION, "mode_id"),
     "DEVICE_ID":        (CONFIG_SECTION_CONNECTION, "device_id"),
-    "POWER_ON_URL":     (CONFIG_SECTION_CONNECTION, "power_on_url"),
-    "POWER_OFF_URL":    (CONFIG_SECTION_CONNECTION, "power_off_url"),
-    "POWER_STATUS_URL": (CONFIG_SECTION_CONNECTION, "power_status_url"),
     "DEFAULT_AMS_SLOT":     (CONFIG_SECTION_PRINT,   "default_ams_slot"),
     "AUTO_LEVELING":            (CONFIG_SECTION_PRINT,   "auto_leveling"),
     "VIBRATION_COMPENSATION":   (CONFIG_SECTION_PRINT,   "vibration_compensation"),
     "CAMERA_ON_PRINT":          (CONFIG_SECTION_PRINT,   "camera_on_print"),
     "WEB_UPLOAD_WARNING":   (CONFIG_SECTION_PRINT,   "web_upload_warning"),
-    "DELETE_PRINTER_FILE_AFTER_PRINT": (CONFIG_SECTION_PRINT, "delete_printer_file_after_print"),
     "PRINT_START_DIALOG":   (CONFIG_SECTION_PRINT,   "print_start_dialog"),
     "BRIDGE_PRINTER_NAME":  (CONFIG_SECTION_BRIDGE,  "printer_name"),
     "BRIDGE_HOST_IP":       (CONFIG_SECTION_BRIDGE,  "host_ip"),
@@ -83,7 +76,7 @@ CONFIG_ENV_MAPPING = {
 
 def _load_config_file(path: pathlib.Path):
     """Loads config.ini and sets keys in os.environ (only if not already set)."""
-    cfg = configparser.ConfigParser(interpolation=None)
+    cfg = configparser.ConfigParser()
     cfg.read(path, encoding="utf-8")
 
     for env_key, (section, option) in CONFIG_ENV_MAPPING.items():
@@ -119,7 +112,8 @@ def migrate_env_to_config(env_path: pathlib.Path, config_path: pathlib.Path):
             k, _, v = line.partition("=")
             env_vals[k.strip()] = v.strip()
 
-    cfg = configparser.ConfigParser(interpolation=None)
+    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"),
@@ -138,20 +132,10 @@ def migrate_env_to_config(env_path: pathlib.Path, config_path: pathlib.Path):
     cfg[CONFIG_SECTION_BRIDGE] = {
         "poll_interval": "3",
     }
-    # This runs at module import time (see the "Laden" section below) - an
-    # uncaught mkdir/write failure (e.g. a read-only filesystem) would crash
-    # the whole bridge at startup with a raw traceback. Log a clear diagnostic
-    # before re-raising, so the actual cause (permissions, disk full) is
-    # visible instead of a bare stack trace pointing into configparser.
-    try:
-        config_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(config_path, "w", encoding="utf-8") as f:
-            f.write("# KX-Bridge Konfigurationsdatei\n")
-            f.write("# Automatically migrated from .env\n\n")
-            cfg.write(f)
-    except OSError as e:
-        log.error("Failed to write migrated config.ini to %s: %s", config_path, e)
-        raise
+    with open(config_path, "w", encoding="utf-8") as f:
+        f.write("# KX-Bridge Konfigurationsdatei\n")
+        f.write("# Automatically migrated from .env\n\n")
+        cfg.write(f)
 
 
 def find_config_path() -> pathlib.Path:
@@ -191,7 +175,7 @@ def list_printers() -> list[dict]:
     path = _find_config_file()
     if not path:
         return []
-    cfg = configparser.ConfigParser(interpolation=None)
+    cfg = configparser.ConfigParser()
     cfg.read(path, encoding="utf-8")
     printers: list[dict] = []
     idx = 1
@@ -253,7 +237,7 @@ def list_filament_profiles(printer_id: Optional[str] = None) -> dict[int, dict]:
     path = _find_config_file()
     if not path:
         return {}
-    cfg = configparser.ConfigParser(interpolation=None)
+    cfg = configparser.ConfigParser()
     cfg.read(path, encoding="utf-8")
     section = _filament_section(printer_id)
     if not cfg.has_section(section):
@@ -294,7 +278,7 @@ def save_filament_profiles(profiles: dict[int, dict], printer_id: Optional[str]
     path = _find_config_file()
     if not path:
         return False
-    cfg = configparser.ConfigParser(interpolation=None)
+    cfg = configparser.ConfigParser()
     cfg.read(path, encoding="utf-8")
     section = _filament_section(printer_id)
     # visible_vendors (Issue #41) is not a slot mapping - preserve it when
@@ -336,7 +320,7 @@ def list_visible_vendors(printer_id: Optional[str] = None) -> list[str]:
     path = _find_config_file()
     if not path:
         return []
-    cfg = configparser.ConfigParser(interpolation=None)
+    cfg = configparser.ConfigParser()
     cfg.read(path, encoding="utf-8")
     section = _filament_section(printer_id)
     if not cfg.has_option(section, "visible_vendors"):
@@ -358,7 +342,7 @@ def save_visible_vendors(vendors: list[str], printer_id: Optional[str] = None) -
     path = _find_config_file()
     if not path:
         return False
-    cfg = configparser.ConfigParser(interpolation=None)
+    cfg = configparser.ConfigParser()
     cfg.read(path, encoding="utf-8")
     section = _filament_section(printer_id)
     if not cfg.has_section(section):
@@ -418,7 +402,7 @@ def list_spool_map(printer_id: Optional[str] = None) -> dict[int, int]:
     path = _find_config_file()
     if not path:
         return {}
-    cfg = configparser.ConfigParser(interpolation=None)
+    cfg = configparser.ConfigParser()
     cfg.read(path, encoding="utf-8")
     section = _spoolman_map_section(printer_id)
     if cfg.has_option(section, "slot_spools"):
@@ -438,7 +422,7 @@ def save_spool_map(slot_spools: dict[int, int], printer_id: Optional[str] = None
     path = _find_config_file()
     if not path:
         return False
-    cfg = configparser.ConfigParser(interpolation=None)
+    cfg = configparser.ConfigParser()
     cfg.read(path, encoding="utf-8")
     section = _spoolman_map_section(printer_id)
     clean = {int(k): int(v) for k, v in (slot_spools or {}).items() if int(v) > 0}
@@ -457,41 +441,21 @@ def get(key: str, default: str = "") -> str:
     return os.environ.get(key, default)
 
 
-def _safe_int(value: str, default: int) -> int:
-    """Falls back to `default` instead of raising on a non-numeric value.
-
-    All of these run at module import time - an uncaught ValueError here
-    (e.g. from a hand-edited config.ini with a typo like `mqtt_port = 98833x`)
-    would crash the entire bridge before it even starts, with a raw traceback
-    instead of a clear diagnostic. list_printers() already guards this same
-    class of input the same way; this applies it to the module-level
-    shortcuts too."""
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        log.warning("config: expected a number, got %r - using default %r", value, default)
-        return default
-
-
 # Frequently used shortcuts
 PRINTER_IP       = get("PRINTER_IP",       "")
-MQTT_PORT        = _safe_int(get("MQTT_PORT", "9883"), 9883)
+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",        "")
-POWER_ON_URL     = get("POWER_ON_URL",     "")
-POWER_OFF_URL    = get("POWER_OFF_URL",    "")
-POWER_STATUS_URL = get("POWER_STATUS_URL", "")
 DEFAULT_AMS_SLOT = get("DEFAULT_AMS_SLOT", "auto")
-AUTO_LEVELING           = _safe_int(get("AUTO_LEVELING",          "1"), 1)
-VIBRATION_COMPENSATION  = _safe_int(get("VIBRATION_COMPENSATION", "0"), 0)
-CAMERA_ON_PRINT         = _safe_int(get("CAMERA_ON_PRINT",        "0"), 0)
-WEB_UPLOAD_WARNING = _safe_int(get("WEB_UPLOAD_WARNING", "1"), 1)
-DELETE_PRINTER_FILE_AFTER_PRINT = _safe_int(get("DELETE_PRINTER_FILE_AFTER_PRINT", "0"), 0)
-PRINT_START_DIALOG = _safe_int(get("PRINT_START_DIALOG", get("FILE_READY_DIALOG", "1")), 1)
+AUTO_LEVELING           = int(get("AUTO_LEVELING",          "1"))
+VIBRATION_COMPENSATION  = int(get("VIBRATION_COMPENSATION", "0"))
+CAMERA_ON_PRINT         = int(get("CAMERA_ON_PRINT",        "0"))
+WEB_UPLOAD_WARNING = int(get("WEB_UPLOAD_WARNING", "1"))
+PRINT_START_DIALOG = int(get("PRINT_START_DIALOG", get("FILE_READY_DIALOG", "1")))
 SPOOLMAN_SERVER    = get("SPOOLMAN_SERVER",    "")
-SPOOLMAN_SYNC_RATE = _safe_int(get("SPOOLMAN_SYNC_RATE", "0"), 0)
+SPOOLMAN_SYNC_RATE = int(get("SPOOLMAN_SYNC_RATE", "0"))
 BRIDGE_HOST_IP     = get("BRIDGE_HOST_IP",     "")
-POLL_INTERVAL      = _safe_int(get("POLL_INTERVAL",  "3"), 3)
-VERBOSE_HTTP_LOG   = _safe_int(get("VERBOSE_HTTP_LOG", "0"), 0)
+POLL_INTERVAL      = int(get("POLL_INTERVAL",  "3"))
+VERBOSE_HTTP_LOG   = int(get("VERBOSE_HTTP_LOG", "0"))

env_loader.py

@@ -46,14 +46,10 @@ USERNAME         = get("MQTT_USERNAME",    "")
 PASSWORD         = get("MQTT_PASSWORD",    "")
 MODE_ID          = get("MODE_ID",          "")
 DEVICE_ID        = get("DEVICE_ID",        "")
-POWER_ON_URL     = get("POWER_ON_URL",     "")
-POWER_OFF_URL    = get("POWER_OFF_URL",    "")
-POWER_STATUS_URL = get("POWER_STATUS_URL", "")
 DEFAULT_AMS_SLOT = get("DEFAULT_AMS_SLOT", "auto")
 AUTO_LEVELING            = int(get("AUTO_LEVELING", "1"))
 VIBRATION_COMPENSATION   = int(get("VIBRATION_COMPENSATION", "0"))
 CAMERA_ON_PRINT          = int(get("CAMERA_ON_PRINT", "0"))
 WEB_UPLOAD_WARNING = int(get("WEB_UPLOAD_WARNING", "1"))
-DELETE_PRINTER_FILE_AFTER_PRINT = int(get("DELETE_PRINTER_FILE_AFTER_PRINT", "0"))
 PRINT_START_DIALOG = int(get("PRINT_START_DIALOG", get("FILE_READY_DIALOG", "1")))
 BRIDGE_HOST_IP   = get("BRIDGE_HOST_IP", "")

kobrax_client.py

@@ -101,46 +101,6 @@ def _parse_publish(pkt: bytes):
     return topic, payload
 
 
-def _enable_tcp_keepalive(sock: socket.socket) -> None:
-    """Without this, a printer that goes dark without a clean TCP close (e.g.
-    unplugged, not gracefully shut down) leaves the socket looking alive to
-    is_connected() for as long as the OS's default dead-connection timeout
-    (often 15+ minutes on Linux) - sendall() on a half-open connection is
-    buffered by the kernel and doesn't fail immediately, so the poll loop's
-    is_connected() check (kobrax_moonraker_bridge.py's _poll_loop) never
-    sees the failure it needs to flip kobra_state to "offline". Short
-    keepalive probes make the OS notice and fail the socket within seconds
-    instead. Linux/macOS only (TCP_KEEPIDLE/INTVL/CNT); best-effort on other
-    platforms - not fatal if unsupported.
-
-    SO_KEEPALIVE alone is NOT enough, verified live by unplugging a real
-    printer mid-connection: keepalive probes only fire while the connection
-    is idle (no unacknowledged data outstanding). If the printer disappears
-    while a send is still in flight - the common case, since the poll loop
-    sends a request roughly every poll_interval - the kernel instead retries
-    that specific send via the normal TCP retransmission timer
-    (tcp_retries2, default 15 attempts with exponential backoff = 13-30+
-    minutes on Linux), which keepalive settings don't affect at all.
-    TCP_USER_TIMEOUT (Linux-specific) closes that gap: it caps how long ANY
-    unacknowledged data may sit in the send queue before the kernel gives up
-    on the connection outright, regardless of which mechanism (keepalive or
-    retransmission) would otherwise still be retrying."""
-    try:
-        sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
-        if hasattr(socket, "TCP_KEEPIDLE"):
-            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, 5)
-        elif hasattr(socket, "TCP_KEEPALIVE"):  # macOS
-            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPALIVE, 5)
-        if hasattr(socket, "TCP_KEEPINTVL"):
-            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, 3)
-        if hasattr(socket, "TCP_KEEPCNT"):
-            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT, 3)
-        if hasattr(socket, "TCP_USER_TIMEOUT"):
-            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_USER_TIMEOUT, 15000)
-    except OSError as e:
-        log.debug("TCP keepalive not fully supported on this platform: %s", e)
-
-
 # ---------------------------------------------------------------------------
 # KobraXClient
 # ---------------------------------------------------------------------------
@@ -166,37 +126,17 @@ class KobraXClient:
         # underneath it (Issue #53). Protects against recv on a stale fd.
         self._sock_gen = 0
         self._running = False
-        # Guards _reconnect() against concurrent invocation - both the reader
-        # thread (keepalive ping failure) and publish()/publish_web() (send
-        # failure) can trigger a reconnect independently. Without this, two
-        # threads could race into _do_connect() at once, each opening its own
-        # competing TLS handshake to a printer that likely only accepts one
-        # mTLS session at a time (Issue #105).
-        self._reconnect_lock = threading.Lock()
 
         # Pending requests by msgid (for response ACK)
         self._pending_msgid: dict[str, dict] = {}
         # Pending requests by msg_type/report topic suffix
         self._pending_report: dict[str, dict] = {}
-        # Guards _pending_msgid/_pending_report against concurrent mutation:
-        # the reader thread resolves entries in _dispatch() while publish()
-        # (called from the poll loop and, via run_in_executor, HTTP handler
-        # threads) registers/cleans them up - without this, two concurrent
-        # publish() calls for the same msg_type can race on the
-        # check-then-set for a report_key slot, and _dispatch() could observe
-        # a dict mid-mutation.
-        self._pending_lock = threading.Lock()
 
         # 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] = {}
-        # Debug switch (MQTT_RAW_LOG=1): logs every RX message unfiltered on
-        # INFO, including dedup'd duplicates and topics with no registered
-        # callback - for capturing printer behavior the bridge doesn't
-        # normally surface (e.g. reverse-engineering a rejected command).
-        self._raw_log = os.environ.get("MQTT_RAW_LOG", "").strip().lower() in ("1", "true", "yes")
         # Fields that change every tick and should be stripped before dedup-hashing
         _VOLATILE = {"timestamp", "msgid", "progress", "curr_layer",
                      "curr_nozzle_temp", "curr_hotbed_temp",
@@ -237,7 +177,6 @@ class KobraXClient:
         # senders. Only the finished socket is swapped in under the lock (#53).
         _ai      = socket.getaddrinfo(self.host, self.port, socket.AF_INET, socket.SOCK_STREAM)
         raw      = socket.create_connection(_ai[0][4], timeout=5)
-        _enable_tcp_keepalive(raw)
         new_sock = ctx.wrap_socket(raw)
         log.info("TLS connected  cipher=%s", new_sock.cipher()[0])
 
@@ -292,81 +231,41 @@ class KobraXClient:
             self._sock = None
             self._sock_gen += 1
 
-    def is_connected(self) -> bool:
-        """Thread-safe check whether the MQTT socket is currently up. Used by
-        the bridge's poll loop to detect a dead session even when publish()
-        already swallowed the send failure and returned None instead of
-        raising (Issue #105) - a TCP-reachable printer alone doesn't mean the
-        MQTT/TLS session is still alive."""
+    def _reconnect(self):
+        """Persistent reconnect: keeps retrying forever until the printer is
+        responds or disconnect() was called. Backoff caps at 60 s. The
+        first 5 attempts log as WARNING (acute connection issue), afterwards
+        only DEBUG to avoid log spam during long printer outages (e.g. switched
+        ausgeschaltet) zu vermeiden."""
+        log.warning("Connection lost - reconnecting...")
+        # Close + invalidation under the lock so no sender is mid-sendall
+        # auf den gerade geschlossenen Socket trifft (Issue #53).
         with self._lock:
-            return self._sock is not None
-
-    def _reconnect(self, wait_if_in_progress: bool = True, persist: bool = True):
-        """Reconnect the MQTT/TLS session. With persist=True (the default, used
-        by the reader-thread keepalive path) it keeps retrying forever until
-        the printer responds or disconnect() was called, backoff capped at 60s.
-        The first 5 attempts log as WARNING (acute connection issue), afterwards
-        only DEBUG to avoid log spam during long printer outages (e.g. switched off).
-
-        Guarded by _reconnect_lock (Issue #105): if another thread's reconnect
-        is already in flight, this call normally waits for it to finish instead
-        of starting a second, competing _do_connect() - the printer likely only
-        accepts one mTLS session at a time, so two parallel handshakes would
-        just interfere with each other and neither converges.
-
-        wait_if_in_progress=False + persist=False are used by the poll loop's
-        publish()/publish_web(): that thread MUST return promptly so the poll
-        loop can observe the dead session (via is_connected()) and flip
-        kobra_state to "offline". It must neither block on the lock waiting for
-        the reader thread's persistent reconnect (wait_if_in_progress=False),
-        nor run the multi-minute backoff loop itself (persist=False -> at most
-        one immediate attempt). Otherwise the poll loop hangs inside publish()
-        for the entire outage and the dashboard stays stuck on the last known
-        state - the exact bug seen when a printer was unplugged mid-connection."""
-        if not self._reconnect_lock.acquire(blocking=False):
-            if not wait_if_in_progress:
-                return self._sock is not None
-            self._reconnect_lock.acquire()
-            self._reconnect_lock.release()
-            return self._sock is not None
-        try:
-            log.warning("Connection lost - reconnecting...")
-            # Close + invalidation under the lock so no sender is mid-sendall
-            # auf den gerade geschlossenen Socket trifft (Issue #53).
-            with self._lock:
-                try:
-                    if self._sock is not None:
-                        self._sock.close()
-                except Exception:
-                    pass
-                self._sock = None
-                self._sock_gen += 1
-            delays = [2, 4, 8, 15, 30, 60]
-            attempt = 0
-            while self._running:
-                delay = delays[min(attempt, len(delays) - 1)]
-                try:
-                    self._do_connect()
-                    log.info("Reconnect successful (after %d attempts)", attempt + 1)
-                    return True
-                except Exception as e:
-                    attempt += 1
-                    if not persist:
-                        # One-shot: don't block the caller (poll loop) in the
-                        # backoff loop - leave persistent retrying to the
-                        # reader thread's keepalive path.
-                        log.debug("Reconnect (one-shot) failed: %s", e)
-                        return False
-                    lvl = log.warning if attempt <= 5 else log.debug
-                    lvl("Reconnect fehlgeschlagen (%s, Versuch %d), warte %ss…", e, attempt, delay)
-                    # Split sleep so disconnect() breaks the loop faster.
-                    slept = 0.0
-                    while slept < delay and self._running:
-                        time.sleep(min(0.5, delay - slept))
-                        slept += 0.5
-            return False  # only when disconnect() was called
-        finally:
-            self._reconnect_lock.release()
+            try:
+                if self._sock is not None:
+                    self._sock.close()
+            except Exception:
+                pass
+            self._sock = None
+            self._sock_gen += 1
+        delays = [2, 4, 8, 15, 30, 60]
+        attempt = 0
+        while self._running:
+            delay = delays[min(attempt, len(delays) - 1)]
+            try:
+                self._do_connect()
+                log.info("Reconnect successful (after %d attempts)", attempt + 1)
+                return True
+            except Exception as e:
+                attempt += 1
+                lvl = log.warning if attempt <= 5 else log.debug
+                lvl("Reconnect fehlgeschlagen (%s, Versuch %d), warte %ss…", e, attempt, delay)
+                # Split sleep so disconnect() breaks the loop faster.
+                slept = 0.0
+                while slept < delay and self._running:
+                    time.sleep(min(0.5, delay - slept))
+                    slept += 0.5
+        return False  # only when disconnect() was called
 
     def _subscribe(self, topic: str):
         with self._lock:
@@ -454,46 +353,34 @@ class KobraXClient:
     def _drain(self):
         buf = self._buf
         idx = 0
-        try:
-            while idx < len(buf):
-                ptype = buf[idx] & 0xF0
-                i = idx + 1
-                mul = 1
-                rem = 0
-                while i < len(buf):
-                    b = buf[i]
-                    rem += (b & 0x7F) * mul
-                    mul *= 128
-                    i += 1
-                    if not (b & 0x80):
-                        break
-                if i + rem > len(buf):
+        while idx < len(buf):
+            ptype = buf[idx] & 0xF0
+            i = idx + 1
+            mul = 1
+            rem = 0
+            while i < len(buf):
+                b = buf[i]
+                rem += (b & 0x7F) * mul
+                mul *= 128
+                i += 1
+                if not (b & 0x80):
                     break
-                pkt = buf[i:i + rem]
-                idx = i + rem
+            if i + rem > len(buf):
+                break
+            pkt = buf[i:i + rem]
+            idx = i + rem
 
-                if ptype == 0x30:
-                    topic, raw_payload = _parse_publish(pkt)
-                    if topic is None:
-                        continue
-                    try:
-                        payload = json.loads(raw_payload)
-                    except Exception:
-                        payload = {"_raw": raw_payload.decode("utf-8", errors="replace")}
-                    try:
-                        self._dispatch(topic, payload)
-                    except Exception as e:
-                        # A single malformed/unexpected message (e.g. valid JSON
-                        # that isn't an object, like a bare number or list) must
-                        # not be reprocessed forever: without this, an exception
-                        # here would skip the buffer-advance below, leaving the
-                        # same bad packet at the front of self._buf so every
-                        # future _drain() call crashes on it again - each one
-                        # forcing a reconnect via the reader loop's exception
-                        # handler, an endless self-inflicted reconnect loop.
-                        log.warning("dispatch error for %s: %s", topic, e)
-        finally:
-            self._buf = buf[idx:]
+            if ptype == 0x30:
+                topic, raw_payload = _parse_publish(pkt)
+                if topic is None:
+                    continue
+                try:
+                    payload = json.loads(raw_payload)
+                except Exception:
+                    payload = {"_raw": raw_payload.decode("utf-8", errors="replace")}
+                self._dispatch(topic, payload)
+
+        self._buf = buf[idx:]
 
     def _dedup_hash(self, suffix: str, payload: dict) -> str:
         """Hash payload ignoring volatile per-tick fields for dedup check."""
@@ -504,14 +391,8 @@ class KobraXClient:
         return hashlib.md5(json.dumps(stable, sort_keys=True).encode(), usedforsecurity=False).hexdigest()
 
     def _dispatch(self, topic: str, payload: dict):
-        if not isinstance(payload, dict):
-            log.warning("dispatch: non-dict payload on %s: %r", topic, payload)
-            return
         suffix = "/".join(topic.split("/")[-2:])
 
-        if self._raw_log:
-            log.info("RX [raw] %s  %s", topic, json.dumps(payload, ensure_ascii=False))
-
         # Structured RX log with dedup suppression
         h = self._dedup_hash(suffix, payload)
         is_dup = self._last_rx_hash.get(suffix) == h
@@ -534,29 +415,18 @@ class KobraXClient:
                 log.info("RX %-25s  state=%-12s  data=%s",
                          suffix, state, json.dumps(payload.get("data"), ensure_ascii=False))
 
-        msgid = payload.get("msgid")
-        with self._pending_lock:
-            report_entry = self._pending_report.get(suffix)
-            msgid_entry  = self._pending_msgid.get(msgid) if msgid else None
-
-        # Resolve by report topic suffix (e.g. "info/report"). If the payload
-        # carries a msgid that doesn't match what this waiter is actually
-        # expecting, it's a stale/late reply for a different, already-timed-out
-        # request that happens to share the same report_key - don't deliver it
-        # to the wrong caller.
-        if report_entry is not None:
-            entry_msgid = report_entry.get("msgid")
-            if not entry_msgid or not msgid or entry_msgid == msgid:
-                report_entry["result"] = payload
-                report_entry["event"].set()
-            else:
-                log.debug("dispatch: msgid mismatch for %s report (waiting=%s, got=%s) - ignoring stale reply",
-                           suffix, entry_msgid, msgid)
+        # Resolve by report topic suffix (e.g. "info/report")
+        if suffix in self._pending_report:
+            entry = self._pending_report[suffix]
+            entry["result"] = payload
+            entry["event"].set()
 
         # Resolve by msgid (for generic response ACK)
-        if msgid_entry is not None:
-            msgid_entry["result"] = payload
-            msgid_entry["event"].set()
+        msgid = payload.get("msgid")
+        if msgid and msgid in self._pending_msgid:
+            entry = self._pending_msgid[msgid]
+            entry["result"] = payload
+            entry["event"].set()
 
         # User callbacks by topic suffix (last two path components)
         if suffix in self.callbacks:
@@ -592,18 +462,13 @@ class KobraXClient:
         # Also register by report topic as fallback for responses without msgid.
         report_key = f"{msg_type}/report"
         event  = threading.Event()
-        # entry carries its own msgid so _dispatch()'s report-suffix path can
-        # confirm a reply actually belongs to THIS request before delivering
-        # it - without that, a late reply for an already-timed-out request A
-        # could be handed to a newer request B waiting on the same report_key.
-        entry  = {"event": event, "result": None, "msgid": msgid}
+        entry  = {"event": event, "result": None}
+        self._pending_msgid[msgid] = entry
+        # Only register report-key waiter if nobody else is waiting on it
         report_registered = False
-        with self._pending_lock:
-            self._pending_msgid[msgid] = entry
-            # Only register report-key waiter if nobody else is waiting on it
-            if report_key not in self._pending_report:
-                self._pending_report[report_key] = entry
-                report_registered = True
+        if report_key not in self._pending_report:
+            self._pending_report[report_key] = entry
+            report_registered = True
 
         topic = self._pub_topic(msg_type)
         # Status poll TX (query/getInfo) is pure noise (every few seconds) ->
@@ -617,38 +482,31 @@ class KobraXClient:
                 self._sock.sendall(_build_publish(topic, payload))
         except Exception as e:
             log.error("send error: %s, reconnecting…", e)
-            with self._pending_lock:
-                self._pending_msgid.pop(msgid, None)
-                if report_registered:
-                    self._pending_report.pop(report_key, None)
-            # Non-blocking: never hang the poll-loop thread inside publish()
-            # while a reconnect is running / during backoff (see _reconnect
-            # docstring) - it must return so kobra_state can flip to "offline".
-            if not self._reconnect(wait_if_in_progress=False, persist=False):
+            self._pending_msgid.pop(msgid, None)
+            if report_registered:
+                self._pending_report.pop(report_key, None)
+            if not self._reconnect():
                 return None
             # retry once after reconnect
             try:
                 with self._lock:
                     self._sock.sendall(_build_publish(topic, payload))
-                with self._pending_lock:
-                    self._pending_msgid[msgid] = entry
-                    if report_registered:
-                        self._pending_report[report_key] = entry
+                self._pending_msgid[msgid] = entry
+                if report_registered:
+                    self._pending_report[report_key] = entry
             except Exception:
                 return None
 
         if timeout <= 0:
-            with self._pending_lock:
-                self._pending_msgid.pop(msgid, None)
-                if report_registered:
-                    self._pending_report.pop(report_key, None)
-            return None
-
-        received = event.wait(timeout)
-        with self._pending_lock:
             self._pending_msgid.pop(msgid, None)
             if report_registered:
                 self._pending_report.pop(report_key, None)
+            return None
+
+        received = event.wait(timeout)
+        self._pending_msgid.pop(msgid, None)
+        if report_registered:
+            self._pending_report.pop(report_key, None)
         if not received:
             return None
         return entry["result"]
@@ -674,11 +532,10 @@ class KobraXClient:
         except Exception as e:
             log.error("web send error: %s, reconnecting…", e)
             # Trigger a reconnect (like publish()); no retry because it is
-            # fire-and-forget - the next call will hit the fresh socket.
-            # Non-blocking for the same reason as publish() (see _reconnect
-            # docstring) - never hang this thread through a backoff loop.
+            # fire-and-forget - the next call will hit the fresh socket
+            # treffen.
             try:
-                self._reconnect(wait_if_in_progress=False, persist=False)
+                self._reconnect()
             except Exception:
                 pass
 
@@ -753,9 +610,7 @@ class KobraXClient:
                 raise RuntimeError("Could not get info/report for upload URL")
             upload_url = info["data"]["urls"]["fileUploadurl"]
         # parse token from URL query string
-        if "?s=" not in upload_url:
-            raise RuntimeError(f"Upload: no session token ('?s=') in upload URL: {upload_url!r}")
-        token = upload_url.split("?s=")[1]
+        token = upload_url.split("?s=")[1] if "?s=" in upload_url else ""
 
         with open(filepath, "rb") as f:
             file_data = f.read()
@@ -805,25 +660,19 @@ class KobraXClient:
         # (the printer processes the file before replying).
         _ai  = socket.getaddrinfo(self.host, 18910, socket.AF_INET, socket.SOCK_STREAM)
         sock = socket.create_connection(_ai[0][4], timeout=10)
+        sock.settimeout(None)  # blocking during send
+        sock.sendall(headers + body)
+        sock.settimeout(180)
+        response = b""
         try:
-            sock.settimeout(None)  # blocking during send
-            sock.sendall(headers + body)
-            sock.settimeout(180)
-            response = b""
-            try:
-                while True:
-                    chunk = sock.recv(65536)
-                    if not chunk:
-                        break
-                    response += chunk
-            except socket.timeout:
-                pass
-        finally:
-            # Without this, a sendall()/recv() failure other than
-            # socket.timeout (e.g. ConnectionResetError/BrokenPipeError if
-            # the printer drops the connection mid-upload) skipped
-            # sock.close() entirely, leaking the fd on every failed attempt.
-            sock.close()
+            while True:
+                chunk = sock.recv(65536)
+                if not chunk:
+                    break
+                response += chunk
+        except socket.timeout:
+            pass
+        sock.close()
 
         # parse HTTP response body
         if b"\r\n\r\n" in response:

kobrax_moonraker_bridge.py

@@ -713,7 +713,7 @@ class CameraCache:
                 await asyncio.sleep(2.0)
                 continue
             try:
-                proc = await asyncio.create_subprocess_exec(
+                self._proc_jpeg = await asyncio.create_subprocess_exec(
                     _find_ffmpeg(), "-loglevel", "warning",
                     *self._input_args(url), "-i", url,
                     "-vf", "fps=2",
@@ -722,7 +722,6 @@ class CameraCache:
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
                 )
-                self._proc_jpeg = proc
             except Exception as e:
                 log.warning(f"CameraCache: ffmpeg-jpeg start failed: {e}")
                 await asyncio.sleep(3.0)
@@ -732,7 +731,7 @@ class CameraCache:
             rc = None
             try:
                 while True:
-                    chunk = await proc.stdout.read(self.TS_CHUNK)
+                    chunk = await self._proc_jpeg.stdout.read(self.TS_CHUNK)
                     if not chunk:
                         break
                     buf += chunk
@@ -752,31 +751,26 @@ class CameraCache:
             except Exception as e:
                 log.debug(f"CameraCache: jpeg-loop unterbrochen: {e}")
             finally:
-                # NOTE: cleanup operates on the local `proc` reference, not on
-                # self._proc_jpeg - see _run_mjpeg_loop's identical comment.
-                # If this task got cancelled (e.g. by reset()), a new task may
-                # already have started and assigned its own process to
-                # self._proc_jpeg by the time we reach here; killing that
-                # shared attribute instead of our own local proc would kill
-                # the WRONG (newer) process and leak this one as an orphan.
-                try:
-                    proc.kill()
-                except Exception:
-                    pass
-                try:
-                    await proc.wait()
-                except Exception:
-                    pass
-                rc = proc.returncode
-                if rc:
+                # Kill + wait - otherwise the child process lingers as a zombie and
+                # asyncio reports "Unknown child pid ..." on the next reaper tick.
+                if self._proc_jpeg is not None:
                     try:
-                        err = await proc.stderr.read(500)
-                        if err:
-                            log.warning(f"CameraCache: ffmpeg-jpeg stderr: {err.decode(errors='replace').strip()}")
+                        self._proc_jpeg.kill()
                     except Exception:
                         pass
-                if self._proc_jpeg is proc:
-                    self._proc_jpeg = None
+                    try:
+                        await self._proc_jpeg.wait()
+                    except Exception:
+                        pass
+                    rc = self._proc_jpeg.returncode
+                    if rc:
+                        try:
+                            err = await self._proc_jpeg.stderr.read(500)
+                            if err:
+                                log.warning(f"CameraCache: ffmpeg-jpeg stderr: {err.decode(errors='replace').strip()}")
+                        except Exception:
+                            pass
+                self._proc_jpeg = None
             if rc:
                 self._fail_count_jpeg += 1
                 delay = min(2.0 * (2 ** self._fail_count_jpeg), 300.0)
@@ -794,7 +788,7 @@ class CameraCache:
                 await asyncio.sleep(2.0)
                 continue
             try:
-                proc = await asyncio.create_subprocess_exec(
+                self._proc_h264 = await asyncio.create_subprocess_exec(
                     _find_ffmpeg(), "-loglevel", "warning",
                     *self._input_args(url), "-i", url,
                     "-c:v", "copy", "-an",
@@ -802,7 +796,6 @@ class CameraCache:
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE,
                 )
-                self._proc_h264 = proc
             except Exception as e:
                 log.warning(f"CameraCache: ffmpeg-h264 start failed: {e}")
                 await asyncio.sleep(3.0)
@@ -811,7 +804,7 @@ class CameraCache:
             rc = None
             try:
                 while True:
-                    chunk = await proc.stdout.read(self.TS_CHUNK)
+                    chunk = await self._proc_h264.stdout.read(self.TS_CHUNK)
                     if not chunk:
                         break
                     # Fanout: non-blocking per subscriber; slow clients
@@ -829,31 +822,24 @@ class CameraCache:
             except Exception as e:
                 log.debug(f"CameraCache: h264-loop unterbrochen: {e}")
             finally:
-                # NOTE: cleanup operates on the local `proc` reference, not on
-                # self._proc_h264 - see _run_mjpeg_loop's identical comment.
-                # If this task got cancelled (e.g. by reset()), a new task may
-                # already have started and assigned its own process to
-                # self._proc_h264 by the time we reach here; killing that
-                # shared attribute instead of our own local proc would kill
-                # the WRONG (newer) process and leak this one as an orphan.
-                try:
-                    proc.kill()
-                except Exception:
-                    pass
-                try:
-                    await proc.wait()
-                except Exception:
-                    pass
-                rc = proc.returncode
-                if rc:
+                if self._proc_h264 is not None:
                     try:
-                        err = await proc.stderr.read(500)
-                        if err:
-                            log.warning(f"CameraCache: ffmpeg-h264 stderr: {err.decode(errors='replace').strip()}")
+                        self._proc_h264.kill()
                     except Exception:
                         pass
-                if self._proc_h264 is proc:
-                    self._proc_h264 = None
+                    try:
+                        await self._proc_h264.wait()
+                    except Exception:
+                        pass
+                    rc = self._proc_h264.returncode
+                    if rc:
+                        try:
+                            err = await self._proc_h264.stderr.read(500)
+                            if err:
+                                log.warning(f"CameraCache: ffmpeg-h264 stderr: {err.decode(errors='replace').strip()}")
+                        except Exception:
+                            pass
+                self._proc_h264 = None
             if rc:
                 self._fail_count_h264 += 1
                 delay = min(2.0 * (2 ** self._fail_count_h264), 300.0)
@@ -1056,8 +1042,6 @@ class KobraXBridge:
           "ace_drying": {"status": 0, "target_temp": 0, "duration": 0, "remain_time": 0, "humidity": None, "current_temp": None},
           "error_code":         0,
           "pause_msg":          "",
-          "storage_total_mb":   0,
-          "storage_used_mb":    0,
         }
         self._ams_slots: list[dict] = []       # flat global list; each entry has global_index + box_id
         self._ams_loaded_slot: int = -1        # global slot index of currently loaded slot
@@ -1078,20 +1062,9 @@ class KobraXBridge:
         # base64 PNG string, "" if the file has no embedded thumbnail).
         # In-memory only - not persisted, cleared on restart.
         self._printer_thumbnail_cache: dict[str, str] = {}
-        # Last buried/report payload (printer's own analytics event, fired once
-        # per print start regardless of slicer - see reference_buried_report_trigger
-        # memory). Carries gcode_size/estimate_duration/total_layers that are
-        # otherwise unavailable for files not uploaded through the bridge itself
-        # (Issue #102). Single entry only - just the most recent print.
-        self._buried_cache: dict | None = None
         self._store = store if store is not None else GCodeStore(args.data_dir)
         self._serve_dir_path: str = self._store._gcode_dir
         self._current_job_id: str = ""
-        # Filename of the file backing _current_job_id, kept alongside it so
-        # the "finished" handler can still delete it from the printer's own
-        # storage (Issue: delete-after-print) after self._state["filename"]
-        # has already been cleared as part of the terminal-state reset below.
-        self._current_job_filename: str = ""
         self._camera_autostarted: bool = False
         self._camera_user_stopped: bool = False  # user manually stopped the camera during a print
         self.camera_cache: CameraCache = CameraCache()
@@ -1140,7 +1113,6 @@ class KobraXBridge:
         client.callbacks["print/report"]          = self._on_print
         client.callbacks["info/report"]           = self._on_info
         client.callbacks["file/report"]           = self._on_file
-        client.callbacks["buried/report"]         = self._on_buried
         client.callbacks["multiColorBox/report"]  = self._on_multicolor_box
         client.callbacks["light/report"]          = self._on_light
         client.callbacks["skip/report"]           = self._on_skip
@@ -1331,7 +1303,7 @@ class KobraXBridge:
         cfg_path = self._find_config_path()
         if not cfg_path.is_file():
             return defaults
-        cfg = configparser.ConfigParser(interpolation=None)
+        cfg = configparser.ConfigParser()
         cfg.read(cfg_path, encoding="utf-8")
         sec = "ace_dry_presets"
         if not cfg.has_section(sec):
@@ -1415,7 +1387,6 @@ class KobraXBridge:
                         gcode_file_id=gf["id"],
                         printer_id=self._printer_id,
                     )
-                    self._current_job_filename = filename
                     log.info(f"Job started: {self._current_job_id} for {filename}")
             self._spoolman_slot_usage = {}
             self._spoolman_slot_reported = {}
@@ -1428,21 +1399,11 @@ class KobraXBridge:
             log.info(f"Job abgeschlossen: {self._current_job_id}")
             self._spoolman_notify_end()
             self._current_job_id = ""
-            # Optional cleanup (Settings -> Print): only for files that are
-            # also backed by the bridge's own GCode store - never for prints
-            # started directly from the printer/Anycubic Slicer, which would
-            # otherwise be deleted with no copy left anywhere (Issue: delete
-            # printer file after successful print). Deliberately only on a
-            # clean "finished" - stoped/canceled prints keep their file.
-            if getattr(self._args, "delete_printer_file_after_print", 0) and self._current_job_filename:
-                self._delete_printer_file_fire_and_forget(self._current_job_filename)
-            self._current_job_filename = ""
         elif kobra_state in ("stoped", "canceled") and self._current_job_id:
             self._store.finish_job(self._current_job_id, status="cancelled")
             log.info(f"Job abgebrochen: {self._current_job_id}")
             self._spoolman_notify_end()
             self._current_job_id = ""
-            self._current_job_filename = ""
 
         # Terminal states (successful finish AND stop/cancel) must leave the
         # same clean end state - a "finished" print used to only clear
@@ -1609,25 +1570,6 @@ class KobraXBridge:
         if payload.get("state") == "done" or payload.get("code") == 200:
             log.info(f"Skip response: state={payload.get('state')} code={payload.get('code')} skipped={skipped}")
 
-    def _delete_printer_file_fire_and_forget(self, filename: str) -> None:
-        """Deletes a file from the printer's own storage without waiting for
-        the response - called from _on_print(), which runs on the MQTT
-        reader thread itself, so blocking here (like _wait_for_file_action
-        does) would deadlock: the file/report reply that would unblock it is
-        dispatched from that same thread. Fire-and-forget is safe because the
-        bridge's own copy in the GCode store is what matters for correctness
-        here; a failed delete just leaves the printer's storage as it is
-        (Settings -> Print -> "Delete file from printer after successful print")."""
-        try:
-            self.client.publish(
-                "file", "deleteBatch",
-                {"root": "local", "files": [{"path": "/", "filename": filename}]},
-                timeout=0,
-            )
-            log.info(f"Requested printer-storage delete for {filename} after successful print")
-        except Exception as e:
-            log.warning(f"Delete-after-print request failed for {filename}: {e}")
-
     def _wait_for_file_action(self, action: str, send_fn, timeout: float = 8.0) -> dict | None:
         """Sends a file/* MQTT request (via send_fn, which must call
         self.client.publish(..., timeout=0) fire-and-forget) and blocks the
@@ -1652,30 +1594,6 @@ class KobraXBridge:
             if self._file_action_waiters.get(action) is waiter:
                 del self._file_action_waiters[action]
 
-    def _on_buried(self, payload: dict):
-        """buried/report - the printer's own analytics event, fired once per
-        print start (verified live against a real Kobra X: fires identically
-        for prints started via Anycubic Slicer Next and via OrcaSlicer/the
-        bridge). Carries gcode_size/estimate_duration/total_layers, which
-        _build_file_metadata() falls back to for files not in our own
-        GCodeStore (Issue #102), plus printer storage usage."""
-        d = payload.get("data") or {}
-        task_name = d.get("task_name") or ""
-        if not task_name:
-            return
-        self._buried_cache = {
-            "task_name": task_name,
-            "gcode_size": int(d.get("gcode_size") or 0),
-            "estimate_duration": int(d.get("estimate_duration") or 0),
-            "total_layers": int(d.get("total_layers") or 0),
-        }
-        self._state["storage_total_mb"] = int(d.get("storage_total") or 0)
-        self._state["storage_used_mb"] = int(d.get("storage_used") or 0)
-        log.info(
-            f"buried/report: {task_name}  size={d.get('gcode_size')}  "
-            f"est={d.get('estimate_duration')}s  layers={d.get('total_layers')}"
-        )
-
     def _on_file(self, payload: dict):
         # Deliver to any pending listLocal/deleteBatch waiter first (see
         # _wait_for_file_action) - these actions carry no file_details/
@@ -2292,32 +2210,12 @@ class KobraXBridge:
             return "", ""
         return vendor, family
 
-    @staticmethod
-    def _rfid_variant_tokens(raw_type: str) -> list[str]:
-        """Tokens after "VENDOR TYPE" in a combined ACE-RFID string (e.g.
-        ["bas"] for "GEEETECH PLA Bas") - the truncated variant/serial that
-        distinguishes multiple profiles of the same (vendor, material family),
-        e.g. "Basic" vs. "Matte". Kept separate from _parse_combined_rfid_type()
-        so that function's 2-tuple signature (and its existing callers/tests)
-        stay unchanged (Issue #101)."""
-        tokens = raw_type.split()
-        return [t.lower() for t in tokens[2:]]
-
-    def _match_profile_by_vendor_family(self, vendor: str, family: str,
-                                         variant_tokens: list[str] | None = None) -> dict:
+    def _match_profile_by_vendor_family(self, vendor: str, family: str) -> dict:
         """Find an imported/system filament profile by (vendor, material
         family) - used to auto-resolve a combined ACE-RFID type string to
         the user's already-imported OrcaSlicer profile (Issue #101), since
         the exact profile `name` never appears verbatim in the truncated
-        RFID string.
-
-        When multiple profiles share the same (vendor, family) - e.g. "Geeetech
-        PLA Basic" and "Geeetech PLA Matte" both matching (Geeetech, PLA) -
-        variant_tokens (the RFID string's remaining tokens, e.g. ["bas"] for
-        "Basic") are scored against each candidate's name: a word-prefix match
-        scores higher than a plain substring match, so "bas" prefers "Basic"
-        over "Matte" or an unrelated profile name containing "bas" as noise.
-        Falls back to the first match when nothing disambiguates."""
+        RFID string."""
         matches = [
             p for p in self._load_orca_filaments()
             if p.get("vendor", "").lower() == vendor.lower()
@@ -2325,28 +2223,12 @@ class KobraXBridge:
         ]
         if not matches:
             return {}
-        if len(matches) == 1 or not variant_tokens:
-            return matches[0]
-
-        best = matches[0]
-        best_score = -1
-        for p in matches:
-            name_words = p.get("name", "").lower().split()
-            score = 0
-            for tok in variant_tokens:
-                if any(w.startswith(tok) for w in name_words):
-                    score += 2
-                elif tok in p.get("name", "").lower():
-                    score += 1
-            if score > best_score:
-                best_score = score
-                best = p
-        log.debug(
-            f"_match_profile_by_vendor_family: {len(matches)} profiles match "
-            f"vendor={vendor!r} family={family!r}, variant_tokens={variant_tokens!r} "
-            f"-> {best.get('name')!r} (score={best_score})"
-        )
-        return best
+        if len(matches) > 1:
+            log.debug(
+                f"_match_profile_by_vendor_family: {len(matches)} profiles match "
+                f"vendor={vendor!r} family={family!r}, using first: {matches[0].get('name')}"
+            )
+        return matches[0]
 
     def _profile_material(self, profile: dict) -> str:
         """Material type (e.g. "PETG") of a saved slot profile, resolved by
@@ -2363,44 +2245,21 @@ class KobraXBridge:
 
     def _effective_slot_profile(self, global_idx: int, ams_material: str) -> dict:
         """Saved slot-profile override — but only while its material *family*
-        still matches the material currently loaded in the AMS. Falls back to
-        auto-resolving a combined ACE-RFID type string (Issue #101) when there
-        is no (usable) manual override.
+        still matches the material currently loaded in the AMS.
 
         Non-destructive suppression (Option A): when the family no longer matches
-        (e.g. a PETG profile but PLA loaded) the override is skipped → falls
-        through to the RFID auto-match / generic default. The override stays in
-        config.ini and reactivates as soon as the matching material is loaded
-        again. When the profile's family is unknown we do NOT suppress (fail-safe).
-
-        Centralized here (rather than duplicated per caller) so every consumer -
-        the dashboard's /kx/filament/slots, Happy-Hare gate data, and the
-        OrcaSlicer lane-data sync - benefits from RFID auto-matching identically,
-        instead of only the one call site that happened to also call
-        _parse_combined_rfid_type() directly."""
-        # A combined ACE-RFID string ("GEEETECH PLA Bas") carries a vendor
-        # prefix that _material_family() alone can't see past (it only
-        # strips known polymer prefixes, so "GEEETECH PLA BAS" resolves to
-        # itself, not "PLA") - resolve the plain material family through the
-        # RFID parser first so the stale-profile guard below compares against
-        # the actual polymer family, not the raw combined string.
-        vendor, family = self._parse_combined_rfid_type(ams_material)
-        plain_material = family or ams_material
-
+        (e.g. a PETG profile but PLA loaded) we return {} → the slot falls back to
+        the generic default. The override stays in config.ini and reactivates as
+        soon as the matching material is loaded again. When the profile's family
+        is unknown we do NOT suppress (fail-safe)."""
         profile = self._filament_profiles.get(global_idx) or {}
-        if profile.get("name"):
-            prof_fam = self._material_family(self._profile_material(profile))
-            ams_fam  = self._material_family(plain_material)
-            if not (prof_fam and ams_fam and prof_fam != ams_fam):
-                return profile
-
-        if vendor:
-            variant_tokens = self._rfid_variant_tokens(ams_material)
-            auto = self._match_profile_by_vendor_family(vendor, family, variant_tokens)
-            if auto.get("name"):
-                return auto
-
-        return {}
+        if not profile.get("name"):
+            return {}
+        prof_fam = self._material_family(self._profile_material(profile))
+        ams_fam  = self._material_family(ams_material)
+        if prof_fam and ams_fam and prof_fam != ams_fam:
+            return {}
+        return profile
 
     def _build_lane_data(self) -> dict:
       """Builds BBL AMS JSON for OrcaSlicer DevFilaSystemParser::ParseV1_0.
@@ -2446,19 +2305,30 @@ class KobraXBridge:
             # The vendor is sent along (tray_sub_brands + filament_vendor),
             # so a patched OrcaSlicer can match by brand + type +
             # color (analogous to SnapmakerPrinterAgent).
-            # Three-layer resolution for the filament hint sent to OrcaSlicer,
-            # all handled inside _effective_slot_profile() (Issue #101):
+            # Two-layer resolution for the filament hint sent to OrcaSlicer:
             #   1. User-Wahl (config.ini [filament_profiles]) — exakte Kontrolle
-            #   2. Combined ACE-RFID "VENDOR TYPE SERIAL" string (e.g.
-            #      "GEEETECH PLA Bas") auto-matched against the user's
-            #      already-imported profile library. Not persisted to
-            #      config.ini - re-derives on every call, so a differently
-            #      tagged spool loaded later isn't stuck with a stale match.
-            #   3. Generic fallback (_TRAY_INFO_IDX) per material type - no
+            #   2. Generic fallback (_TRAY_INFO_IDX) per material type - no
             #      vendor hint; OrcaSlicer then picks its own generic preset
+            # Stale-profile guard: only apply the override while its material
+            # family still matches the loaded filament (PETG profile + PLA
+            # loaded -> dropped).
             user_profile = self._effective_slot_profile(slot_index, material)
+            if not user_profile.get("name"):
+                # Third layer: auto-resolve a combined ACE-RFID "VENDOR TYPE
+                # SERIAL" string (e.g. "GEEETECH PLA Bas", from third-party
+                # RFID tools) against the user's already-imported profile
+                # library, instead of falling through to the neutral Generic
+                # fallback (Issue #101). Not persisted to config.ini - this
+                # re-derives on every _build_lane_data() call, so a
+                # differently-tagged spool loaded later isn't stuck with a
+                # stale match.
+                vendor_guess, family_guess = self._parse_combined_rfid_type(slot.get("type", ""))
+                if vendor_guess:
+                    auto_profile = self._match_profile_by_vendor_family(vendor_guess, family_guess)
+                    if auto_profile.get("name"):
+                        user_profile = auto_profile
+                        material = family_guess
             if user_profile.get("name"):
-                material = self._material_family(user_profile.get("type", material)) or material
                 vendor    = user_profile.get("vendor", "")
                 fila_name = user_profile.get("name", "")
                 tray_info_idx = user_profile.get("id") or self._TRAY_INFO_IDX.get(material, "OGFL99")
@@ -3506,78 +3376,9 @@ class KobraXBridge:
                 "bridge_url": bridge_url,
                 "printer_ip": br._args.printer_ip,
                 "device_id":  br._args.device_id or "",
-                "has_power_control": bool(
-                    (getattr(br._args, "power_on_url", "") or "").strip()
-                    or (getattr(br._args, "power_off_url", "") or "").strip()
-                ),
             })
         return self._json_cors({"result": out})
 
-    async def handle_kx_printer_power(self, request):
-        """Toggles an external smart plug (e.g. Tasmota) for a printer that
-        has no MQTT-level power-off/standby command of its own (Issue #103).
-
-        Just fires a plain HTTP GET at the configured power_on_url/power_off_url -
-        works for Tasmota's cmnd=Power%20on/off style URLs and any other
-        switch that exposes a GET-triggered on/off endpoint."""
-        pid = str(request.match_info.get("pid", "")).strip()
-        br = self._all_bridges.get(pid)
-        if br is None:
-            return self._json_cors({"error": "unknown printer id"}, status=404)
-        try:
-            body = await request.json()
-        except Exception:
-            body = {}
-        action = str(body.get("action", "")).lower()
-        if action not in ("on", "off"):
-            return self._json_cors({"error": "action must be 'on' or 'off'"}, status=400)
-        url = getattr(br._args, f"power_{action}_url", "") or ""
-        if not url:
-            return self._json_cors({"error": f"no power_{action}_url configured"}, status=400)
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(url, timeout=aiohttp.ClientTimeout(total=5)) as resp:
-                    ok = resp.status == 200
-        except Exception as e:
-            return self._json_cors({"error": f"power switch unreachable: {e}"}, status=502)
-        return self._json_cors({"result": "ok" if ok else "error", "status": "on" if action == "on" else "off"})
-
-    async def handle_kx_printer_power_status(self, request):
-        """Queries the configured smart plug for its current on/off state.
-
-        Tries to parse a Tasmota-style {"POWER":"ON"/"OFF"} JSON body first,
-        falls back to a plain substring search for "ON"/"OFF" in the raw
-        response so other switch firmwares with a simpler status endpoint
-        still work."""
-        pid = str(request.match_info.get("pid", "")).strip()
-        br = self._all_bridges.get(pid)
-        if br is None:
-            return self._json_cors({"error": "unknown printer id"}, status=404)
-        url = getattr(br._args, "power_status_url", "") or ""
-        if not url:
-            return self._json_cors({"error": "no power_status_url configured"}, status=400)
-        try:
-            async with aiohttp.ClientSession() as session:
-                async with session.get(url, timeout=aiohttp.ClientTimeout(total=5)) as resp:
-                    text = await resp.text()
-        except Exception as e:
-            return self._json_cors({"error": f"power switch unreachable: {e}"}, status=502)
-        state = "unknown"
-        try:
-            data = json.loads(text)
-            power = str(data.get("POWER", "")).upper()
-            if power in ("ON", "OFF"):
-                state = power.lower()
-        except Exception:
-            pass
-        if state == "unknown":
-            up = text.upper()
-            if "ON" in up and "OFF" not in up:
-                state = "on"
-            elif "OFF" in up:
-                state = "off"
-        return self._json_cors({"state": state})
-
     async def handle_kx_print(self, request):
         """Print start from the GCode store with optional filament assignments."""
         try:
@@ -3644,7 +3445,6 @@ class KobraXBridge:
             printer_id=getattr(self._args, "device_id", "unknown"),
             filament_assignments=assignments,
         )
-        self._current_job_filename = filename
 
         return self._json_cors({"result": "ok", "filename": filename})
 
@@ -3777,18 +3577,6 @@ class KobraXBridge:
             size_bytes = int(gf.get("size_bytes") or 0)
         except Exception:
             pass
-        # Third fallback: the printer's own buried/report analytics event
-        # (fires once per print start regardless of slicer), for files that
-        # are neither the currently-tracked job nor in our own GCodeStore -
-        # e.g. printed directly via Anycubic Slicer Next (Issue #102).
-        buried = self._buried_cache
-        if buried and buried.get("task_name") == filename:
-            if not total_layers:
-                total_layers = buried.get("total_layers") or total_layers
-            if not est_time:
-                est_time = buried.get("estimate_duration") or est_time
-            if not size_bytes:
-                size_bytes = buried.get("gcode_size") or size_bytes
         if not layer_h:
             layer_h = self._layer_height_from_filename(filename)
             if layer_h and not first_h:
@@ -4951,8 +4739,6 @@ class KobraXBridge:
             "version":          self._read_version(),
             "pause_msg":        s.get("pause_msg", ""),
             "error_code":       s.get("error_code", 0),
-            "storage_total_mb": s.get("storage_total_mb", 0),
-            "storage_used_mb":  s.get("storage_used_mb", 0),
         })
 
     async def handle_moonraker_database(self, request):
@@ -5086,15 +4872,11 @@ class KobraXBridge:
             "password":         self._args.password,
             "mode_id":          self._args.mode_id,
             "device_id":        self._args.device_id,
-            "power_on_url":     getattr(self._args, "power_on_url", "") or "",
-            "power_off_url":    getattr(self._args, "power_off_url", "") or "",
-            "power_status_url": getattr(self._args, "power_status_url", "") or "",
             "default_ams_slot": getattr(self._args, "default_ams_slot", "auto"),
             "auto_leveling":          getattr(self._args, "auto_leveling", 1),
             "vibration_compensation": getattr(self._args, "vibration_compensation", 0),
             "camera_on_print":        getattr(self._args, "camera_on_print", 0),
             "web_upload_warning":     getattr(self._args, "web_upload_warning", 1),
-            "delete_printer_file_after_print": getattr(self._args, "delete_printer_file_after_print", 0),
             "print_start_dialog":     getattr(self._args, "print_start_dialog", 1),
             "poll_interval":    getattr(self._args, "poll_interval", 3),
             "verbose_http_log": getattr(self._args, "verbose_http_log", 0),
@@ -5107,15 +4889,12 @@ class KobraXBridge:
 
     async def handle_api_settings_post(self, request):
         import configparser
-        try:
-            data = await request.json()
-        except Exception:
-            return self._json_cors({"error": "invalid json"}, status=400)
+        data = await request.json()
         config_path = self._find_config_path()
         config_path.parent.mkdir(parents=True, exist_ok=True)
 
         # Read the existing config.ini (comments are lost, but values are kept)
-        cfg = configparser.ConfigParser(interpolation=None)
+        cfg = configparser.ConfigParser()
         if config_path.is_file():
             cfg.read(config_path, encoding="utf-8")
 
@@ -5131,15 +4910,11 @@ class KobraXBridge:
         cfg.set("connection", "password",   str(data.get("password",   self._args.password  or "")))
         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 "")))
-        cfg.set("connection", "power_on_url",     str(data.get("power_on_url",     getattr(self._args, "power_on_url", "")     or "")).strip())
-        cfg.set("connection", "power_off_url",    str(data.get("power_off_url",    getattr(self._args, "power_off_url", "")    or "")).strip())
-        cfg.set("connection", "power_status_url", str(data.get("power_status_url", getattr(self._args, "power_status_url", "") or "")).strip())
         cfg.set("print",      "default_ams_slot", str(data.get("default_ams_slot", getattr(self._args, "default_ams_slot", "auto"))))
         cfg.set("print",      "auto_leveling",           str(data.get("auto_leveling",           getattr(self._args, "auto_leveling",           1))))
         cfg.set("print",      "vibration_compensation",  str(int(bool(data.get("vibration_compensation", getattr(self._args, "vibration_compensation", 0))))))
         cfg.set("print",      "camera_on_print",         str(int(bool(data.get("camera_on_print",        getattr(self._args, "camera_on_print",        0))))))
         cfg.set("print",      "web_upload_warning", str(int(bool(data.get("web_upload_warning", getattr(self._args, "web_upload_warning", 1))))))
-        cfg.set("print",      "delete_printer_file_after_print", str(int(bool(data.get("delete_printer_file_after_print", getattr(self._args, "delete_printer_file_after_print", 0))))))
         cfg.set("print",      "print_start_dialog", str(int(bool(data.get("print_start_dialog", getattr(self._args, "print_start_dialog", 1))))))
         if "poll_interval" in data:
             try:
@@ -5204,7 +4979,7 @@ class KobraXBridge:
 
         import configparser
         config_path = self._find_config_path()
-        cfg = configparser.ConfigParser(interpolation=None)
+        cfg = configparser.ConfigParser()
         if config_path.is_file():
             cfg.read(config_path, encoding="utf-8")
 
@@ -5272,7 +5047,7 @@ class KobraXBridge:
 
         import configparser
         config_path = self._find_config_path()
-        cfg = configparser.ConfigParser(interpolation=None)
+        cfg = configparser.ConfigParser()
         if config_path.is_file():
             cfg.read(config_path, encoding="utf-8")
 
@@ -5368,12 +5143,7 @@ class KobraXBridge:
 
     # ─── Update ──────────────────────────────────────────────────────────────
 
-    # limit=1 would only ever see the single newest release regardless of type -
-    # if that happens to be a nightly/dev prerelease (the common case, since
-    # those publish far more often than stable), the stable_releases filter
-    # below finds nothing and update checks fail with "no stable releases
-    # found" even though older stable releases exist (Issue #104).
-    STABLE_RELEASE_API  = "https://gitea.it-drui.de/api/v1/repos/viewit/KX-Bridge-Release/releases?limit=20"
+    STABLE_RELEASE_API  = "https://gitea.it-drui.de/api/v1/repos/viewit/KX-Bridge-Release/releases?limit=1"
     NIGHTLY_RELEASE_API = "https://gitea.it-drui.de/api/v1/repos/viewit/KX-Bridge-Release/releases?limit=5&pre-release=true"
     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"
@@ -5451,21 +5221,6 @@ class KobraXBridge:
 
     async def handle_api_update_check(self, request):
         current = self._read_version()
-        # Testing channel (testing-<sha>) has no Gitea releases at all - it's
-        # a Docker-only channel. Report that directly instead of falling
-        # through to the stable path (which would wrongly offer a stable
-        # "update"). The :testing image is rolling, so there's nothing to
-        # compare a version against.
-        if "testing" in current:
-            return web.json_response({
-                "current":          current,
-                "latest":           current,
-                "update_available": False,
-                "tag":              current,
-                "docker_only":      True,
-                "changelog":        "Testing channel - updates are delivered via Docker: "
-                                    "docker compose pull && docker compose up -d",
-            })
         is_nightly = "nightly" in current
         is_dev = "-dev+" in current
         if is_nightly:
@@ -5545,16 +5300,11 @@ class KobraXBridge:
     ]
 
     async def handle_api_update_apply(self, request):
-        try:
-            data = await request.json()
-        except Exception:
-            return web.json_response({"error": "invalid json"}, status=400)
+        data = await request.json()
         new_tag = data.get("tag", "")
-        _cur = self._read_version()
-        if "nightly" in _cur or "testing" in _cur:
-            channel = "testing" if "testing" in _cur else "nightly"
+        if "nightly" in self._read_version():
             return web.json_response(
-                {"error": f"{channel} updates are delivered via Docker: "
+                {"error": "nightly updates are delivered via Docker: "
                           "docker compose pull && docker compose up -d"}, status=400)
         if getattr(sys, "frozen", False):
             return web.json_response(
@@ -5958,25 +5708,6 @@ class KobraXBridge:
                 info = self.client.query_info()
                 if info:
                     self._on_info(info)
-                elif not self.client.is_connected():
-                    # publish() swallows send/reconnect failures internally and
-                    # just returns None (Issue #105) - a falsy `info` alone
-                    # doesn't distinguish "printer sent nothing this tick" from
-                    # "the MQTT session itself is dead". Check is_connected()
-                    # explicitly so a dead session gets routed into the same
-                    # clean offline/reconnect path as a TCP-unreachable printer,
-                    # instead of silently retrying every poll_interval forever.
-                    log.warning("MQTT connection lost (query returned no response) - switching to offline mode")
-                    self._state["print_state"] = "error"
-                    self._state["kobra_state"] = "offline"
-                    self._state["connection_error"] = f"MQTT connection lost ({self._args.printer_ip})"
-                    try:
-                        self.client.disconnect()
-                    except Exception:
-                        pass
-                    _offline = True
-                    stop_event.wait(getattr(self._args, "poll_interval", 3))
-                    continue
                 # While printing: query print/report directly
                 if self._state["print_state"] in ("printing", "preheating",
                                                    "auto_leveling", "checking", "init"):
@@ -6129,8 +5860,6 @@ def build_app(bridge: KobraXBridge) -> web.Application:
     r.add_get("/kx/printers",              bridge.handle_kx_printers)
     r.add_post("/kx/printers/add",         bridge.handle_kx_printer_add)
     r.add_delete("/kx/printers/{pid}",     bridge.handle_kx_printer_remove)
-    r.add_post("/kx/printers/{pid}/power",        bridge.handle_kx_printer_power)
-    r.add_get("/kx/printers/{pid}/power-status",  bridge.handle_kx_printer_power_status)
     r.add_post("/kx/print",               bridge.handle_kx_print)
     r.add_get("/kx/files",                bridge.handle_kx_files)
     r.add_delete("/kx/files/{file_id}",    bridge.handle_kx_file_delete)
@@ -6186,9 +5915,6 @@ def _build_per_printer_args(base_args, p: dict):
     a.mode_id    = p.get("mode_id")   or base_args.mode_id
     a.device_id  = p.get("device_id") or base_args.device_id
     a.port       = int(p.get("http_port") or base_args.port)
-    a.power_on_url     = p.get("power_on_url")     or getattr(base_args, "power_on_url", "")     or ""
-    a.power_off_url    = p.get("power_off_url")    or getattr(base_args, "power_off_url", "")    or ""
-    a.power_status_url = p.get("power_status_url") or getattr(base_args, "power_status_url", "") or ""
     return a
 
 
@@ -6331,21 +6057,11 @@ def main():
     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("--power-on-url",     default=env_loader.POWER_ON_URL,
-                        help="HTTP GET URL to power the printer on (e.g. a Tasmota smart plug)")
-    parser.add_argument("--power-off-url",    default=env_loader.POWER_OFF_URL,
-                        help="HTTP GET URL to power the printer off")
-    parser.add_argument("--power-status-url", default=env_loader.POWER_STATUS_URL,
-                        help="HTTP GET URL returning the smart plug's current on/off state")
     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("--vibration-compensation",  type=int, default=env_loader.VIBRATION_COMPENSATION)
     parser.add_argument("--camera-on-print",         type=int, default=env_loader.CAMERA_ON_PRINT)
     parser.add_argument("--web-upload-warning", type=int, default=env_loader.WEB_UPLOAD_WARNING)
-    parser.add_argument("--delete-printer-file-after-print", type=int,
-                        default=env_loader.DELETE_PRINTER_FILE_AFTER_PRINT,
-                        help="After a successful print, delete the file from the printer's "
-                             "own storage if it's also in the bridge's own GCode store")
     parser.add_argument("--print-start-dialog", dest="print_start_dialog", type=int, default=env_loader.PRINT_START_DIALOG)
     parser.add_argument("--file-ready-dialog",  dest="print_start_dialog", type=int)
     parser.add_argument("--spoolman-server",    default=env_loader.SPOOLMAN_SERVER,

orca_filaments.py

@@ -9,11 +9,8 @@ them as a normalized list with (id, name, vendor, type, color).
 from __future__ import annotations
 
 import json
-import logging
 import re
 
-log = logging.getLogger("kobrax.filaments")
-
 
 def first_str(value, default: str = "") -> str:
     """Orca profiles store some fields as ['value']. Returns the first
@@ -72,17 +69,7 @@ def parse_profile(data: dict, by_name: dict | None = None,
     if system_index:
         for p in system_index:
             if isinstance(p, dict) and p.get("name"):
-                pname = p["name"]
-                if pname in sys_by_name and sys_by_name[pname] is not p:
-                    # clean_name() deliberately collapses variant-suffixed
-                    # names (e.g. "...@base" vs "...@Anycubic Kobra X 0.4
-                    # nozzle") onto the same cleaned name - expected, but the
-                    # last-write-wins overwrite here was previously silent,
-                    # making an unexpected inherits-parent resolution hard to
-                    # debug.
-                    log.debug("orca_filaments: duplicate system profile name %r - "
-                              "overwriting %r with %r", pname, sys_by_name[pname].get("id"), p.get("id"))
-                sys_by_name[pname] = p
+                sys_by_name[p["name"]] = p
 
     def _resolve(key: str, depth: int = 5):
         cur_list = [data]
@@ -132,7 +119,7 @@ def parse_profile(data: dict, by_name: dict | None = None,
     if not fid or not isinstance(fid, str):
         return None
 
-    name_raw = first_str(data.get("name"), fid)
+    name_raw = data.get("name", fid)
     name = clean_name(name_raw)
     vendor = first_str(_resolve_full("filament_vendor")) or (path_vendor or "Generic")
     ftype  = first_str(_resolve_full("filament_type"), "")

tests/test_ace_rfid_vendor_matching.py

@@ -109,128 +109,3 @@ def test_build_lane_data_plain_type_still_uses_generic_fallback():
     tray = lane["ams"][0]["tray"][0]
     assert tray["name"] == "Generic PLA"
     assert tray["vendor_name"] == "Generic"
-
-
-# ─── Centralized matching via _effective_slot_profile() ────────────────────
-#
-# The bug reported in Issue #101 by @Blaim (nightly45 not working, despite
-# _parse_combined_rfid_type()/_match_profile_by_vendor_family() existing):
-# those two helpers were ONLY ever invoked inside _build_lane_data(), which
-# is only reached when OrcaSlicer polls the Moonraker lane_data endpoint -
-# never as part of the real MQTT receive path (_on_multicolor_box ->
-# self._ams_slots -> _push_status_update -> dashboard / /kx/filament/slots).
-# So the dashboard and the Happy-Hare gate data never saw a match, matching
-# exactly what the user's screenshots showed. Fixed by moving the matching
-# logic into _effective_slot_profile() itself, which all three consumers
-# already call.
-
-def test_effective_slot_profile_auto_resolves_raw_rfid_string_without_override():
-    """The core Issue #101 regression: _effective_slot_profile() itself (not
-    just _build_lane_data()) must resolve a combined RFID string when there is
-    no manual per-slot override in config.ini."""
-    b = _bridge()
-    b._filament_profiles = {}
-    profile = b._effective_slot_profile(0, "GEEETECH PLA Bas")
-    assert profile.get("name") == "Geeetech PLA Basic"
-    assert profile.get("vendor") == "Geeetech"
-
-
-def test_effective_slot_profile_manual_override_still_wins():
-    b = _bridge()
-    b._filament_profiles = {0: {"id": "OGFL99", "name": "Generic PLA", "vendor": "Generic"}}
-    profile = b._effective_slot_profile(0, "GEEETECH PLA Bas")
-    assert profile.get("name") == "Generic PLA"
-
-
-def test_effective_slot_profile_plain_type_no_override_returns_empty():
-    """Regression guard: a plain type="PLA" slot with no override must still
-    fall through to {} (the caller's own generic-name fallback), not be
-    treated as an RFID string."""
-    b = _bridge()
-    b._filament_profiles = {}
-    assert b._effective_slot_profile(0, "PLA") == {}
-
-
-def _multicolor_box_report(raw_type: str, color=(238, 190, 152)) -> dict:
-    """A realistic multiColorBox/report payload for one ACE box (id=0) with
-    a toolhead (id=-1), matching the real Kobra X topology captured live
-    during Issue #100/#101 investigation - drives _detect_filament_mode()
-    to "ace_hub", same as on real hardware."""
-    return {
-        "state": "success",
-        "data": {
-            "head_tools_model": 1,
-            "multi_color_box": [
-                {
-                    "id": -1, "loaded_slot": -1,
-                    "slots": [{"index": 0, "status": 0, "type": "", "color": [0, 0, 0]}],
-                },
-                {
-                    "id": 0, "loaded_slot": -1,
-                    "slots": [
-                        {"index": 0, "status": 0, "type": "", "color": [0, 0, 0]},
-                        {"index": 1, "status": 0, "type": "", "color": [0, 0, 0]},
-                        {
-                            "index": 2, "status": 5, "type": raw_type,
-                            "color": list(color), "sku": "",
-                        },
-                        {"index": 3, "status": 0, "type": "", "color": [0, 0, 0]},
-                    ],
-                },
-            ],
-        },
-    }
-
-
-def test_on_multicolor_box_end_to_end_resolves_rfid_slot_for_dashboard():
-    """End-to-end regression test for Issue #101: feed a raw MQTT
-    multiColorBox/report payload through the real receive path
-    (_on_multicolor_box), then check that the dashboard-facing
-    /kx/filament/slots data (handle_kx_filament_slots) - which is what
-    populates the dashboard's window._slotProfileMap in the browser -
-    actually reflects the matched profile, not the raw "GEEETECH PLA Bas"
-    string. This is the exact path that was broken and untested before."""
-    b = _bridge()
-    b._filament_profiles = {}
-    b._on_multicolor_box(_multicolor_box_report("GEEETECH PLA Bas"))
-
-    assert b._filament_mode == "ace_hub"
-    # global_index 6 = box_id 0 * 4 + local slot 2 in ace_hub mode's ACE block
-    slot = next(s for s in b._ams_slots if s.get("type") == "GEEETECH PLA Bas")
-    global_idx = slot["global_index"]
-
-    profile = b._effective_slot_profile(global_idx, slot["type"])
-    assert profile.get("name") == "Geeetech PLA Basic"
-    assert profile.get("vendor") == "Geeetech"
-
-
-def test_match_profile_by_vendor_family_disambiguates_via_variant_tokens():
-    """Issue #101 follow-up (@Blaim): two profiles of the same vendor+family
-    ("Geeetech PLA Basic" vs. "Geeetech PLA Matte") must resolve to the one
-    matching the RFID string's truncated variant token ("bas" -> Basic),
-    not just "whichever loads first"."""
-    profiles = USER_PROFILES + [
-        {"id": "GTPLA03", "name": "Geeetech PLA Matte", "vendor": "Geeetech", "type": "PLA", "color": "", "is_user": True},
-    ]
-    b = _bridge(profiles)
-
-    basic = b._match_profile_by_vendor_family("Geeetech", "PLA", ["bas"])
-    assert basic.get("name") == "Geeetech PLA Basic"
-
-    matte = b._match_profile_by_vendor_family("Geeetech", "PLA", ["mat"])
-    assert matte.get("name") == "Geeetech PLA Matte"
-
-
-def test_match_profile_by_vendor_family_no_variant_tokens_falls_back_to_first():
-    profiles = USER_PROFILES + [
-        {"id": "GTPLA03", "name": "Geeetech PLA Matte", "vendor": "Geeetech", "type": "PLA", "color": "", "is_user": True},
-    ]
-    b = _bridge(profiles)
-    profile = b._match_profile_by_vendor_family("Geeetech", "PLA")
-    assert profile.get("name") == "Geeetech PLA Basic"
-
-
-def test_rfid_variant_tokens_extracts_tokens_after_vendor_and_family():
-    assert KobraXBridge._rfid_variant_tokens("GEEETECH PLA Bas") == ["bas"]
-    assert KobraXBridge._rfid_variant_tokens("GEEETECH PLA") == []
-    assert KobraXBridge._rfid_variant_tokens("PLA") == []

tests/test_buried_report.py

@@ -1,111 +0,0 @@
-"""
-Tests für buried/report — das druckerseitige Analytics-Event, das einmal pro
-Druckstart feuert (verifiziert live gegen einen echten Kobra X, sowohl für
-Anycubic Slicer Next als auch für OrcaSlicer/die Bridge selbst). Liefert
-gcode_size/estimate_duration/total_layers, die server/files/metadata für
-Dateien außerhalb des eigenen GCodeStore sonst nicht hat (Issue #102).
-"""
-import pytest
-
-
-BURIED_PAYLOAD = {
-    "type": "buried",
-    "action": "PrintStart",
-    "code": 200,
-    "state": "done",
-    "data": {
-        "task_name": "Smileys_simple_plate(01)_PLA_0.2_16m39s.gcode",
-        "gcode_size": 644437,
-        "estimate_duration": 1264,
-        "total_layers": 8,
-        "storage_total": 6481,
-        "storage_used": 898,
-        "slicer": "OrcaSlicer",
-    },
-}
-
-
-def test_on_buried_populates_cache(client):
-    _, bridge = client
-    bridge._on_buried(BURIED_PAYLOAD)
-    assert bridge._buried_cache == {
-        "task_name": "Smileys_simple_plate(01)_PLA_0.2_16m39s.gcode",
-        "gcode_size": 644437,
-        "estimate_duration": 1264,
-        "total_layers": 8,
-    }
-
-
-def test_on_buried_populates_storage_state(client):
-    _, bridge = client
-    bridge._on_buried(BURIED_PAYLOAD)
-    assert bridge._state["storage_total_mb"] == 6481
-    assert bridge._state["storage_used_mb"] == 898
-
-
-def test_on_buried_ignores_payload_without_task_name(client):
-    _, bridge = client
-    bridge._buried_cache = None
-    bridge._on_buried({"type": "buried", "data": {"gcode_size": 123}})
-    assert bridge._buried_cache is None
-
-
-def test_build_file_metadata_uses_buried_fallback_for_unknown_file(client):
-    """A file not in the GCodeStore and not the currently-tracked job should
-    still get real size/estimated_time/layer_count from the buried cache."""
-    _, bridge = client
-    bridge._on_buried(BURIED_PAYLOAD)
-    meta = bridge._build_file_metadata("Smileys_simple_plate(01)_PLA_0.2_16m39s.gcode")
-    assert meta["size"] == 644437
-    assert meta["estimated_time"] == 1264
-    assert meta["layer_count"] == 8
-
-
-def test_build_file_metadata_ignores_buried_cache_for_different_file(client):
-    """The buried cache must only apply when task_name matches the queried
-    filename - otherwise it would leak the last print's data into an
-    unrelated query, the exact bug Issue #102 already fixed for live state."""
-    _, bridge = client
-    bridge._on_buried(BURIED_PAYLOAD)
-    meta = bridge._build_file_metadata("some_other_file.gcode")
-    assert meta["size"] == 1  # unchanged fallback, not leaked from buried cache
-    assert meta["estimated_time"] is None
-    assert meta["layer_count"] is None
-
-
-def test_build_file_metadata_prefers_gcodestore_over_buried(client):
-    """GCodeStore data (from the bridge's own upload) must win over the
-    buried cache when both are available for the same filename."""
-    _, bridge = client
-    bridge._on_buried(BURIED_PAYLOAD)
-    with bridge._store._lock:
-        bridge._store._conn.execute(
-            "INSERT INTO gcode_files (id, filename, path, size_bytes, uploaded_at, layer_count, est_print_time_sec) "
-            "VALUES (?,?,?,?,?,?,?)",
-            ("f1", "Smileys_simple_plate(01)_PLA_0.2_16m39s.gcode", "/tmp/f1", 999999, "2026-01-01T00:00:00Z", 42, 5000),
-        )
-        bridge._store._conn.commit()
-    meta = bridge._build_file_metadata("Smileys_simple_plate(01)_PLA_0.2_16m39s.gcode")
-    assert meta["size"] == 999999
-    assert meta["estimated_time"] == 5000
-    assert meta["layer_count"] == 42
-
-
-@pytest.mark.asyncio
-async def test_api_state_reports_storage_after_buried_report(client):
-    c, bridge = client
-    bridge._on_buried(BURIED_PAYLOAD)
-    resp = await c.get("/api/state")
-    assert resp.status == 200
-    data = await resp.json()
-    assert data["storage_total_mb"] == 6481
-    assert data["storage_used_mb"] == 898
-
-
-@pytest.mark.asyncio
-async def test_api_state_storage_defaults_to_zero(client):
-    c, _ = client
-    resp = await c.get("/api/state")
-    data = await resp.json()
-    assert data["storage_total_mb"] == 0
-    assert data["storage_used_mb"] == 0

tests/test_camera_process_race.py

@@ -1,83 +0,0 @@
-"""Camera ffmpeg process-handle race (code review finding).
-
-_run_jpeg_loop()/_run_h264_loop() used to operate on the shared instance
-attribute (self._proc_jpeg / self._proc_h264) in their cleanup, instead of a
-local reference to the process they themselves started - the same bug
-_run_mjpeg_loop() already had fixed with a documented local-`proc` pattern.
-
-If a loop's task is cancelled (e.g. via CameraCache.reset() after a stream
-URL rotation) while a new task has already started and assigned its own
-process to the shared attribute, the cancelled task's cleanup would kill
-and null out the NEWER process instead of its own - leaking its own actual
-ffmpeg child as an orphan that nothing ever cleans up again.
-"""
-import asyncio
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from kobrax_moonraker_bridge import CameraCache
-
-
-def _fake_proc(name):
-    """A minimal stand-in for asyncio.subprocess.Process good enough to
-    drive _run_jpeg_loop()'s read/kill/wait/returncode usage."""
-    proc = MagicMock(name=name)
-    proc.returncode = 0
-    proc.kill = MagicMock()
-    proc.wait = AsyncMock()
-    proc.stdout = MagicMock()
-    proc.stderr = MagicMock()
-    proc.stderr.read = AsyncMock(return_value=b"")
-    return proc
-
-
-@pytest.mark.asyncio
-async def test_jpeg_loop_cleanup_does_not_kill_a_newer_process():
-    cache = CameraCache()
-    cache._url = "http://printer/live/streamtoken"
-
-    old_proc = _fake_proc("old")
-    new_proc = _fake_proc("new")
-
-    # old_proc's stdout.read blocks forever until cancelled - simulating the
-    # loop being stuck reading from a stale connection, same as the real bug.
-    stuck = asyncio.Event()
-
-    async def old_stdout_read(_n):
-        await stuck.wait()
-        return b""
-
-    old_proc.stdout.read = old_stdout_read
-
-    create_calls = []
-
-    async def fake_create_subprocess_exec(*args, **kwargs):
-        create_calls.append(1)
-        return old_proc if len(create_calls) == 1 else new_proc
-
-    with patch("kobrax_moonraker_bridge.asyncio.create_subprocess_exec",
-               side_effect=fake_create_subprocess_exec), \
-         patch("kobrax_moonraker_bridge._find_ffmpeg", return_value="ffmpeg"):
-        task = asyncio.create_task(cache._run_jpeg_loop())
-        # Let the loop start and assign old_proc to the shared attribute.
-        await asyncio.sleep(0.05)
-        assert cache._proc_jpeg is old_proc
-
-        # Simulate a second loop iteration's process already having been
-        # assigned to the shared attribute before the cancelled task's
-        # cleanup runs - the exact race window from the bug report.
-        cache._proc_jpeg = new_proc
-
-        task.cancel()
-        try:
-            await asyncio.wait_for(task, timeout=2.0)
-        except (asyncio.CancelledError, asyncio.TimeoutError):
-            pass
-
-    # The cancelled task must have killed/waited on ITS OWN process (old_proc),
-    # not the newer one that had already taken over the shared attribute.
-    old_proc.kill.assert_called_once()
-    new_proc.kill.assert_not_called()
-    # And it must not have clobbered the newer process's slot.
-    assert cache._proc_jpeg is new_proc

tests/test_client_robustness.py

@@ -1,189 +0,0 @@
-"""Robustness fixes found during a targeted code review of kobrax_client.py:
-
-1. _drain()/_dispatch() must not get stuck reprocessing the same malformed
-   packet forever when the printer sends valid JSON that isn't an object
-   (e.g. a bare number or list) - previously an exception from _dispatch()
-   escaped before self._buf was advanced, so the same bytes sat at the
-   front of the buffer and crashed every subsequent _drain() call, each one
-   forcing a reconnect via the reader loop's exception handler.
-2. publish()'s pending-dict registration/cleanup must be safe against
-   concurrent callers for the same msg_type, and a stale/late reply must
-   not be delivered to a newer, unrelated caller waiting on the same
-   report-topic suffix.
-3. upload_gcode() must raise a clear error for a malformed upload URL
-   (missing "?s=") instead of silently sending an unauthenticated request,
-   and must not leak the upload socket on a send/recv failure.
-"""
-import argparse
-import json
-import socket
-import tempfile
-import threading
-import time
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from kobrax_client import KobraXClient, _build_publish
-
-
-def _client(**overrides):
-    kwargs = dict(
-        host="192.168.1.100", username="u", password="p",
-        mode_id="20030", device_id="abc123", port=9883,
-        client_id="test",
-    )
-    kwargs.update(overrides)
-    return KobraXClient(**kwargs)
-
-
-def _frame(topic: str, payload) -> bytes:
-    """Builds a raw MQTT PUBLISH frame carrying `payload` as JSON, the same
-    wire format _drain() parses."""
-    return _build_publish(topic, json.dumps(payload))
-
-
-# --- Fix 1: malformed (non-dict) JSON payload must not wedge the buffer ---
-
-def test_drain_advances_buffer_past_non_dict_payload():
-    c = _client()
-    # A bare JSON number is valid JSON but not a dict - json.loads succeeds,
-    # but _dispatch()'s dict-oriented logic would previously crash on it.
-    bad = _frame("anycubic/anycubicCloud/v1/printer/public/20030/abc123/info/report", 42)
-    good = _frame("anycubic/anycubicCloud/v1/printer/public/20030/abc123/info/report", {"state": "done"})
-    c._buf = bad + good
-
-    c._drain()  # must not raise
-
-    # Both packets must have been consumed - the malformed one logged/skipped,
-    # the buffer advanced past it so the following valid packet is also
-    # processed, not left stuck behind it.
-    assert c._buf == b""
-
-
-def test_drain_does_not_reprocess_bad_packet_on_repeated_calls():
-    """Regression guard for the original bug: before the fix, a crash in
-    _dispatch() left self._buf untouched, so the bad packet stayed at the
-    front and every _drain() call re-crashed on it."""
-    c = _client()
-    bad = _frame("anycubic/anycubicCloud/v1/printer/public/20030/abc123/info/report", [1, 2, 3])
-    c._buf = bad
-
-    c._drain()
-    assert c._buf == b""  # consumed, not stuck
-
-    # A second call on the now-empty buffer must be a no-op, not a re-crash.
-    c._drain()
-    assert c._buf == b""
-
-
-def test_dispatch_rejects_non_dict_payload_directly():
-    c = _client()
-    c._dispatch("anycubic/anycubicCloud/v1/printer/public/20030/abc123/info/report", "not a dict")
-    # No exception, no registered pending entries get corrupted.
-    assert c._pending_report == {}
-
-
-# --- Fix 2: pending-dict thread-safety + msgid correlation ---
-
-def test_publish_concurrent_same_msg_type_both_get_delivered():
-    """Two overlapping publish() calls for the same msg_type must each
-    receive their OWN reply, not have one silently miss out because the
-    other already claimed the shared report_key slot."""
-    c = _client()
-    c._running = True
-    c._sock = MagicMock()
-    c._ensure_reader = lambda: None  # no real reader thread needed for this test
-
-    results = {}
-
-    def call(label):
-        results[label] = c.publish("info", "query", timeout=2.0)
-
-    t1 = threading.Thread(target=call, args=("a",))
-    t2 = threading.Thread(target=call, args=("b",))
-    t1.start()
-    time.sleep(0.02)
-    t2.start()
-    time.sleep(0.05)
-
-    # Simulate the printer replying to whichever msgid-bearing requests are
-    # currently pending, by msgid (the reliable path both requests can use).
-    with c._pending_lock:
-        pending = dict(c._pending_msgid)
-    for msgid, entry in pending.items():
-        c._dispatch("anycubic/anycubicCloud/v1/printer/public/20030/abc123/info/report",
-                    {"msgid": msgid, "state": "done", "data": {"ok": True}})
-
-    t1.join(timeout=3)
-    t2.join(timeout=3)
-
-    assert results["a"] is not None
-    assert results["b"] is not None
-
-
-def test_dispatch_ignores_stale_reply_with_mismatched_msgid():
-    """A late reply carrying a msgid that doesn't match what the current
-    report_key waiter is expecting must not be delivered to it - it belongs
-    to an earlier, already-resolved/timed-out request."""
-    c = _client()
-    c._running = True
-    c._sock = MagicMock()
-
-    event = threading.Event()
-    entry = {"event": event, "result": None, "msgid": "the-real-one"}
-    with c._pending_lock:
-        c._pending_report["info/report"] = entry
-
-    # A stale reply for a different msgid must not resolve this waiter.
-    c._dispatch("anycubic/anycubicCloud/v1/printer/public/20030/abc123/info/report",
-                {"msgid": "some-other-stale-id", "state": "done"})
-    assert not event.is_set()
-    assert entry["result"] is None
-
-    # The matching reply must resolve it.
-    c._dispatch("anycubic/anycubicCloud/v1/printer/public/20030/abc123/info/report",
-                {"msgid": "the-real-one", "state": "done"})
-    assert event.is_set()
-    assert entry["result"]["msgid"] == "the-real-one"
-
-
-def test_dispatch_delivers_reply_without_msgid_as_before():
-    """Regression guard: plenty of printer reports carry no msgid at all
-    (e.g. spontaneous status pushes) - those must still resolve a waiter
-    registered without one (entry["msgid"] is falsy)."""
-    c = _client()
-    event = threading.Event()
-    entry = {"event": event, "result": None, "msgid": None}
-    with c._pending_lock:
-        c._pending_report["info/report"] = entry
-
-    c._dispatch("anycubic/anycubicCloud/v1/printer/public/20030/abc123/info/report",
-                {"state": "done"})
-    assert event.is_set()
-
-
-# --- Fix 3: upload_gcode() URL validation + socket cleanup ---
-
-def test_upload_gcode_raises_clear_error_on_missing_session_token(tmp_path):
-    c = _client()
-    f = tmp_path / "test.gcode"
-    f.write_text("; gcode")
-
-    with pytest.raises(RuntimeError, match="session token"):
-        c.upload_gcode(str(f), upload_url="http://192.168.1.100:18910/gcode_upload")
-
-
-def test_upload_gcode_closes_socket_on_send_failure(tmp_path):
-    c = _client()
-    f = tmp_path / "test.gcode"
-    f.write_text("; gcode")
-
-    fake_sock = MagicMock()
-    fake_sock.sendall.side_effect = ConnectionResetError("printer went away")
-
-    with patch("socket.create_connection", return_value=fake_sock):
-        with pytest.raises(ConnectionResetError):
-            c.upload_gcode(str(f), upload_url="http://192.168.1.100:18910/gcode_upload?s=tok123")
-
-    fake_sock.close.assert_called_once()

tests/test_config_loader_robustness.py

@@ -1,66 +0,0 @@
-"""config_loader.py robustness fixes found during code review:
-
-1. _safe_int() must fall back to a default instead of raising - the
-   module-level numeric shortcuts (MQTT_PORT, POLL_INTERVAL, etc.) run this
-   at import time, so an uncaught ValueError there previously crashed the
-   entire bridge on startup if config.ini had a typo'd numeric value
-   (e.g. "mqtt_port = 98833x"), with a raw traceback instead of a clear
-   diagnostic. list_printers() already guarded this same class of input the
-   same way; this applies it to the module-level shortcuts too.
-2. migrate_env_to_config() must log a clear error (not a bare traceback)
-   if writing the migrated config.ini fails (e.g. permission error).
-"""
-import subprocess
-import sys
-import textwrap
-
-import config_loader
-
-
-def test_safe_int_returns_value_for_valid_numeric_string():
-    assert config_loader._safe_int("42", 0) == 42
-
-
-def test_safe_int_falls_back_to_default_on_garbage():
-    assert config_loader._safe_int("98833x", 9883) == 9883
-
-
-def test_safe_int_falls_back_to_default_on_empty_string():
-    assert config_loader._safe_int("", 3) == 3
-
-
-def test_safe_int_falls_back_to_default_on_none():
-    assert config_loader._safe_int(None, 5) == 5
-
-
-def test_config_loader_import_survives_malformed_config_ini(tmp_path):
-    """End-to-end regression guard: importing config_loader with a
-    config.ini containing a non-numeric mqtt_port must not raise - it must
-    fall back to the default instead. Run in a subprocess since
-    config_loader executes its migration/loading logic at import time and
-    Python caches modules, so a plain re-import in this test process
-    wouldn't actually re-exercise the import-time code path."""
-    config_dir = tmp_path / "config"
-    config_dir.mkdir()
-    (config_dir / "config.ini").write_text(
-        "[connection]\n"
-        "printer_ip = 192.168.1.50\n"
-        "mqtt_port = 98833x\n"  # malformed - not a number
-    )
-
-    script = textwrap.dedent(f"""
-        import sys
-        sys.path.insert(0, {str(tmp_path.parent.parent)!r})
-        import config_loader
-        config_loader._BASE = __import__("pathlib").Path({str(tmp_path)!r})
-        config_loader._find_config_file = lambda: {str(config_dir / "config.ini")!r} \
-            and __import__("pathlib").Path({str(config_dir / "config.ini")!r})
-        import importlib
-        importlib.reload(config_loader)
-        assert config_loader.MQTT_PORT == 9883, config_loader.MQTT_PORT
-        print("OK")
-    """)
-
-    result = subprocess.run([sys.executable, "-c", script], capture_output=True, text=True, timeout=10)
-    assert result.returncode == 0, f"stdout={result.stdout!r} stderr={result.stderr!r}"
-    assert "OK" in result.stdout

tests/test_delete_printer_file_after_print.py

@@ -1,157 +0,0 @@
-"""Optional auto-delete of a printed file from the printer's own storage
-after a successful print (Settings -> Print -> "Delete file from printer
-after successful print").
-
-Only applies to files that are also backed by the bridge's own GCode store
-(otherwise the file would be gone with no copy left anywhere) and only on a
-clean "finished" state - not on stoped/canceled prints, and never when the
-setting is off (the default).
-"""
-import argparse
-import tempfile
-from unittest.mock import MagicMock
-
-from kobrax_moonraker_bridge import GCodeStore, KobraXBridge
-
-
-def _bridge(delete_after_print=1):
-    c = MagicMock()
-    c.callbacks = {}
-    c.connected = False
-    args = argparse.Namespace(
-        printer_ip="", mqtt_port=9883, username="", password="",
-        mode_id="20030", device_id="", host="127.0.0.1", port=7125,
-        data_dir=tempfile.mkdtemp(prefix="kxdelafterprint-"),
-        delete_printer_file_after_print=delete_after_print,
-    )
-    store = GCodeStore(args.data_dir)
-    b = KobraXBridge(c, args=args, store=store)
-    return b, c
-
-
-def _seed_file(bridge, filename="test.gcode"):
-    file_id = "abc123"
-    bridge._store.save_file(file_id, filename, b"; gcode content")
-    return file_id
-
-
-def _print_report(state, filename=None):
-    payload = {"state": state, "data": {}}
-    if filename is not None:
-        payload["data"]["filename"] = filename
-    return payload
-
-
-def test_finished_print_deletes_printer_file_when_enabled_and_in_store():
-    b, c = _bridge(delete_after_print=1)
-    _seed_file(b, "test.gcode")
-
-    b._on_print(_print_report("printing", "test.gcode"))
-    assert b._current_job_id
-    assert b._current_job_filename == "test.gcode"
-
-    b._on_print(_print_report("finished"))
-
-    delete_calls = [
-        call for call in c.publish.call_args_list
-        if call.args[:2] == ("file", "deleteBatch")
-    ]
-    assert len(delete_calls) == 1
-    payload = delete_calls[0].args[2]
-    assert payload == {"root": "local", "files": [{"path": "/", "filename": "test.gcode"}]}
-
-
-def test_finished_print_no_delete_when_setting_disabled():
-    b, c = _bridge(delete_after_print=0)
-    _seed_file(b, "test.gcode")
-
-    b._on_print(_print_report("printing", "test.gcode"))
-    b._on_print(_print_report("finished"))
-
-    delete_calls = [
-        call for call in c.publish.call_args_list
-        if call.args[:2] == ("file", "deleteBatch")
-    ]
-    assert delete_calls == []
-
-
-def test_finished_print_no_delete_when_file_not_in_bridge_store():
-    """Files started directly from the printer/Anycubic Slicer aren't in the
-    bridge's own GCode store - must never be deleted, since that would leave
-    no copy anywhere."""
-    b, c = _bridge(delete_after_print=1)
-    # No _seed_file() call - the file is not in the store.
-
-    b._on_print(_print_report("printing", "not_in_store.gcode"))
-    assert not b._current_job_id  # no store match -> no job tracked either
-
-    b._on_print(_print_report("finished"))
-
-    delete_calls = [
-        call for call in c.publish.call_args_list
-        if call.args[:2] == ("file", "deleteBatch")
-    ]
-    assert delete_calls == []
-
-
-def test_canceled_print_does_not_delete_file():
-    """Only a clean "finished" triggers the delete - a stopped/canceled
-    print keeps its file, since the user may want to retry it."""
-    b, c = _bridge(delete_after_print=1)
-    _seed_file(b, "test.gcode")
-
-    b._on_print(_print_report("printing", "test.gcode"))
-    b._on_print(_print_report("canceled"))
-
-    delete_calls = [
-        call for call in c.publish.call_args_list
-        if call.args[:2] == ("file", "deleteBatch")
-    ]
-    assert delete_calls == []
-    assert b._current_job_filename == ""
-
-
-def test_stoped_print_does_not_delete_file():
-    b, c = _bridge(delete_after_print=1)
-    _seed_file(b, "test.gcode")
-
-    b._on_print(_print_report("printing", "test.gcode"))
-    b._on_print(_print_report("stoped"))
-
-    delete_calls = [
-        call for call in c.publish.call_args_list
-        if call.args[:2] == ("file", "deleteBatch")
-    ]
-    assert delete_calls == []
-
-
-def test_current_job_filename_reset_after_finished():
-    """Regression guard: _current_job_filename must not leak into the next
-    print's finished-handling if that next print isn't itself tracked."""
-    b, c = _bridge(delete_after_print=1)
-    _seed_file(b, "test.gcode")
-
-    b._on_print(_print_report("printing", "test.gcode"))
-    b._on_print(_print_report("finished"))
-    assert b._current_job_filename == ""
-
-    # A second "finished" with no new job in between must not re-trigger a delete.
-    c.publish.reset_mock()
-    b._on_print(_print_report("finished"))
-    delete_calls = [
-        call for call in c.publish.call_args_list
-        if call.args[:2] == ("file", "deleteBatch")
-    ]
-    assert delete_calls == []
-
-
-def test_delete_publish_failure_does_not_raise():
-    """A broken MQTT send during the delete request must not propagate out
-    of _on_print() - it runs on the MQTT reader thread, and an unhandled
-    exception there would break processing of subsequent messages."""
-    b, c = _bridge(delete_after_print=1)
-    _seed_file(b, "test.gcode")
-    c.publish.side_effect = RuntimeError("send failed")
-
-    b._on_print(_print_report("printing", "test.gcode"))
-    b._on_print(_print_report("finished"))  # must not raise

tests/test_mqtt_reconnect.py

@@ -1,152 +0,0 @@
-"""
-Tests für den MQTT-Reconnect-Mechanismus (Issue #105) — der Client hing nach
-einem Drucker-Reconnect fest, weil zwei unabhängige Fehlerpfade (der Reader-
-Thread-Keepalive und publish()'s eigener Reconnect-Trigger) unkoordiniert
-parallel liefen, UND weil der Poll-Loop einen None-Rückgabewert von publish()
-(statt einer Exception) nie als "Verbindung tot" erkannte.
-"""
-import threading
-import time
-
-import pytest
-
-from kobrax_client import KobraXClient
-
-
-def _client(**overrides):
-    kwargs = dict(
-        host="192.168.1.100", username="u", password="p",
-        mode_id="20030", device_id="abc123", port=9883,
-        client_id="test",
-    )
-    kwargs.update(overrides)
-    return KobraXClient(**kwargs)
-
-
-def test_is_connected_false_when_no_socket():
-    c = _client()
-    assert c.is_connected() is False
-
-
-def test_is_connected_true_when_socket_present():
-    c = _client()
-    c._sock = object()  # any truthy stand-in for a real socket
-    assert c.is_connected() is True
-
-
-def test_reconnect_concurrent_calls_only_run_do_connect_once():
-    """Two threads calling _reconnect() at the same time must not both run
-    _do_connect() - only one handshake should happen; the second caller waits
-    for the first instead of racing it (Issue #105)."""
-    c = _client()
-    c._running = True
-    do_connect_calls = []
-    call_lock = threading.Lock()
-    release_event = threading.Event()
-
-    def fake_do_connect():
-        with call_lock:
-            do_connect_calls.append(1)
-        # Simulate a slow handshake so the second _reconnect() call has time
-        # to observe the lock as already held.
-        release_event.wait(timeout=2.0)
-        c._sock = object()
-
-    c._do_connect = fake_do_connect
-
-    results = []
-
-    def run():
-        results.append(c._reconnect())
-
-    t1 = threading.Thread(target=run)
-    t2 = threading.Thread(target=run)
-    t1.start()
-    time.sleep(0.05)  # let t1 acquire the lock and enter _do_connect first
-    t2.start()
-    time.sleep(0.1)
-    release_event.set()  # let the in-flight handshake finish
-    t1.join(timeout=3)
-    t2.join(timeout=3)
-
-    assert len(do_connect_calls) == 1
-    assert results == [True, True]
-
-
-def test_reconnect_second_waiter_returns_after_first_completes():
-    c = _client()
-    c._running = True
-
-    def fake_do_connect():
-        time.sleep(0.1)
-        c._sock = object()
-
-    c._do_connect = fake_do_connect
-
-    t1 = threading.Thread(target=c._reconnect)
-    t1.start()
-    time.sleep(0.02)
-    # Second call while the first is still mid-handshake.
-    result = c._reconnect()
-    t1.join(timeout=3)
-
-    assert result is True
-    assert c._sock is not None
-
-
-def test_reconnect_non_blocking_returns_immediately_while_reconnect_in_progress():
-    """The poll-loop path (publish/publish_web) must NOT block while the reader
-    thread's persistent reconnect is running its multi-minute backoff loop -
-    it has to return so the poll loop can flip kobra_state to "offline".
-    A printer unplugged mid-connection otherwise left the dashboard stuck on
-    the last known state indefinitely (Issue #103 follow-up)."""
-    c = _client()
-    c._running = True
-    started = threading.Event()
-    release = threading.Event()
-
-    def slow_persistent_do_connect():
-        started.set()
-        # Simulate the printer still being gone: never succeeds until released.
-        release.wait(timeout=5.0)
-        raise OSError("still unreachable")
-
-    c._do_connect = slow_persistent_do_connect
-
-    # First reconnect (reader-thread style): persistent, holds the lock, stuck
-    # in backoff.
-    t1 = threading.Thread(target=lambda: c._reconnect(persist=True), daemon=True)
-    t1.start()
-    assert started.wait(timeout=2.0)
-
-    # Poll-loop style call must return basically instantly, not block on t1.
-    t0 = time.time()
-    result = c._reconnect(wait_if_in_progress=False, persist=False)
-    elapsed = time.time() - t0
-
-    assert elapsed < 0.5, f"non-blocking reconnect blocked for {elapsed:.2f}s"
-    assert result is False  # socket is down while the other reconnect churns
-
-    release.set()  # let the daemon thread unwind
-
-
-def test_reconnect_one_shot_does_not_loop_on_failure():
-    """persist=False must attempt the handshake at most once and return,
-    instead of entering the backoff loop (which would block the caller)."""
-    c = _client()
-    c._running = True
-    attempts = []
-
-    def failing_do_connect():
-        attempts.append(1)
-        raise OSError("unreachable")
-
-    c._do_connect = failing_do_connect
-
-    t0 = time.time()
-    result = c._reconnect(persist=False)
-    elapsed = time.time() - t0
-
-    assert result is False
-    assert len(attempts) == 1  # exactly one attempt, no backoff retries
-    assert elapsed < 0.5

tests/test_orca_filaments_parser.py

@@ -1,182 +0,0 @@
-"""orca_filaments.py parser robustness (code review finding).
-
-No dedicated test file existed for parse_profile()/parse_profile_bytes()/
-clean_name() before this - existing tests only used pre-parsed profile dicts
-as fixtures, never exercised the actual parsing logic.
-"""
-import json
-import logging
-
-from orca_filaments import clean_name, first_str, parse_profile, parse_profile_bytes
-
-
-def test_clean_name_strips_base_suffix():
-    assert clean_name("PolyTerra PLA @base") == "PolyTerra PLA"
-
-
-def test_clean_name_strips_printer_and_nozzle_suffix():
-    assert clean_name("Anycubic PLA @Anycubic Kobra X 0.4 nozzle") == "Anycubic PLA"
-
-
-def test_clean_name_strips_bare_nozzle_suffix():
-    assert clean_name("Anker Generic PLA 0.4 nozzle") == "Anker Generic PLA"
-
-
-def test_clean_name_returns_raw_when_stripping_leaves_nothing():
-    """An all-suffix name has nothing left after stripping - falls back to
-    the original raw string rather than returning an empty string."""
-    assert clean_name("@base") == "@base"
-
-
-def test_first_str_unwraps_single_element_list():
-    assert first_str(["PLA"]) == "PLA"
-
-
-def test_first_str_passes_through_plain_string():
-    assert first_str("PLA") == "PLA"
-
-
-def test_first_str_returns_default_for_empty_list():
-    assert first_str([], "fallback") == "fallback"
-
-
-def test_first_str_returns_default_for_other_types():
-    assert first_str(42, "fallback") == "fallback"
-    assert first_str(None, "fallback") == "fallback"
-
-
-def test_parse_profile_rejects_non_dict():
-    assert parse_profile([1, 2, 3]) is None
-    assert parse_profile("not a dict") is None
-    assert parse_profile(None) is None
-
-
-def test_parse_profile_rejects_stub_without_id_or_parent():
-    data = {"type": "filament"}  # no inherits, no filament_id
-    assert parse_profile(data) is None
-
-
-def test_parse_profile_rejects_instantiation_false():
-    data = {"type": "filament", "filament_id": "GFL01", "instantiation": "false"}
-    assert parse_profile(data) is None
-
-
-def test_parse_profile_minimal_valid_profile():
-    data = {
-        "type": "filament",
-        "filament_id": "GFL01",
-        "name": "Generic PLA",
-        "filament_vendor": ["Generic"],
-        "filament_type": ["PLA"],
-        "default_filament_colour": ["#FFFFFF"],
-    }
-    result = parse_profile(data)
-    assert result == {
-        "id": "GFL01",
-        "name": "Generic PLA",
-        "vendor": "Generic",
-        "type": "PLA",
-        "color": "#FFFFFF",
-    }
-
-
-def test_parse_profile_name_as_list_does_not_crash():
-    """Regression guard: `name` wasn't previously routed through first_str()
-    like the other fields are, unlike filament_vendor/filament_type/
-    default_filament_colour just below it - a list value here used to raise
-    TypeError inside clean_name()'s re.sub()."""
-    data = {
-        "type": "filament",
-        "filament_id": "GFL02",
-        "name": ["Geeetech PLA Basic"],
-        "filament_vendor": ["Geeetech"],
-        "filament_type": ["PLA"],
-    }
-    result = parse_profile(data)
-    assert result is not None
-    assert result["name"] == "Geeetech PLA Basic"
-
-
-def test_parse_profile_missing_name_falls_back_to_filament_id():
-    data = {"type": "filament", "filament_id": "GFL03", "filament_vendor": ["Generic"]}
-    result = parse_profile(data)
-    assert result["name"] == "GFL03"
-
-
-def test_parse_profile_missing_optional_fields_default_to_empty_string():
-    data = {"type": "filament", "filament_id": "GFL04", "name": "Mystery Filament"}
-    result = parse_profile(data)
-    assert result["type"] == ""
-    assert result["color"] == ""
-    assert result["vendor"] == "Generic"  # no path_vendor given either
-
-
-def test_parse_profile_inherits_via_by_name():
-    parent = {"type": "filament", "filament_id": "GFL05", "filament_vendor": ["Geeetech"], "filament_type": ["PLA"]}
-    child = {"type": "filament", "inherits": "Geeetech PLA @base", "name": "Geeetech PLA Basic"}
-    by_name = {"Geeetech PLA @base": [parent]}
-    result = parse_profile(child, by_name=by_name)
-    assert result is not None
-    assert result["id"] == "GFL05"
-    assert result["vendor"] == "Geeetech"
-    assert result["type"] == "PLA"
-
-
-def test_parse_profile_inherits_via_system_index():
-    system_index = [{
-        "id": "GFL06", "name": "Geeetech PLA", "vendor": "Geeetech", "type": "PLA", "color": "",
-    }]
-    user_profile = {"type": "filament", "inherits": "Geeetech PLA @base", "name": "My Geeetech Override"}
-    result = parse_profile(user_profile, system_index=system_index)
-    assert result is not None
-    assert result["id"] == "GFL06"
-    assert result["vendor"] == "Geeetech"
-
-
-def test_parse_profile_inherits_cycle_does_not_infinite_loop():
-    """A inherits B, B inherits A - _resolve()'s hard depth=5 bound must
-    terminate this rather than recursing forever."""
-    a = {"type": "filament", "inherits": "B"}
-    b = {"type": "filament", "inherits": "A"}
-    by_name = {"A": [a], "B": [b]}
-    # Neither profile has a filament_id anywhere in the cycle - must return
-    # None (not hang, not crash) after exhausting the depth limit.
-    result = parse_profile(a, by_name=by_name)
-    assert result is None
-
-
-def test_parse_profile_duplicate_system_names_logs_and_uses_last(caplog):
-    """clean_name() deliberately collapses variant-suffixed names onto the
-    same cleaned name - sys_by_name's last-write-wins overwrite on collision
-    is expected, but must now be observable via a debug log instead of
-    silent."""
-    system_index = [
-        {"id": "GFL07", "name": "PolyTerra PLA", "vendor": "Polymaker", "type": "PLA", "color": ""},
-        {"id": "GFL08", "name": "PolyTerra PLA", "vendor": "Polymaker", "type": "PLA", "color": ""},
-    ]
-    user_profile = {"type": "filament", "inherits": "PolyTerra PLA @base", "name": "Override"}
-    with caplog.at_level(logging.DEBUG, logger="kobrax.filaments"):
-        result = parse_profile(user_profile, system_index=system_index)
-    assert result is not None
-    assert result["id"] == "GFL08"  # last one wins, as before
-    assert any("duplicate system profile name" in r.message for r in caplog.records)
-
-
-def test_parse_profile_bytes_valid_json():
-    blob = json.dumps({
-        "type": "filament", "filament_id": "GFL09", "name": "Test PLA",
-        "filament_vendor": ["Test"], "filament_type": ["PLA"],
-    }).encode("utf-8")
-    result = parse_profile_bytes(blob)
-    assert result is not None
-    assert result["id"] == "GFL09"
-
-
-def test_parse_profile_bytes_malformed_json_returns_none():
-    assert parse_profile_bytes(b"{not valid json") is None
-
-
-def test_parse_profile_bytes_non_dict_json_returns_none():
-    assert parse_profile_bytes(b"[1, 2, 3]") is None
-    assert parse_profile_bytes(b'"just a string"') is None
-    assert parse_profile_bytes(b"42") is None

tests/test_poll_loop_reconnect.py

@@ -1,96 +0,0 @@
-"""
-Tests für _poll_loop's Umgang mit einer toten MQTT-Session (Issue #105).
-publish()/query_info() swallow send failures internally and return None
-instead of raising - the poll loop must treat that (combined with
-is_connected() == False) as "connection lost" and switch to the offline
-branch, instead of silently retrying forever every poll_interval.
-"""
-import argparse
-import tempfile
-import threading
-import time
-from unittest.mock import MagicMock
-
-import pytest
-
-from kobrax_moonraker_bridge import KobraXBridge
-
-
-def _bridge():
-    c = MagicMock()
-    c.callbacks = {}
-    c.connected = False
-    args = argparse.Namespace(
-        printer_ip="192.168.1.100", mqtt_port=9883, username="", password="",
-        mode_id="20030", device_id="", host="127.0.0.1", port=7125,
-        data_dir=tempfile.mkdtemp(prefix="kxpoll-"), poll_interval=0.05,
-    )
-    return KobraXBridge(c, args=args)
-
-
-def test_poll_loop_switches_to_offline_when_query_returns_none_and_disconnected():
-    b = _bridge()
-    b._state["print_state"] = "standby"
-    b._state["kobra_state"] = "free"
-    b.client.query_info.return_value = None
-    b.client.is_connected.return_value = False
-    b._printer_reachable = MagicMock(return_value=True)  # TCP still fine
-
-    stop_event = threading.Event()
-    t = threading.Thread(target=b._poll_loop, args=(stop_event,), daemon=True)
-    t.start()
-    time.sleep(0.2)
-    stop_event.set()
-    t.join(timeout=2)
-
-    assert b._state["kobra_state"] == "offline"
-    b.client.disconnect.assert_called()
-
-
-def test_poll_loop_stays_online_when_query_returns_none_but_still_connected():
-    """A single missed poll tick (info momentarily falsy) must not flip the
-    bridge offline if the MQTT session itself is still alive."""
-    b = _bridge()
-    b._state["print_state"] = "standby"
-    b._state["kobra_state"] = "free"
-    b.client.query_info.return_value = None
-    b.client.is_connected.return_value = True  # session still up
-    b.client.query_multicolor_box.return_value = None
-    b._printer_reachable = MagicMock(return_value=True)
-
-    stop_event = threading.Event()
-    t = threading.Thread(target=b._poll_loop, args=(stop_event,), daemon=True)
-    t.start()
-    time.sleep(0.2)
-    stop_event.set()
-    t.join(timeout=2)
-
-    assert b._state["kobra_state"] != "offline"
-
-
-def test_poll_loop_recovers_via_offline_branch_once_reachable_again():
-    """Once flipped offline, the existing offline branch should re-connect
-    as soon as the printer becomes reachable again (pre-existing behavior,
-    unaffected by this fix)."""
-    b = _bridge()
-    b._state["print_state"] = "standby"
-    b._state["kobra_state"] = "free"
-    b.client.query_info.return_value = None
-    b.client.is_connected.return_value = False
-    b._printer_reachable = MagicMock(return_value=True)
-
-    stop_event = threading.Event()
-    t = threading.Thread(target=b._poll_loop, args=(stop_event,), daemon=True)
-    t.start()
-    time.sleep(0.15)  # let it flip offline
-    assert b._state["kobra_state"] == "offline"
-
-    # Printer "comes back": client.connect() succeeds, subsequent query_info
-    # starts returning real data again.
-    b.client.connect.side_effect = None
-    b.client.query_info.return_value = {"data": {"state": "free"}}
-    time.sleep(0.2)
-    stop_event.set()
-    t.join(timeout=2)
-
-    b.client.connect.assert_called()

tests/test_printer_power.py

@@ -1,175 +0,0 @@
-"""External smart-plug power control (Issue #103).
-
-The printer itself has no MQTT command to power off or enter standby - only
-heaters/motors/etc. can be controlled remotely. For users running the
-printer through a Tasmota-style smart plug, the bridge exposes plain
-HTTP GET on/off/status URLs (configured per printer) as its own dashboard
-button, instead of routing through Moonraker's device_power API.
-"""
-import argparse
-import tempfile
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-import pytest_asyncio
-from aiohttp.test_utils import TestClient, TestServer
-
-from kobrax_moonraker_bridge import KobraXBridge, build_app
-
-
-def _make_bridge(pid="1", **arg_overrides):
-    c = MagicMock()
-    c.callbacks = {}
-    c.connected = False
-    args = argparse.Namespace(
-        printer_ip="192.168.1.50", mqtt_port=9883, username="", password="",
-        mode_id="20030", device_id="", host="127.0.0.1", port=7125,
-        data_dir=tempfile.mkdtemp(prefix="kxpower-"),
-        power_on_url="", power_off_url="", power_status_url="",
-    )
-    for k, v in arg_overrides.items():
-        setattr(args, k, v)
-    all_bridges = {}
-    bridge = KobraXBridge(c, args=args, printer_id=pid, all_bridges=all_bridges)
-    all_bridges[pid] = bridge
-    return bridge
-
-
-@pytest_asyncio.fixture
-async def power_client():
-    bridge = _make_bridge(
-        power_on_url="http://192.168.1.99/cm?cmnd=Power%20on",
-        power_off_url="http://192.168.1.99/cm?cmnd=Power%20off",
-        power_status_url="http://192.168.1.99/cm?cmnd=Power",
-    )
-    app = build_app(bridge)
-    async with TestClient(TestServer(app)) as c:
-        yield c, bridge
-
-
-def _fake_get_response(status=200, text=""):
-    resp = MagicMock()
-    resp.status = status
-    resp.text = AsyncMock(return_value=text)
-    ctx = MagicMock()
-    ctx.__aenter__ = AsyncMock(return_value=resp)
-    ctx.__aexit__ = AsyncMock(return_value=False)
-    return ctx
-
-
-@pytest.mark.asyncio
-async def test_printers_list_reports_has_power_control(power_client):
-    c, bridge = power_client
-    resp = await c.get("/kx/printers")
-    data = await resp.json()
-    assert data["result"][0]["has_power_control"] is True
-
-
-@pytest.mark.asyncio
-async def test_printers_list_no_power_control_when_unconfigured():
-    bridge = _make_bridge()
-    app = build_app(bridge)
-    async with TestClient(TestServer(app)) as c:
-        resp = await c.get("/kx/printers")
-        data = await resp.json()
-        assert data["result"][0]["has_power_control"] is False
-
-
-@pytest.mark.asyncio
-async def test_power_on_hits_configured_url(power_client):
-    c, bridge = power_client
-    with patch("aiohttp.ClientSession.get", return_value=_fake_get_response(200)) as mock_get:
-        resp = await c.post("/kx/printers/1/power", json={"action": "on"})
-        data = await resp.json()
-    assert resp.status == 200
-    assert data["result"] == "ok"
-    mock_get.assert_called_once()
-    assert mock_get.call_args[0][0] == "http://192.168.1.99/cm?cmnd=Power%20on"
-
-
-@pytest.mark.asyncio
-async def test_power_off_hits_configured_url(power_client):
-    c, bridge = power_client
-    with patch("aiohttp.ClientSession.get", return_value=_fake_get_response(200)) as mock_get:
-        resp = await c.post("/kx/printers/1/power", json={"action": "off"})
-        data = await resp.json()
-    assert resp.status == 200
-    assert data["result"] == "ok"
-    assert mock_get.call_args[0][0] == "http://192.168.1.99/cm?cmnd=Power%20off"
-
-
-@pytest.mark.asyncio
-async def test_power_invalid_action_rejected(power_client):
-    c, bridge = power_client
-    resp = await c.post("/kx/printers/1/power", json={"action": "toggle"})
-    assert resp.status == 400
-
-
-@pytest.mark.asyncio
-async def test_power_unknown_printer_id_404(power_client):
-    c, bridge = power_client
-    resp = await c.post("/kx/printers/99/power", json={"action": "on"})
-    assert resp.status == 404
-
-
-@pytest.mark.asyncio
-async def test_power_missing_url_configured_error():
-    bridge = _make_bridge()  # no power_on_url set
-    app = build_app(bridge)
-    async with TestClient(TestServer(app)) as c:
-        resp = await c.post("/kx/printers/1/power", json={"action": "on"})
-        assert resp.status == 400
-
-
-@pytest.mark.asyncio
-async def test_power_switch_unreachable_returns_502(power_client):
-    c, bridge = power_client
-    with patch("aiohttp.ClientSession.get", side_effect=OSError("connection refused")):
-        resp = await c.post("/kx/printers/1/power", json={"action": "on"})
-    assert resp.status == 502
-
-
-@pytest.mark.asyncio
-async def test_power_status_parses_tasmota_json(power_client):
-    c, bridge = power_client
-    with patch("aiohttp.ClientSession.get", return_value=_fake_get_response(200, '{"POWER":"ON"}')):
-        resp = await c.get("/kx/printers/1/power-status")
-        data = await resp.json()
-    assert data["state"] == "on"
-
-
-@pytest.mark.asyncio
-async def test_power_status_parses_tasmota_json_off(power_client):
-    c, bridge = power_client
-    with patch("aiohttp.ClientSession.get", return_value=_fake_get_response(200, '{"POWER":"OFF"}')):
-        resp = await c.get("/kx/printers/1/power-status")
-        data = await resp.json()
-    assert data["state"] == "off"
-
-
-@pytest.mark.asyncio
-async def test_power_status_falls_back_to_plain_text(power_client):
-    c, bridge = power_client
-    with patch("aiohttp.ClientSession.get", return_value=_fake_get_response(200, "STATE: ON")):
-        resp = await c.get("/kx/printers/1/power-status")
-        data = await resp.json()
-    assert data["state"] == "on"
-
-
-@pytest.mark.asyncio
-async def test_power_status_missing_url_configured_error():
-    bridge = _make_bridge()  # no power_status_url set
-    app = build_app(bridge)
-    async with TestClient(TestServer(app)) as c:
-        resp = await c.get("/kx/printers/1/power-status")
-        assert resp.status == 400
-
-
-@pytest.mark.asyncio
-async def test_settings_roundtrip_persists_power_urls(power_client):
-    c, bridge = power_client
-    resp = await c.get("/api/settings")
-    data = await resp.json()
-    assert data["power_on_url"] == "http://192.168.1.99/cm?cmnd=Power%20on"
-    assert data["power_off_url"] == "http://192.168.1.99/cm?cmnd=Power%20off"
-    assert data["power_status_url"] == "http://192.168.1.99/cm?cmnd=Power"

tests/test_settings.py

@@ -39,15 +39,6 @@ async def test_settings_get_returns_configured_values(client_configured):
     assert data["device_id"]  == "abc123deadbeef"
 
 
-@pytest.mark.asyncio
-async def test_settings_post_invalid_json_returns_400(client):
-    """A malformed/non-JSON body must be a clean 400, not an unhandled 500
-    with a raw JSONDecodeError traceback (code review finding)."""
-    c, _ = client
-    resp = await c.post("/api/settings", data=b"not json", headers={"Content-Type": "application/json"})
-    assert resp.status == 400
-
-
 @pytest.mark.asyncio
 async def test_settings_post_writes_config_ini(client):
     """POST /api/settings schreibt Werte in config.ini (Migration von .env, v0.9.x)."""

tests/test_tcp_keepalive.py

@@ -1,80 +0,0 @@
-"""TCP keepalive + TCP_USER_TIMEOUT on the MQTT socket (Issue #103 follow-up).
-
-Without these, a printer that disappears without a clean TCP close
-(unplugged, not gracefully shut down) leaves the socket looking alive to
-is_connected() for as long as the OS's default dead-connection timeout -
-often 15+ minutes on Linux - since sendall() on a half-open connection is
-buffered by the kernel and doesn't fail immediately. This left the
-dashboard's printer-state indicator stuck showing the last known state
-(e.g. green "ready") long after the printer was actually unreachable,
-reported when testing the smart-plug power-switch feature by physically
-unplugging the printer.
-
-Verified live (real printer, physically unplugged) that SO_KEEPALIVE alone
-is not sufficient: keepalive probes only fire on an idle connection, but if
-the printer disappears while a send is still unacknowledged - the normal
-case, since the poll loop is sending every few seconds - the kernel's
-regular TCP retransmission timer takes over instead (tcp_retries2, 13-30+
-minutes on Linux), which keepalive settings don't affect. TCP_USER_TIMEOUT
-closes that gap by capping how long ANY unacknowledged data may sit in the
-send queue, regardless of which retry mechanism would otherwise still be
-running.
-"""
-import socket
-from unittest.mock import MagicMock
-
-import pytest
-
-from kobrax_client import _enable_tcp_keepalive
-
-
-def test_enable_tcp_keepalive_sets_so_keepalive():
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    try:
-        _enable_tcp_keepalive(s)
-        assert s.getsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE) == 1
-    finally:
-        s.close()
-
-
-@pytest.mark.skipif(not hasattr(socket, "TCP_KEEPIDLE"), reason="Linux-specific option")
-def test_enable_tcp_keepalive_sets_short_idle_and_interval():
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    try:
-        _enable_tcp_keepalive(s)
-        idle = s.getsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE)
-        intvl = s.getsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL)
-        cnt = s.getsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPCNT)
-        # Short enough that a dead connection is detected within a couple of
-        # poll cycles (default poll_interval is 3s), not the OS default of
-        # minutes.
-        assert idle <= 10
-        assert intvl <= 5
-        assert cnt <= 5
-    finally:
-        s.close()
-
-
-@pytest.mark.skipif(not hasattr(socket, "TCP_USER_TIMEOUT"), reason="Linux-specific option")
-def test_enable_tcp_keepalive_sets_user_timeout():
-    """The critical fix, verified live against a real printer: without this,
-    a dead connection with unacknowledged data in flight is only detected
-    after the OS's normal TCP retransmission timeout (13-30+ minutes on
-    Linux), not the keepalive interval."""
-    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    try:
-        _enable_tcp_keepalive(s)
-        user_timeout_ms = s.getsockopt(socket.IPPROTO_TCP, socket.TCP_USER_TIMEOUT)
-        # Short enough that a dead connection with in-flight data is detected
-        # within a couple of poll cycles, not tens of minutes.
-        assert 0 < user_timeout_ms <= 20000
-    finally:
-        s.close()
-
-
-def test_enable_tcp_keepalive_does_not_raise_on_unsupported_platform():
-    """A platform without TCP_KEEPIDLE/INTVL/CNT (e.g. some Windows builds)
-    must not crash the connection attempt - keepalive is best-effort."""
-    s = MagicMock()
-    s.setsockopt.side_effect = OSError("unsupported")
-    _enable_tcp_keepalive(s)  # must not raise

tests/test_update_check.py

@@ -1,100 +0,0 @@
-"""Update-check regression for Issue #104.
-
-STABLE_RELEASE_API used limit=1, so it only ever saw the single newest
-release on Gitea regardless of type. Since nightly/dev prereleases publish
-far more often than stable releases, that newest release is almost always a
-prerelease - the stable_releases filter (not prerelease) then found nothing
-and /api/update/check returned "no stable releases found" even though older
-stable releases exist.
-"""
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-
-@pytest.mark.asyncio
-async def test_update_apply_invalid_json_returns_400(client):
-    """A malformed/non-JSON body must be a clean 400, not an unhandled 500
-    with a raw JSONDecodeError traceback (code review finding)."""
-    c, _ = client
-    resp = await c.post("/api/update/apply", data=b"not json", headers={"Content-Type": "application/json"})
-    assert resp.status == 400
-
-
-@pytest.mark.asyncio
-async def test_update_check_testing_channel_is_docker_only(client):
-    """A testing-<sha> build has no Gitea releases at all - the check must
-    report a docker-only channel with nothing to update, NOT fall through to
-    the stable path and wrongly offer a stable "update". Must not even call
-    the Gitea API."""
-    c, bridge = client
-    bridge._read_version = lambda: "testing-2e4dbf0"
-
-    with patch("aiohttp.ClientSession.get") as mock_get:
-        resp = await c.get("/api/update/check")
-        data = await resp.json()
-
-    assert resp.status == 200
-    assert data["update_available"] is False
-    assert data["docker_only"] is True
-    assert data["current"] == "testing-2e4dbf0"
-    mock_get.assert_not_called()  # no Gitea round-trip for the testing channel
-
-
-@pytest.mark.asyncio
-async def test_update_apply_testing_channel_blocked(client):
-    """Self-update must be refused on the testing channel, same as nightly -
-    testing images are delivered via Docker only."""
-    c, bridge = client
-    bridge._read_version = lambda: "testing-2e4dbf0"
-
-    resp = await c.post("/api/update/apply", json={"tag": "whatever"})
-    data = await resp.json()
-    assert resp.status == 400
-    assert "testing" in data["error"]
-    assert "docker" in data["error"].lower()
-
-
-def _fake_releases_response(payload):
-    resp = MagicMock()
-    resp.status = 200
-    resp.json = AsyncMock(return_value=payload)
-    ctx = MagicMock()
-    ctx.__aenter__ = AsyncMock(return_value=resp)
-    ctx.__aexit__ = AsyncMock(return_value=False)
-    return ctx
-
-
-@pytest.mark.asyncio
-async def test_stable_update_check_finds_release_behind_newer_prereleases(client):
-    c, bridge = client
-    bridge._read_version = lambda: "0.9.27"
-
-    releases = (
-        [{"tag_name": f"nightly-0.9.30-nightly{i}", "prerelease": True} for i in range(1, 7)]
-        + [{"tag_name": "v0.9.29", "prerelease": False, "body": "changelog"}]
-    )
-
-    with patch("aiohttp.ClientSession.get", return_value=_fake_releases_response(releases)):
-        resp = await c.get("/api/update/check")
-        data = await resp.json()
-
-    assert resp.status == 200
-    assert data["latest"] == "0.9.29"
-    assert data["update_available"] is True
-
-
-@pytest.mark.asyncio
-async def test_stable_update_check_requests_enough_releases_to_skip_prereleases(client):
-    """The API URL itself must ask for more than the single newest release -
-    a limit=1 request can never find a stable release behind a run of
-    prereleases no matter how the response is parsed."""
-    c, bridge = client
-    bridge._read_version = lambda: "0.9.27"
-
-    import re
-    assert not re.search(r"limit=1(?!\d)", bridge.STABLE_RELEASE_API), (
-        "STABLE_RELEASE_API must request more than 1 release, otherwise a "
-        "recent nightly/dev prerelease being the newest release hides all "
-        "stable releases behind it (Issue #104)"
-    )

web/themes/default/app.js

@@ -450,11 +450,6 @@ 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('modal-sec-power',T.settings_power||'Power Switch');
-  setText('lbl-power-on-url',T.settings_power_on_url||'Power-On URL');
-  setText('lbl-power-off-url',T.settings_power_off_url||'Power-Off URL');
-  setText('lbl-power-status-url',T.settings_power_status_url||'Status URL');
-  setText('lbl-power-hint',T.settings_power_hint||'Optional: plain HTTP GET URLs for a smart plug (e.g. Tasmota) controlling the printer\'s mains power. Leave empty to hide the power button.');
   setText('lbl-default-slot',T.settings_default_slot);
   setText('opt-slot-auto',T.settings_slot_auto);
   setText('lbl-auto-leveling',T.settings_auto_leveling);
@@ -464,8 +459,6 @@ function applyLang(){
   setText('opt-file-ready-banner',T.settings_file_ready_banner);
   setText('lbl-camera-on-print',T.settings_camera_on_print);
   setText('lbl-web-upload-warning',T.settings_web_upload_warning);
-  setText('lbl-delete-printer-file-after-print',T.settings_delete_printer_file_after_print||'Delete file from printer after successful print');
-  setText('lbl-delete-printer-file-after-print-hint',T.settings_delete_printer_file_after_print_hint||'Only applies to prints started through this bridge (files it uploaded itself) - prints started directly from the printer or Anycubic Slicer are never deleted, since no copy of those exists anywhere else.');
   setText('fd-options-title',T.fd_options_title);
   setText('fd-lbl-auto-leveling',T.print_auto_leveling);
 
@@ -1134,16 +1127,12 @@ 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||'';
-    var pon=document.getElementById('s-power-on-url');if(pon)pon.value=d.power_on_url||'';
-    var poff=document.getElementById('s-power-off-url');if(poff)poff.value=d.power_off_url||'';
-    var pstat=document.getElementById('s-power-status-url');if(pstat)pstat.value=d.power_status_url||'';
     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 vc=document.getElementById('s-vibration-compensation');if(vc)vc.checked=!!d.vibration_compensation;
     var cop=document.getElementById('s-camera-on-print');if(cop)cop.checked=!!d.camera_on_print;
     var frm=document.getElementById('s-file-ready-mode');if(frm)frm.value=(d.print_start_dialog===undefined?'1':String(d.print_start_dialog?1:0));
     var wuw=document.getElementById('s-web-upload-warning');if(wuw)wuw.checked=(d.web_upload_warning===undefined?true:!!d.web_upload_warning);
-    var dpfap=document.getElementById('s-delete-printer-file-after-print');if(dpfap)dpfap.checked=!!d.delete_printer_file_after_print;
     // Poll-Intervall (Sekunden) — Backend hat Vorrang vor localStorage
     var pi=document.getElementById('s-poll-interval');
     if(pi){
@@ -1906,16 +1895,12 @@ function saveSettings(){
     password:         document.getElementById('s-password').value,
     device_id:        document.getElementById('s-device-id').value,
     mode_id:          document.getElementById('s-mode-id').value,
-    power_on_url:     (document.getElementById('s-power-on-url')||{}).value||'',
-    power_off_url:    (document.getElementById('s-power-off-url')||{}).value||'',
-    power_status_url: (document.getElementById('s-power-status-url')||{}).value||'',
     default_ams_slot: document.getElementById('s-default-slot').value,
     auto_leveling:           document.getElementById('s-auto-leveling').checked?1:0,
     vibration_compensation:  (document.getElementById('s-vibration-compensation')||{}).checked?1:0,
     camera_on_print:         (document.getElementById('s-camera-on-print')||{}).checked?1:0,
     print_start_dialog: parseInt((document.getElementById('s-file-ready-mode')||{}).value||'1',10),
     web_upload_warning:webUploadWarning,
-    delete_printer_file_after_print: (document.getElementById('s-delete-printer-file-after-print')||{}).checked?1:0,
     poll_interval:    Math.min(60,Math.max(1,parseInt((document.getElementById('s-poll-interval')||{}).value,10)||3)),
     verbose_http_log: (document.getElementById('s-verbose-http-log')||{}).checked?1:0,
     spoolman_server:  (document.getElementById('s-spoolman-url')||{}).value||'',
@@ -3999,7 +3984,6 @@ function loadPrinterTab(){
             '<span style="font-weight:700;font-size:14px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">🖨 '+p.name+'</span>'+
             '<span style="display:flex;align-items:center;gap:8px;flex-shrink:0">'+
               (isActive?'<span style="font-size:11px;color:var(--accent);font-weight:600">'+T.printers_active+'</span>':'')+
-              (p.has_power_control?'<button id="power-btn-'+printerNum+'" onclick="togglePrinterPower(\''+printerNum+'\')" title="'+T.printers_power+'" style="background:none;border:none;color:var(--txt2);font-size:16px;cursor:pointer;line-height:1;padding:0">🔌</button>':'')+
               '<button onclick="removePrinter(\''+printerNum+'\',\''+nameEsc+'\')" title="'+T.printers_remove+'" style="background:none;border:none;color:var(--txt2);font-size:16px;cursor:pointer;line-height:1;padding:0">✕</button>'+
             '</span>'+
           '</div>'+
@@ -4016,40 +4000,8 @@ function loadPrinterTab(){
           (!isActive?'<a href="'+url+'/printer'+printerNum+'" style="display:block;text-align:center;padding:7px;background:var(--accent);color:#fff;border-radius:7px;font-size:13px;font-weight:600;text-decoration:none;margin-top:4px">'+T.printers_switch+'</a>':'<div style="text-align:center;padding:7px;font-size:12px;color:var(--txt2)">'+T.printers_current+'</div>')+
         '</div>';
       }).join('');
-      results.forEach(function(res){
-        if(res.printer.has_power_control)_refreshPrinterPowerIcon(res.printer.id,(res.printer.bridge_url||'').replace(/\/+$/,''));
-      });
     });
   }).catch(function(e){
     if(grid)grid.innerHTML='<div style="color:var(--err);font-size:13px;padding:20px">Fehler: '+e+'</div>';
   });
 }
-
-function _refreshPrinterPowerIcon(pid,bridgeUrl){
-  fetch((bridgeUrl||'')+'/kx/printers/'+encodeURIComponent(pid)+'/power-status',{signal:AbortSignal.timeout(5000)})
-    .then(function(r){return r.json()})
-    .then(function(d){
-      var btn=document.getElementById('power-btn-'+pid);
-      if(!btn)return;
-      if(d.state==='on'){btn.style.color='var(--ok)';btn.title=T.printers_power_on||'Power: On';}
-      else if(d.state==='off'){btn.style.color='var(--txt2)';btn.title=T.printers_power_off||'Power: Off';}
-    })
-    .catch(function(){/* status endpoint optional - icon just stays neutral */});
-}
-
-function togglePrinterPower(pid){
-  var btn=document.getElementById('power-btn-'+pid);
-  var currentlyOn=btn&&btn.style.color&&btn.style.color.indexOf('var(--ok)')!==-1;
-  // Without a known current state, default to "on" - turning an already-off
-  // switch on is harmless, whereas guessing "off" on a printer mid-print is not.
-  var action=currentlyOn?'off':'on';
-  if(action==='off'&&!confirm(T.printers_power_off_confirm||'Turn printer power off? Make sure no print is running.'))return;
-  if(btn)btn.style.opacity='0.5';
-  post('/kx/printers/'+encodeURIComponent(pid)+'/power',{action:action}).then(function(){
-    if(btn)btn.style.opacity='1';
-    setTimeout(function(){loadPrinterTab();},1500);
-  }).catch(function(e){
-    if(btn)btn.style.opacity='1';
-    clog('Power-Fehler: '+e,'msg-err');
-  });
-}

web/themes/default/index.html

@@ -548,22 +548,6 @@
                 <input type="text" id="s-mode-id" placeholder="20030">
               </div>
             </div>
-            <div class="card">
-              <div class="card-title"><span>🔌</span> <span id="modal-sec-power">Power Switch</span></div>
-              <div class="modal-field">
-                <label id="lbl-power-on-url">Power-On URL</label>
-                <input type="text" id="s-power-on-url" placeholder="http://192.168.x.x/cm?cmnd=Power%20on">
-              </div>
-              <div class="modal-field">
-                <label id="lbl-power-off-url">Power-Off URL</label>
-                <input type="text" id="s-power-off-url" placeholder="http://192.168.x.x/cm?cmnd=Power%20off">
-              </div>
-              <div class="modal-field">
-                <label id="lbl-power-status-url">Status URL</label>
-                <input type="text" id="s-power-status-url" placeholder="http://192.168.x.x/cm?cmnd=Power">
-                <small id="lbl-power-hint" style="color:var(--txt2)"></small>
-              </div>
-            </div>
           </div>
 
           <!-- Drucker -->
@@ -603,11 +587,6 @@
                 <input type="checkbox" id="s-web-upload-warning" style="width:auto;margin:0">
                 <label id="lbl-web-upload-warning" style="margin:0;cursor:pointer" for="s-web-upload-warning">Warnung bei Web-Upload-Druck anzeigen</label>
               </div>
-              <div class="modal-field" style="flex-direction:row;align-items:center;gap:10px">
-                <input type="checkbox" id="s-delete-printer-file-after-print" style="width:auto;margin:0">
-                <label id="lbl-delete-printer-file-after-print" style="margin:0;cursor:pointer" for="s-delete-printer-file-after-print">Delete file from printer after successful print</label>
-              </div>
-              <small id="lbl-delete-printer-file-after-print-hint" style="color:var(--txt2)"></small>
             </div>
           </div>
 

web/translations/de.json

@@ -224,10 +224,6 @@
   "printers_loading": "Lade…",
   "printers_none": "Keine Drucker konfiguriert.",
   "printers_remove": "Drucker entfernen",
-  "printers_power": "Drucker-Stromversorgung schalten",
-  "printers_power_on": "Strom: An",
-  "printers_power_off": "Strom: Aus",
-  "printers_power_off_confirm": "Drucker-Strom ausschalten? Stelle sicher, dass kein Druck läuft.",
   "printers_remove_confirm": "Drucker \"{name}\" entfernen? Die Bridge startet neu.",
   "printers_switch": "Wechseln →",
   "progress_action_clear": "Leeren",
@@ -261,11 +257,6 @@
   "settings_language": "Sprache",
   "settings_mode_id": "Mode-ID",
   "settings_mode_id_placeholder": "20030",
-  "settings_power": "Steckdose (Ein/Aus)",
-  "settings_power_on_url": "Einschalt-URL",
-  "settings_power_off_url": "Ausschalt-URL",
-  "settings_power_status_url": "Status-URL",
-  "settings_power_hint": "Optional: einfache HTTP-GET-URLs für eine Steckdose (z.B. Tasmota), die den Drucker per Netzstrom schaltet. Leer lassen blendet den Power-Button aus.",
   "settings_mqtt_port": "MQTT-Port",
   "settings_mqtt_username_placeholder": "userXXXXXXXX",
   "settings_orca_profiles_import": "Profile importieren",
@@ -293,8 +284,6 @@
   "settings_visible_vendors_save": "Auswahl speichern",
   "settings_visible_vendors_save_label": "Auswahl speichern",
   "settings_web_upload_warning": "Warnung bei Web-Upload-Druck anzeigen",
-  "settings_delete_printer_file_after_print": "Datei nach erfolgreichem Druck vom Drucker löschen",
-  "settings_delete_printer_file_after_print_hint": "Gilt nur für Drucke, die über diese Bridge gestartet wurden (selbst hochgeladene Dateien) - direkt am Drucker oder über Anycubic Slicer gestartete Drucke werden nie gelöscht, da davon sonst keine Kopie mehr existiert.",
   "sf_all": "Alle",
   "sf_err": "✗ Fehler",
   "sf_new": "Neu",

web/translations/en.json

@@ -224,10 +224,6 @@
   "printers_loading": "Loading…",
   "printers_none": "No printers configured.",
   "printers_remove": "Remove printer",
-  "printers_power": "Toggle printer power",
-  "printers_power_on": "Power: On",
-  "printers_power_off": "Power: Off",
-  "printers_power_off_confirm": "Turn printer power off? Make sure no print is running.",
   "printers_remove_confirm": "Remove printer \"{name}\"? The bridge will restart.",
   "printers_switch": "Switch →",
   "progress_action_clear": "Clear",
@@ -261,11 +257,6 @@
   "settings_language": "Language",
   "settings_mode_id": "Mode ID",
   "settings_mode_id_placeholder": "20030",
-  "settings_power": "Power Switch",
-  "settings_power_on_url": "Power-On URL",
-  "settings_power_off_url": "Power-Off URL",
-  "settings_power_status_url": "Status URL",
-  "settings_power_hint": "Optional: plain HTTP GET URLs for a smart plug (e.g. Tasmota) controlling the printer's mains power. Leave empty to hide the power button.",
   "settings_mqtt_port": "MQTT Port",
   "settings_mqtt_username_placeholder": "userXXXXXXXX",
   "settings_orca_profiles_import": "Import profiles",
@@ -293,8 +284,6 @@
   "settings_visible_vendors_save": "Save selection",
   "settings_visible_vendors_save_label": "Save selection",
   "settings_web_upload_warning": "Show warning when printing web uploads",
-  "settings_delete_printer_file_after_print": "Delete file from printer after successful print",
-  "settings_delete_printer_file_after_print_hint": "Only applies to prints started through this bridge (files it uploaded itself) - prints started directly from the printer or Anycubic Slicer are never deleted, since no copy of those exists anywhere else.",
   "sf_all": "All",
   "sf_err": "✗ Failed",
   "sf_new": "New",

web/translations/es.json

@@ -224,10 +224,6 @@
   "printers_loading": "Cargando…",
   "printers_none": "No hay impresoras configuradas.",
   "printers_remove": "Eliminar impresora",
-  "printers_power": "Alternar alimentación de la impresora",
-  "printers_power_on": "Alimentación: Encendida",
-  "printers_power_off": "Alimentación: Apagada",
-  "printers_power_off_confirm": "¿Apagar la alimentación de la impresora? Asegúrate de que no haya ninguna impresión en curso.",
   "printers_remove_confirm": "¿Eliminar impresora \"{name}\"? El bridge se reiniciará.",
   "printers_switch": "Cambiar →",
   "progress_action_clear": "Vaciar",
@@ -261,11 +257,6 @@
   "settings_language": "Idioma",
   "settings_mode_id": "ID de modo",
   "settings_mode_id_placeholder": "20030",
-  "settings_power": "Enchufe inteligente",
-  "settings_power_on_url": "URL de encendido",
-  "settings_power_off_url": "URL de apagado",
-  "settings_power_status_url": "URL de estado",
-  "settings_power_hint": "Opcional: URLs HTTP GET para un enchufe inteligente (p.ej. Tasmota) que controla la alimentación de la impresora. Déjalo vacío para ocultar el botón de encendido.",
   "settings_mqtt_port": "MQTT Port",
   "settings_mqtt_username_placeholder": "userXXXXXXXX",
   "settings_orca_profiles_import": "Importar perfiles",
@@ -293,8 +284,6 @@
   "settings_visible_vendors_save": "Guardar selección",
   "settings_visible_vendors_save_label": "Guardar selección",
   "settings_web_upload_warning": "Mostrar advertencia al imprimir subidas web",
-  "settings_delete_printer_file_after_print": "Eliminar archivo de la impresora tras una impresión exitosa",
-  "settings_delete_printer_file_after_print_hint": "Solo aplica a impresiones iniciadas a través de este bridge (archivos que él mismo subió) - las impresiones iniciadas directamente desde la impresora o Anycubic Slicer nunca se eliminan, ya que no existe ninguna copia en otro lugar.",
   "sf_all": "Todos",
   "sf_err": "✗ Fallido",
   "sf_new": "Nuevo",

web/translations/fr.json

@@ -212,10 +212,6 @@
   "printers_loading": "Chargement…",
   "printers_none": "Aucune imprimante configurée.",
   "printers_remove": "Supprimer l'imprimante",
-  "printers_power": "Basculer l'alimentation de l'imprimante",
-  "printers_power_on": "Alimentation : Allumée",
-  "printers_power_off": "Alimentation : Éteinte",
-  "printers_power_off_confirm": "Éteindre l'alimentation de l'imprimante ? Assurez-vous qu'aucune impression n'est en cours.",
   "printers_remove_confirm": "Supprimer l'imprimante \"{name}\" ? Le bridge va redémarrer.",
   "printers_switch": "Changer →",
   "progress_action_clear": "Vider",
@@ -249,11 +245,6 @@
   "settings_language": "Langue",
   "settings_mode_id": "ID du mode",
   "settings_mode_id_placeholder": "20030",
-  "settings_power": "Prise électrique",
-  "settings_power_on_url": "URL d'allumage",
-  "settings_power_off_url": "URL d'extinction",
-  "settings_power_status_url": "URL de statut",
-  "settings_power_hint": "Optionnel : URL HTTP GET pour une prise connectée (ex. Tasmota) contrôlant l'alimentation secteur de l'imprimante. Laisser vide masque le bouton d'alimentation.",
   "settings_mqtt_port": "Port MQTT",
   "settings_mqtt_username_placeholder": "userXXXXXXXX",
   "settings_orca_profiles_import": "Importer des profils",
@@ -279,8 +270,6 @@
   "settings_visible_vendors_save": "Enregistrer la sélection",
   "settings_visible_vendors_save_label": "Enregistrer la sélection",
   "settings_web_upload_warning": "Afficher un avertissement lors de l'impression de fichiers web",
-  "settings_delete_printer_file_after_print": "Supprimer le fichier de l'imprimante après une impression réussie",
-  "settings_delete_printer_file_after_print_hint": "S'applique uniquement aux impressions lancées via ce bridge (fichiers qu'il a lui-même téléversés) - les impressions lancées directement depuis l'imprimante ou Anycubic Slicer ne sont jamais supprimées, car aucune copie n'existe ailleurs.",
   "sf_all": "Tout",
   "sf_err": "✗ Échoués",
   "sf_new": "Nouveau",

web/translations/it.json

@@ -212,10 +212,6 @@
   "printers_loading": "Caricamento in corso…",
   "printers_none": "Nessuna stampante configurata.",
   "printers_remove": "Rimuovi stampante",
-  "printers_power": "Attiva/disattiva alimentazione stampante",
-  "printers_power_on": "Alimentazione: Accesa",
-  "printers_power_off": "Alimentazione: Spenta",
-  "printers_power_off_confirm": "Spegnere l'alimentazione della stampante? Assicurati che non sia in corso alcuna stampa.",
   "printers_remove_confirm": "Rimuovere la stampante \"{name}\"? Il bridge si riavvierà.",
   "printers_switch": "Cambia →",
   "progress_action_clear": "Cancella",
@@ -249,11 +245,6 @@
   "settings_language": "Lingua",
   "settings_mode_id": "ID modalità",
   "settings_mode_id_placeholder": "20030",
-  "settings_power": "Presa elettrica",
-  "settings_power_on_url": "URL accensione",
-  "settings_power_off_url": "URL spegnimento",
-  "settings_power_status_url": "URL stato",
-  "settings_power_hint": "Opzionale: URL HTTP GET per una presa smart (es. Tasmota) che controlla l'alimentazione della stampante. Lasciare vuoto per nascondere il pulsante di accensione.",
   "settings_mqtt_port": "Porta MQTT",
   "settings_mqtt_username_placeholder": "userXXXXXXXX",
   "settings_orca_profiles_import": "Importa profili",
@@ -279,8 +270,6 @@
   "settings_visible_vendors_save": "Salva selezione",
   "settings_visible_vendors_save_label": "Salva selezione",
   "settings_web_upload_warning": "Mostra un avviso quando si stampano caricamenti web",
-  "settings_delete_printer_file_after_print": "Elimina il file dalla stampante dopo una stampa riuscita",
-  "settings_delete_printer_file_after_print_hint": "Si applica solo alle stampe avviate tramite questo bridge (file caricati da esso) - le stampe avviate direttamente dalla stampante o da Anycubic Slicer non vengono mai eliminate, poiché non ne esiste alcuna copia altrove.",
   "sf_all": "Tutti",
   "sf_err": "✗ Fallito",
   "sf_new": "Nuovo",

web/translations/zh-cn.json

@@ -224,10 +224,6 @@
   "printers_loading": "加载中…",
   "printers_none": "未配置打印机。",
   "printers_remove": "移除打印机",
-  "printers_power": "切换打印机电源",
-  "printers_power_on": "电源：开",
-  "printers_power_off": "电源：关",
-  "printers_power_off_confirm": "关闭打印机电源？请确认当前没有正在进行的打印任务。",
   "printers_remove_confirm": "移除打印机 \"{name}\"? Bridge 将重启。",
   "printers_switch": "切换 →",
   "progress_action_clear": "清除",
@@ -261,11 +257,6 @@
   "settings_language": "语言",
   "settings_mode_id": "模式 ID",
   "settings_mode_id_placeholder": "20030",
-  "settings_power": "电源插座",
-  "settings_power_on_url": "开机 URL",
-  "settings_power_off_url": "关机 URL",
-  "settings_power_status_url": "状态 URL",
-  "settings_power_hint": "可选：智能插座（如 Tasmota）的 HTTP GET 控制 URL，用于控制打印机的电源。留空则隐藏电源按钮。",
   "settings_mqtt_port": "MQTT 端口",
   "settings_mqtt_username_placeholder": "userXXXXXXXX",
   "settings_orca_profiles_import": "导入配置文件",
@@ -293,8 +284,6 @@
   "settings_visible_vendors_save": "保存选择",
   "settings_visible_vendors_save_label": "保存选择",
   "settings_web_upload_warning": "打印网页上传文件时显示警告",
-  "settings_delete_printer_file_after_print": "打印成功后从打印机删除文件",
-  "settings_delete_printer_file_after_print_hint": "仅适用于通过此网桥启动的打印（即由网桥自己上传的文件）——直接从打印机或 Anycubic Slicer 启动的打印任务永远不会被删除，因为它们没有其他备份。",
   "sf_all": "全部",
   "sf_err": "✗ 失败",
   "sf_new": "新",