boneio 1.6.0.dev13__tar.gz → 1.6.0.dev14__tar.gz

{boneio-1.6.0.dev13 → boneio-1.6.0.dev14}/MANIFEST.in

@@ -5,6 +5,7 @@ recursive-include boneio *.yaml
 recursive-include boneio *.json
 recursive-include boneio *.ttf
 recursive-include boneio/webui/frontend-dist *
+recursive-include boneio/webui/recovery/static *
 # Signing key and migration plan signatures — the helper refuses to run
 # without them, so a wheel built without these is useless on a device.
 recursive-include boneio *.pem

{boneio-1.6.0.dev13/boneio.egg-info → boneio-1.6.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.6.0.dev13
+Version: 1.6.0.dev14
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0

{boneio-1.6.0.dev13 → boneio-1.6.0.dev14}/boneio/bonecli.py

@@ -213,10 +213,11 @@ def run(
     """Run BoneIO."""
     import time as _time
 
-    from yaml import MarkedYAMLError
+    from yaml import YAMLError
 
     from boneio.core.config import load_config_from_file
     from boneio.core.events import GracefulExit
+    from boneio.core.recovery import RecoveryReason, StartupFailures, describe_config_error
     from boneio.core.utils.logger import configure_logger, setup_logging
     from boneio.exceptions import ConfigurationException
     _t0 = _time.monotonic()
@@ -246,6 +247,22 @@ def run(
         def draw_config_error(msg: str) -> None: pass  # noqa: E731
         def draw_crash(exc: BaseException) -> None: pass  # noqa: E731
 
+    def _recover(reason: RecoveryReason) -> int:
+        # Imported only here: the panel's web stack costs seconds to import,
+        # and a controller that starts normally never needs it.
+        from boneio.webui.recovery import run_recovery
+
+        return run_recovery(config, reason)
+
+    failures = StartupFailures(config)
+    if failures.in_crash_loop():
+        _LOGGER.error(
+            "boneIO crashed during startup %d times in a row. Starting the "
+            "recovery panel instead, so the error can be seen and fixed.",
+            failures.count,
+        )
+        return _recover(failures.last_reason())
+
     try:
         _t1 = _time.monotonic()
         _config = load_config_from_file(
@@ -253,9 +270,11 @@ def run(
         )
         _LOGGER.debug("[STARTUP TIMING] load_config_from_file: %.2fs", _time.monotonic() - _t1)
         if not _config:
-            _LOGGER.error("Config not loaded. Exiting.")
+            _LOGGER.error("Config not loaded.")
             draw_config_error("Config file is empty or missing")
-            return 1
+            return _recover(
+                RecoveryReason(kind="config", message="Config file is empty or missing", file=config)
+            )
         configure_logger(log_config=_config.get("logger") or {}, debug=debug)
         draw_status("Importing modules...")
         # Granular timing of runner sub-imports to find the bottleneck
@@ -294,13 +313,14 @@ def run(
     except GracefulExit as err:
         _LOGGER.info("Message: %s", err)
         return 0
-    except (ConfigurationException, MarkedYAMLError) as err:
-        _LOGGER.error("Failed to load config. %s Exiting.", err)
+    except (ConfigurationException, YAMLError) as err:
+        _LOGGER.error("Failed to load config. %s", err)
         draw_config_error(str(err)[:100])
-        return 1
+        return _recover(describe_config_error(err, config))
     except Exception as err:
         _LOGGER.error("Unexpected error during startup: %s", err, exc_info=True)
         draw_crash(err)
+        failures.record(err)
         return 1
 
 

{boneio-1.6.0.dev13 → boneio-1.6.0.dev14}/boneio/components/input/binary_sensor.py

@@ -53,7 +53,6 @@ class GpioInputBinarySensor(GpioBaseClass):
             name=self._name,
             pin=self._pin,
             detector=self._detector,
-            gpio_mode=kwargs.get("gpio_mode", "gpio"),
         )
         
         _LOGGER.debug("Configured binary sensor %s on pin %s (inverted=%s)", 

{boneio-1.6.0.dev13 → boneio-1.6.0.dev14}/boneio/components/input/event.py

@@ -140,7 +140,6 @@ class GpioEventButton(GpioBaseClass):
             name=self._name,
             pin=self._pin,
             detector=self._detector,
-            gpio_mode=kwargs.get("gpio_mode", "gpio"),
         )
 
         _LOGGER.debug("Configured event input %s on pin %s", self._name, self._pin)

{boneio-1.6.0.dev13 → boneio-1.6.0.dev14}/boneio/const.py

@@ -14,12 +14,12 @@ SET_BRIGHTNESS = "set_brightness"
 ENABLED = "enabled"
 OUTPUT = "output"
 VIRTUAL_SWITCH = "virtual_switch"
+SCHEDULE = "schedule"
 PIN = "pin"
 ID = "id"
 KIND = "kind"
 GPIO = "gpio"
 PCA = "pca"
-GPIO_MODE = "gpio_mode"
 ACTIONS = "actions"
 ACTION = "action"
 OUTPUT_OVER_MQTT = "output_over_mqtt"

boneio-1.6.0.dev14/boneio/core/auth/jwt_secret.py

@@ -0,0 +1,59 @@
+"""The secret the panel signs its login tokens with.
+
+Kept in ``jwt_secret`` next to config.yaml so a token outlives a restart. Here
+rather than in the web server so recovery mode signs with the same secret
+without importing the web server, which pulls in the whole Manager: a token
+issued in recovery keeps working once the controller is back, and the other
+way round.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import secrets
+from pathlib import Path
+
+_LOGGER = logging.getLogger(__name__)
+
+JWT_SECRET_FILENAME = "jwt_secret"
+
+
+def load_or_create_jwt_secret(config_dir: str | os.PathLike[str]) -> str:
+    """Read the token secret, creating it on first use.
+
+    Never raises: a secret that cannot be persisted is replaced by one that
+    lives as long as the process, which logs everybody out on the next restart
+    but does not keep the panel from starting.
+
+    Args:
+        config_dir: The directory config.yaml is in.
+
+    Returns:
+        The secret.
+    """
+    jwt_secret_file = Path(config_dir) / JWT_SECRET_FILENAME
+
+    try:
+        if jwt_secret_file.exists():
+            # Read existing secret
+            with open(jwt_secret_file) as f:
+                jwt_secret = f.read().strip()
+                if jwt_secret:  # Verify it's not empty
+                    return jwt_secret
+
+        # Generate new secret if file doesn't exist or is empty
+        jwt_secret = secrets.token_hex(32)  # 256-bit random secret
+
+        # Save the secret
+        with open(jwt_secret_file, "w") as f:
+            f.write(jwt_secret)
+
+        # Secure the file permissions (read/write only for owner)
+        os.chmod(jwt_secret_file, 0o600)
+
+    except Exception as e:
+        # If we can't persist the secret, generate a temporary one
+        _LOGGER.error(f"Failed to handle JWT secret file: {e}")
+        jwt_secret = secrets.token_hex(32)
+    return jwt_secret

{boneio-1.6.0.dev13 → boneio-1.6.0.dev14}/boneio/core/config/migrations/__init__.py

@@ -17,7 +17,7 @@ from dataclasses import dataclass, field
 _LOGGER = logging.getLogger(__name__)
 
 # Current schema version — bump this when adding new migrations
-CURRENT_SCHEMA_VERSION = 5
+CURRENT_SCHEMA_VERSION = 6
 
 # Minimum app version that introduced each schema version.
 # Used by the WebUI to warn before rolling back to an incompatible version.
@@ -28,6 +28,7 @@ SCHEMA_VERSION_APP_MAP: dict[int, str] = {
     3: "1.3.0dev7",   # irrigation section
     4: "1.5.0dev13",  # WLED effects/palettes → JSON cache
     5: "1.5.0dev35",  # OLED screen name: ina219 → ina
+    6: "1.6.0dev15",  # gpio_mode, clear_message removed from inputs
 }
 
 
@@ -153,6 +154,15 @@ def _has_legacy_fields(doc: dict) -> bool:
         if isinstance(screens, list) and "ina219" in screens:
             return True
 
+    # v6: dead gpio_mode / clear_message keys on inputs
+    for section_key in ("event", "binary_sensor"):
+        items = doc.get(section_key)
+        if isinstance(items, list) and any(
+            isinstance(item, dict) and ("gpio_mode" in item or "clear_message" in item)
+            for item in items
+        ):
+            return True
+
     return False
 
 
@@ -310,4 +320,5 @@ from boneio.core.config.migrations import (
     v2_transition,  # noqa: E402, F401
     v4_wled_cache,  # noqa: E402, F401
     v5_ina_screen,  # noqa: E402, F401
+    v6_input_keys,  # noqa: E402, F401
 )

boneio-1.6.0.dev14/boneio/core/config/migrations/v6_input_keys.py

@@ -0,0 +1,160 @@
+"""Migration v6: Drop dead keys from inputs.
+
+Both keys were ignored at runtime but stayed in schema.yaml, so people who fed
+the schema to an LLM got configs full of them:
+
+- ``gpio_mode`` — pull-up/pull-down comes from the kernel overlay.
+- ``clear_message`` — sent an empty MQTT message 200 ms after a click, the way
+  Zigbee2MQTT clears its ``action`` sensor. It only made sense while clicks
+  reached Home Assistant as a sensor; the event entity needs no reset. It
+  stopped working in the 2025 input refactor and nobody noticed.
+
+Before:
+    event:
+      - name: IN_01
+        pin: P8_37
+        gpio_mode: gpio_pu
+        clear_message: true
+After:
+    event:
+      - name: IN_01
+        pin: P8_37
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+
+from boneio.core.config.migrations import register_migration
+
+_LOGGER = logging.getLogger(__name__)
+
+# Sections whose list items may still carry the keys.
+_SECTIONS = ("event", "binary_sensor")
+_KEYS = ("gpio_mode", "clear_message")
+
+_TOP_LEVEL_RE = re.compile(r"^([A-Za-z_][\w-]*)\s*:(.*)$")
+_INCLUDE_RE = re.compile(r"^!include\s+(\S+)$")
+
+
+def _strip_key_lines(lines: list[str], keys: tuple[str, ...]) -> tuple[list[str], int]:
+    """Remove every ``key: value`` line from a YAML block list.
+
+    A key written as the first entry of a list item (``- key: value``) hands
+    its dash to the next line of that item, so the item survives.
+
+    Args:
+        lines: Lines of the block, with line endings.
+        keys: Mapping keys to remove.
+
+    Returns:
+        The new lines and how many were removed.
+    """
+    names = "|".join(re.escape(k) for k in keys)
+    key_re = re.compile(rf"^(\s*)(-\s+)?(?:{names})\s*:.*$")
+    out: list[str] = []
+    removed = 0
+    pending_dash: int | None = None  # indent of a dash that needs a new owner
+
+    for line in lines:
+        m = key_re.match(line.rstrip("\n"))
+        if m:
+            removed += 1
+            if m.group(2):
+                pending_dash = len(m.group(1))
+            continue
+        if pending_dash is not None and line.strip() and not line.lstrip().startswith("#"):
+            indent = len(line) - len(line.lstrip())
+            if indent > pending_dash:
+                line = " " * pending_dash + "- " + line.lstrip()
+            pending_dash = None
+        out.append(line)
+    return out, removed
+
+
+def strip_item_keys(config_file: str, sections: tuple[str, ...], keys: tuple[str, ...]) -> None:
+    """Remove ``keys`` from list items of top-level ``sections`` on disk.
+
+    Follows a top-level ``section: !include file.yaml`` into that file, since
+    that is where the shipped configs keep ``event`` and ``binary_sensor``.
+
+    Args:
+        config_file: Path to config.yaml.
+        sections: Top-level section names to clean.
+        keys: Mapping keys to remove from their items.
+    """
+    main = Path(config_file)
+    lines = main.read_text(encoding="utf-8").splitlines(keepends=True)
+
+    out: list[str] = []
+    block: list[str] = []
+    in_section = False
+    main_removed = 0
+
+    def flush() -> None:
+        nonlocal main_removed
+        if in_section:
+            cleaned, n = _strip_key_lines(block, keys)
+            main_removed += n
+            out.extend(cleaned)
+        else:
+            out.extend(block)
+        block.clear()
+
+    for line in lines:
+        m = _TOP_LEVEL_RE.match(line.rstrip("\n"))
+        if m:
+            flush()
+            name, rest = m.group(1), m.group(2).split("#", 1)[0].strip()
+            in_section = name in sections
+            include = _INCLUDE_RE.match(rest) if in_section else None
+            if include:
+                _strip_file(main.parent / include.group(1), keys)
+        block.append(line)
+    flush()
+
+    if main_removed:
+        main.write_text("".join(out), encoding="utf-8")
+        _LOGGER.info("Removed %d deprecated line(s) from %s", main_removed, main)
+
+
+def _strip_file(path: Path, keys: tuple[str, ...]) -> None:
+    """Remove ``keys`` from an included file that holds a whole section."""
+    if not path.is_file():
+        _LOGGER.warning("Included file %s not found, skipping", path)
+        return
+    lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+    cleaned, removed = _strip_key_lines(lines, keys)
+    if removed:
+        path.write_text("".join(cleaned), encoding="utf-8")
+        _LOGGER.info("Removed %d deprecated line(s) from %s", removed, path)
+
+
+def _persist_input_keys(config_file: str) -> None:
+    strip_item_keys(config_file, _SECTIONS, _KEYS)
+
+
+@register_migration(
+    version=6,
+    name="Remove gpio_mode and clear_message from event/binary_sensor",
+    migrate_file=_persist_input_keys,
+)
+def migrate_v6_input_keys(doc: dict) -> dict:
+    """Drop the dead keys from every event and binary_sensor item.
+
+    Args:
+        doc: Raw config dictionary.
+
+    Returns:
+        Migrated config dictionary.
+    """
+    for section in _SECTIONS:
+        items = doc.get(section)
+        if isinstance(items, list):
+            for item in items:
+                if isinstance(item, dict):
+                    for key in _KEYS:
+                        item.pop(key, None)
+    return doc

{boneio-1.6.0.dev13 → boneio-1.6.0.dev14}/boneio/core/events/bus.py

@@ -102,6 +102,10 @@ class EventBus:
             "host": {},
             "group": {},
             "inputs_reloaded": {},
+            # The web UI listens for schedule status. Without the key, adding
+            # that listener raised KeyError and the WebSocket handler died
+            # right after its first state dump.
+            "schedule": {},
         }
         self._listener_id_index = {}
         self._worker_task = None

{boneio-1.6.0.dev13 → boneio-1.6.0.dev14}/boneio/core/manager/manager.py

@@ -32,6 +32,7 @@ from boneio.const import (
     OUTPUT_OVER_MQTT,
     REMOTE_COVER,
     REMOTE_OUTPUT,
+    SCHEDULE,
     SET_BRIGHTNESS,
     STATE,
     TOGGLE,
@@ -2062,6 +2063,22 @@ class Manager:
                 _LOGGER.debug("Unknown virtual switch command %s.", message.upper())
             return
 
+        # Handle schedule enable/disable — the same path the web UI toggle
+        # takes, so a schedule switched off in Home Assistant is switched off
+        # everywhere and survives a restart.
+        if msg_type == SCHEDULE and command == "set":
+            scheduler = getattr(self, "scheduler", None)
+            if scheduler is None:
+                _LOGGER.debug("No scheduler to take a command for %s.", device_id)
+                return
+            wanted = message.upper()
+            if wanted not in (ON, OFF):
+                _LOGGER.debug("Unknown schedule command %s.", wanted)
+                return
+            if not scheduler.set_enabled(device_id, wanted == ON):
+                _LOGGER.debug("Schedule not found %s.", device_id)
+            return
+
         # Handle relay/output commands
         if msg_type == OUTPUT and command == "set":
             target_device = self.outputs.get_output(device_id)