boneIO 1.6.0.dev33__py3-none-any.whl → 1.6.0.dev35__py3-none-any.whl

boneio/components/sensor/virtual_energy.py

@@ -25,6 +25,10 @@ if TYPE_CHECKING:
 
 _LOGGER = logging.getLogger(__name__)
 
+# How long to wait, once the broker has the subscription, for a stored total.
+# None arriving means the counter has never been published.
+RESTORE_GRACE_SECONDS = 15.0
+
 
 class VirtualEnergySensor:
     """Virtual energy/water sensor linked to an output.
@@ -72,6 +76,7 @@ class VirtualEnergySensor:
         self._area = area
 
         self._virtual_sensors_task = None
+        self._restore_task: asyncio.Task | None = None
 
         # Counters
         self._energy_consumed_Wh = 0.0
@@ -145,7 +150,8 @@ class VirtualEnergySensor:
 
     def start_tracking(self):
         """Start tracking consumption (called when output turns ON)."""
-        self._last_on_timestamp = time.time()
+        if self._last_on_timestamp is None:  # ON while already on keeps the stretch
+            self._last_on_timestamp = time.time()
         if self._virtual_sensors_task is not None and not self._virtual_sensors_task.done():
             return  # Already running
         self._virtual_sensors_task = self._loop.create_task(self._tracking_loop())
@@ -169,20 +175,9 @@ class VirtualEnergySensor:
     async def _tracking_loop(self):
         """Periodically update and send state every 30 seconds while output is ON."""
         try:
-            # Wait for state restore before sending any state.
-            # This prevents overwriting the retained MQTT value with 0.
-            # Timeout of 5s ensures we don't hang if MQTT is down.
-            try:
-                await asyncio.wait_for(self._restore_done.wait(), timeout=5.0)
-            except TimeoutError:
-                _LOGGER.warning(
-                    "State restore timeout for %s, starting with energy=%.4f Wh", self._id, self._energy_consumed_Wh
-                )
-                self._restore_done.set()
-
-            # Reset on_timestamp after restore so we don't count
-            # the time elapsed during the restore wait.
-            self._last_on_timestamp = time.time()
+            # Publishing before the stored total is known would replace it
+            # with what was counted since boot.
+            await self._restore_done.wait()
 
             while self._output.state == ON:
                 self._update_consumption()
@@ -194,7 +189,9 @@ class VirtualEnergySensor:
     def _update_consumption(self):
         """Update consumption counters based on elapsed time."""
         now = time.time()
-        if self._output.state == ON and self._last_on_timestamp is not None:
+        # Not the output's state: by the time OFF is handled it is already
+        # off, and the stretch since the last update would be lost.
+        if self._last_on_timestamp is not None:
             elapsed = now - self._last_on_timestamp
 
             if self._sensor_type == "power" and self._power_usage is not None:
@@ -215,14 +212,17 @@ class VirtualEnergySensor:
         """
 
         async def on_message(_topic, payload):
+            if self._restore_done.is_set():
+                return  # Late, after giving up: the counter is already published.
             try:
                 data = json.loads(payload)
                 if isinstance(data, dict):
+                    # Added, not assigned: the output may have been on since boot.
                     if "energy" in data:
-                        self._energy_consumed_Wh = float(data["energy"])
+                        self._energy_consumed_Wh += float(data["energy"])
                         _LOGGER.info("Restored energy state for %s: %.4f Wh", self._id, self._energy_consumed_Wh)
                     if "water" in data:
-                        self._water_consumed_L = float(data["water"])
+                        self._water_consumed_L += float(data["water"])
                         _LOGGER.info("Restored water state for %s: %.4f L", self._id, self._water_consumed_L)
             except Exception as e:
                 _LOGGER.warning("Failed to restore state for %s: %s", self._id, e)
@@ -230,8 +230,20 @@ class VirtualEnergySensor:
                 self._restore_done.set()
                 await self._message_bus.unsubscribe_and_stop_listen(self._sensor_topic)
 
+        async def restore():
+            await self._message_bus.subscribe_and_listen(self._sensor_topic, on_message)
+            # The grace starts once the broker has the subscription, not at
+            # boot: connecting can take longer than any fixed timeout.
+            await self._message_bus.wait_until_subscribed()
+            try:
+                await asyncio.wait_for(self._restore_done.wait(), timeout=RESTORE_GRACE_SECONDS)
+            except TimeoutError:
+                _LOGGER.info("No stored state for %s, counting from boot", self._id)
+                self._restore_done.set()
+                await self._message_bus.unsubscribe_and_stop_listen(self._sensor_topic)
+
         if self._message_bus is not None:
-            asyncio.create_task(self._message_bus.subscribe_and_listen(self._sensor_topic, on_message))
+            self._restore_task = asyncio.create_task(restore())
 
     def get_current_power(self) -> float:
         """Get current power usage in W (0 if output is OFF)."""

boneio/core/cloud/registration.py

@@ -119,7 +119,13 @@ class CloudRegistration:
 
     @property
     def is_compose_writable(self) -> bool:
-        """Check if docker-compose.yaml is writable without side effects."""
+        """Check if docker-compose.yaml is writable without side effects.
+
+        True for the packaged Caddy: there is no compose file to be writable,
+        and the panel warns when this is False.
+        """
+        if containers.proxy_mode() == "native":
+            return True
         compose_file = _DOCKER_DIR / "docker-compose.yaml"
         if not compose_file.exists():
             return False
@@ -521,6 +527,9 @@ class CloudRegistration:
         This ensures the script is always up-to-date after a pip upgrade,
         even if the user never re-clones the full repo.
         """
+        if containers.proxy_mode() == "native":
+            # The generator writes the cloud block itself; no script is mounted.
+            return
         dest = CADDY_CONFIG_DIR / "init-certs-cloud.sh"
         try:
             src = files("boneio.core.cloud.data").joinpath("init-certs-cloud.sh")
@@ -661,19 +670,15 @@ class CloudRegistration:
 
     def is_cloud_config_active(self) -> bool:
         """
-        Check if cloud init-certs script is active in docker-compose.
+        Check if the cloud template is the one in use.
+
+        Asked of the compose file in container mode and of the helper's marker
+        for the packaged Caddy, which has no compose file.
 
         Returns:
             True if cloud config is active
         """
-        try:
-            compose_file = _DOCKER_DIR / "docker-compose.yaml"
-            if not compose_file.exists():
-                return False
-            content = compose_file.read_text()
-            return "init-certs-cloud.sh" in content
-        except Exception:
-            return False
+        return containers.cloud_template_is_live()
 
 
 async def set_enabled(config_helper, enabled: bool, local_ip: str | None = None) -> str:

boneio/core/config/provenance.py

@@ -75,9 +75,12 @@ def looks_factory_fresh(
         return True
 
     root = Path(template_dir) if template_dir is not None else FACTORY_TEMPLATE_DIR
-    try:
-        variants = sorted(p for p in root.iterdir() if p.is_dir())
-    except OSError:
+    # <variant>/ on older images, <revision>/<variant>/ since one image serves
+    # every board.
+    variants = sorted(
+        p.parent for p in [*root.glob("*/config.yaml"), *root.glob("*/*/config.yaml")]
+    )
+    if not variants:
         # No templates to compare against: the honest answer is "cannot tell",
         # and the safe reading of that is "assume it has been configured".
         _LOGGER.debug("No factory templates under %s — assuming configured", root)
@@ -85,7 +88,7 @@ def looks_factory_fresh(
 
     for variant in variants:
         if current == _digest(variant / "config.yaml"):
-            _LOGGER.debug("Configuration matches the %s template", variant.name)
+            _LOGGER.debug("Configuration matches the %s template", variant.relative_to(root))
             return True
 
     return False

boneio/core/containers.py

@@ -90,6 +90,13 @@ _HELPER_ONLY = {
     # Read the root-owned template and rewrite the compose file's Caddy line.
     "caddy-image-state",
     "caddy-image-apply",
+    # Root reads Caddy's own copy; without the helper the panel reads it itself.
+    "caddy-root-ca",
+    # Installs a package and starts it as root, in a unit of its own.
+    "proxy-switch-start",
+    "proxy-switch-run",
+    "proxy-switch-state",
+    "proxy-switch-recover",
 }
 
 
@@ -349,8 +356,8 @@ def restart_nodered(timeout: int = 120) -> Result:
     return run("restart-nodered", timeout=timeout)
 
 
-def pull_nodered(timeout: int = 600) -> Result:
-    """Pull the Node-RED image."""
+def pull_nodered(timeout: int = 960) -> Result:
+    """Pull the Node-RED image; outlasts the helper's own 900 s limit."""
     return run("pull-nodered", timeout=timeout)
 
 
@@ -453,6 +460,60 @@ def caddy_image_apply(timeout: int = 1300) -> Result:
     return run("caddy-image-apply", timeout=timeout)
 
 
+#: Present once Caddy is the apt package under systemd. Created only by the
+#: root helper's switch, and world-readable, so the application can look.
+NATIVE_MARKER = Path("/etc/boneio/proxy-native")
+
+
+#: Present while the cloud wildcard block is wanted by the packaged Caddy.
+#: Created and removed by the root helper's cloud-template verbs, which is the
+#: whole of what "the cloud template" means once there is no compose file.
+CLOUD_MARKER = Path("/etc/boneio/proxy-cloud")
+
+
+def proxy_mode() -> str:
+    """``"native"`` once Caddy runs as the package, else ``"container"``."""
+    try:
+        return "native" if NATIVE_MARKER.exists() else "container"
+    except OSError:
+        return "container"
+
+
+def proxy_switch_start(timeout: int = 60) -> Result:
+    """Start the move from the Caddy container to the package, and return.
+
+    The helper runs it in a unit of its own, so it outlives a boneIO restart;
+    it refuses while one runs and once Caddy is already the package.
+    """
+    return run("proxy-switch-start", timeout=timeout)
+
+
+def proxy_switch_state(timeout: int = 30) -> Result:
+    """The last switch's record and log tail, as JSON on stdout. Read-only."""
+    return run("proxy-switch-state", timeout=timeout)
+
+
+def proxy_switch_recover(timeout: int = 300) -> Result:
+    """Undo a switch that was cut short; a no-op for anything else."""
+    return run("proxy-switch-recover", timeout=timeout)
+
+
+def root_ca(timeout: int = 30) -> bytes | None:
+    """The PEM of Caddy's local root certificate, read by the helper.
+
+    One path for both modes: the helper knows where each keeps it, and in the
+    packaged one the data directory is not readable by the application.
+
+    Returns:
+        The certificate, or None when the helper is missing or too old to know
+        the verb, or Caddy has not created one yet.
+    """
+    result = run("caddy-root-ca", timeout=timeout)
+    if not result.ok or not result.stdout.strip():
+        return None
+    return result.stdout.encode()
+
+
 def remove_cloud_template(timeout: int = 60) -> Result:
     """Restore the plain compose template."""
     return run("remove-cloud-template", timeout=timeout)
@@ -539,6 +600,9 @@ def cloud_template_is_live() -> bool:
         cannot be read — the local template is the safe assumption, being the
         one that needs nothing from outside the device.
     """
+    if proxy_mode() == "native":
+        # No compose file to ask: the helper's marker is the template.
+        return CLOUD_MARKER.exists()
     try:
         body = COMPOSE_FILE.read_text()
     except OSError as err:

boneio/core/events/bus.py

@@ -372,8 +372,14 @@ class EventBus:
         return listener_job
 
     def remove_event_listener(self, event_type: str | None = None, entity_id: str | None = None, listener_id: str | None = None) -> None:
-        """Remove event listener. Can remove by event_type, listener_id, or both."""
-        if listener_id and listener_id in self._listener_id_index:
+        """Remove event listener. Can remove by event_type, listener_id, or both.
+
+        A ``listener_id`` the bus does not know removes nothing; it never
+        widens to every listener of ``event_type``.
+        """
+        if listener_id:
+            if listener_id not in self._listener_id_index:
+                return
             # Remove by listener_id
             for evt_type, ent_id in self._listener_id_index[listener_id]:
                 if event_type and evt_type != event_type:

boneio/core/manager/manager.py

@@ -830,7 +830,7 @@ class Manager:
 
                 elif action == OUTPUT_OVER_MQTT:
                     boneio_id = action_definition.get("boneio_id")
-                    action_output = action_definition.get("action_output")
+                    action_output = action_definition.get("action_output", TOGGLE)
                     action_to_execute = output_actions.get(action_output.upper())
                     if boneio_id and action_to_execute:
                         parsed_action = {
@@ -845,7 +845,7 @@ class Manager:
 
                 elif action == COVER_OVER_MQTT:
                     boneio_id = action_definition.get("boneio_id")
-                    action_cover = action_definition.get("action_cover")
+                    action_cover = action_definition.get("action_cover", TOGGLE)
                     action_to_execute = cover_actions.get(action_cover.upper())
                     if boneio_id and action_to_execute:
                         parsed_action = {
@@ -1494,11 +1494,12 @@ class Manager:
 
         _LOGGER.info("Reloading remote devices configuration")
         # Clean up old remote inputs and outputs before reload
+        await self.inputs._remote_registrar.stop()
         self.inputs.unregister_remote_inputs()
         self.unregister_remote_outputs()
         await self.remote_devices.reload(remote_devices_config)
         # Re-register remote inputs and outputs from config
-        self.register_remote_inputs()
+        await self.register_remote_inputs()
         self.register_remote_outputs()
         # Broadcast all input states so frontend picks up new/removed remote inputs
         self.inputs._broadcast_all_input_states()
@@ -1515,13 +1516,12 @@ class Manager:
         # previous callbacks would run the old actions alongside the new ones.
         await self.inputs._remote_registrar.stop()
         self.inputs.unregister_remote_inputs()
-        self.register_remote_inputs()
-        await self.inputs._remote_registrar.start()
+        await self.register_remote_inputs()
         # Broadcast all input states so frontend picks up new/removed remote inputs
         self.inputs._broadcast_all_input_states()
         _LOGGER.info("Remote inputs configuration reloaded successfully")
 
-    def register_remote_inputs(self) -> None:
+    async def register_remote_inputs(self) -> None:
         """Register remote inputs from the ``remote_inputs`` config section.
 
         Delegates to :meth:`InputManager.register_remote_inputs`.
@@ -1530,6 +1530,11 @@ class Manager:
         config = self._config_helper.get_config()
         remote_inputs_config = config.get("remote_inputs", [])
         self.inputs.register_remote_inputs(self.remote_devices, remote_inputs_config)
+        # Subscribe here rather than wait for the next MQTT connect: at startup
+        # the broker is usually connected long before remote inputs register,
+        # and the inputs would stay deaf until the connection dropped. Before
+        # the connect the bus only records the listener and subscribes it then.
+        await self.inputs._remote_registrar.start()
 
     # Keep backward-compatible alias
     register_esphome_binary_sensors = register_remote_inputs

boneio/core/messaging/basic.py

@@ -78,3 +78,9 @@ class MessageBus(ABC):
         """Unsubscribe from a topic and stop listening."""
         pass
 
+    async def wait_until_subscribed(self) -> None:
+        """Return once the broker holds this bus's subscriptions.
+
+        Until then a retained message cannot have arrived yet, so its absence
+        means nothing. Buses without a broker return at once.
+        """

boneio/core/messaging/composite.py

@@ -97,3 +97,7 @@ class CompositeMessageBus(MessageBus):
         """Unsubscribe from a topic and stop listening on all buses."""
         for bus in self._buses:
             await bus.unsubscribe_and_stop_listen(topic)
+
+    async def wait_until_subscribed(self) -> None:
+        """Wait for every bus: one being up says nothing about another."""
+        await asyncio.gather(*(bus.wait_until_subscribed() for bus in self._buses))

boneio/core/messaging/mqtt.py

@@ -76,6 +76,7 @@ class MQTTClient(MessageBus):
         self.asyncio_client = self.create_client()
         self.reconnect_interval = 1
         self._connection_established = False
+        self._subscribed = asyncio.Event()
         self.publish_queue: UniqueQueue = UniqueQueue()
         self._mqtt_energy_listeners: dict[str, Callable[..., Awaitable[None]]] = {}
         # Listeners that are told whether a message is a retained replay.
@@ -227,6 +228,10 @@ class MQTTClient(MessageBus):
         if self._connection_established:
             await self.subscribe(topics=[topic])
 
+    @override
+    async def wait_until_subscribed(self) -> None:
+        await self._subscribed.wait()
+
     @override
     async def unsubscribe_and_stop_listen(self, topic: str) -> None:
         await self.unsubscribe([topic])
@@ -476,6 +481,7 @@ class MQTTClient(MessageBus):
 
                 topics = self._topics + list(self._mqtt_energy_listeners.keys()) + self._discovery_topics
                 await self.subscribe(topics=topics)
+                self._subscribed.set()
                 # Connected: the next outage starts the backoff from scratch
                 # instead of waiting as long as the worst one before it.
                 self.reconnect_interval = 1

boneio/core/proxy_switch.py

@@ -0,0 +1,149 @@
+"""Moves a controller from the Caddy container to the packaged Caddy by itself.
+
+The move is the root helper's (``proxy-switch-start``), run in a unit of its
+own; this only decides when to ask for it and watches it finish. It waits for
+the controller to have settled, needs the package repository to be reachable,
+and gives up after a few failed runs so a controller that cannot make the move
+does not retry for ever. Everything that touches the helper or the network runs
+off the event loop, and nothing here waits on or blocks the inputs.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import socket
+
+from boneio.core import containers
+
+_LOGGER = logging.getLogger(__name__)
+
+#: Let the controller finish starting (discovery, Modbus, the first sensor
+#: reads) before a package install competes with it for a single core.
+START_DELAY = 300
+#: Between looks when a condition was not met (offline, helper not updated).
+RECHECK = 1800
+POLL = 10
+#: A switch that runs longer than this (30 minutes of polls) is left to the
+#: next look rather than watched for ever.
+MAX_POLLS = 180
+MAX_ATTEMPTS = 3
+#: Where the package comes from; no point starting the move without it.
+REPO_HOST = "dl.cloudsmith.io"
+
+
+def has_default_route() -> bool:
+    """Whether the kernel has a default IPv4 route (destination and mask zero)."""
+    try:
+        with open("/proc/net/route", encoding="ascii") as handle:
+            rows = [line.split() for line in handle.read().splitlines()[1:]]
+    except OSError:
+        return False
+    return any(len(r) > 7 and r[1] == "00000000" and r[7] == "00000000" for r in rows)
+
+
+def repo_resolves() -> bool:
+    """Whether the package repository's name resolves. Blocks; call off the loop."""
+    try:
+        socket.getaddrinfo(REPO_HOST, 443)
+    except OSError:
+        return False
+    return True
+
+
+def read_state() -> dict | None:
+    """The helper's switch record, or None when it cannot be read."""
+    result = containers.proxy_switch_state()
+    state = result.json() if result.ok else None
+    return state if isinstance(state, dict) else None
+
+
+#: The ``at`` of the interrupted record already undone, so one record is not
+#: undone twice; a later interrupted run has a new ``at``.
+_recovered_at: object = object()
+
+
+def _recover_if_cut_short(state: dict) -> dict | None:
+    """Undo a run the helper reports as interrupted, and read the record again.
+
+    The helper shows a ``running`` record with no unit as ``failed`` with the
+    error ``interrupted``; the record itself still says ``running`` until the
+    undo has run, which is what puts a stopped unit's container back. Covers
+    ``systemctl stop`` of the unit while boneIO keeps running (a boot unit
+    covers a reboot). Once per interrupted record.
+    """
+    global _recovered_at
+    if state.get("running") or state.get("error") != "interrupted":
+        return state
+    if state.get("at") == _recovered_at:
+        return state
+    _LOGGER.warning("Proxy switch was interrupted; undoing it")
+    _recovered_at = state.get("at")
+    containers.proxy_switch_recover()
+    return read_state()
+
+
+def _finished(state: dict) -> bool:
+    """Whether no further automatic attempt is due."""
+    attempts = state.get("attempts")
+    return state.get("state") == "done" or (isinstance(attempts, int) and attempts >= MAX_ATTEMPTS)
+
+
+async def attempt_switch() -> bool:
+    """One look: start the switch if every condition holds, and wait for it.
+
+    Returns:
+        Whether the automatic task is finished: Caddy is the package, or the
+        attempts are used up. False when it should look again later.
+    """
+    if not await asyncio.to_thread(containers.helper_supports, "proxy-switch-start"):
+        return False
+    state = await asyncio.to_thread(read_state)
+    if state is None:
+        return False
+    state = await asyncio.to_thread(_recover_if_cut_short, state)
+    if state is None:
+        return False
+    if await asyncio.to_thread(containers.proxy_mode) == "native":
+        return True
+    if state.get("running"):
+        return False
+    if _finished(state):
+        return True
+    if not await asyncio.to_thread(has_default_route):
+        return False
+    if not await asyncio.to_thread(repo_resolves):
+        return False
+
+    started = await asyncio.to_thread(containers.proxy_switch_start)
+    if not started.ok:
+        _LOGGER.warning("Proxy switch did not start: %s", (started.stderr or started.stdout).strip())
+        return False
+    _LOGGER.info("Proxy switch started")
+    for _ in range(MAX_POLLS):
+        await asyncio.sleep(POLL)
+        state = await asyncio.to_thread(read_state)
+        if state is not None and not state.get("running"):
+            break
+    if state is None:
+        return False
+    _LOGGER.info("Proxy switch finished: %s", state.get("state"))
+    # A unit stopped by hand ends here as interrupted; undo it now rather than
+    # at the next look, which may never come if the panel is what it broke.
+    state = await asyncio.to_thread(_recover_if_cut_short, state) or state
+    return _finished(state)
+
+
+async def run() -> None:
+    """Background task: look 5 minutes after start, then every half hour.
+
+    Ends once Caddy is the package or the automatic attempts are used up.
+    """
+    await asyncio.sleep(START_DELAY)
+    while True:
+        try:
+            if await attempt_switch():
+                return
+        except Exception:  # noqa: BLE001 - a failed look must not end the task
+            _LOGGER.exception("Proxy switch check failed")
+        await asyncio.sleep(RECHECK)

boneio/core/security/certificate.py

@@ -22,6 +22,8 @@ from pathlib import Path
 from cryptography import x509
 from cryptography.hazmat.primitives import hashes, serialization
 
+from boneio.core import containers
+
 _LOGGER = logging.getLogger(__name__)
 
 #: Refuse anything larger. A certificate chain is a few kilobytes; a megabyte
@@ -231,6 +233,41 @@ ROOT_CA = (
     / "authorities" / "local" / "root.crt"
 )
 
+
+def root_ca() -> bytes | None:
+    """Caddy's root certificate in whichever mode runs it.
+
+    Asked of the root helper, the only reader of the packaged Caddy's data. An
+    old helper that lacks the verb leaves the container mode reading the file
+    itself, as it always did; the packaged mode reads the generator's public
+    export, since its data directory is not the application's to read.
+
+    Returns:
+        The PEM, or None when there is none yet.
+    """
+    pem = containers.root_ca()
+    if pem is not None:
+        return pem
+    try:
+        return (
+            ROOT_CA_EXPORT if containers.proxy_mode() == "native" else ROOT_CA
+        ).read_bytes()
+    except OSError:
+        return None
+
+
+#: The public copy of that certificate the packaged Caddy's generator writes
+#: on every start and reload, world-readable, so that asking whether one exists
+#: needs no sudo.
+ROOT_CA_EXPORT = Path("/var/lib/boneio/proxy/root.crt")
+
+
+def root_ca_exists() -> bool:
+    """Whether a root certificate is there to offer; a plain file check."""
+    path = ROOT_CA_EXPORT if containers.proxy_mode() == "native" else ROOT_CA
+    return path.exists()
+
+
 #: The key is a secret, and it is written by the account the panel runs as.
 KEY_MODE = 0o600
 CERT_MODE = 0o644

boneio/core/system_ops.py

@@ -379,3 +379,13 @@ def os_update_log(timeout: int = 30) -> Result:
 def os_autoupdate_set(enabled: bool, timeout: int = 60) -> Result:
     """Switch automatic security updates on or off. Never reboots either way."""
     return run("os-autoupdate-set", "on" if enabled else "off", timeout=timeout)
+
+
+def disk_usage(timeout: int = 120) -> Result:
+    """Docker images, the journal and the apt cache, in bytes, as JSON."""
+    return run("disk-usage", timeout=timeout)
+
+
+def disk_clean(target: str, timeout: int = 360) -> Result:
+    """Free space in ``docker`` (unused images) or ``apt`` (the package cache)."""
+    return run("disk-clean", target, timeout=timeout)

boneio/{example_config → factory_config/0.8}/24x16/config.yaml

@@ -25,11 +25,11 @@ binary_sensor: !include binary_sensor.yaml
 output: !include output24x16A.yaml
 
 boneio:
-  config_version: 4
+  config_version: 7
   name: "boneIO Black 24x16A"
   version: 0.8
   device_type: "24x16A"
-  
+
 modbus:
   uart: uart4
 
@@ -37,7 +37,12 @@ logger:
   default: info
 
 web:
-  port: 8090 #If you change this you need to change Nginx proxy settings in /home/boneio/docker/
-  proxy_port: 8443
-# adc: !include adc.yaml Uncomment only if needed. Not supported yet in v1.0.0
-
+  # Panel nie jest wystawiony po czystym HTTP na sieć lokalną.
+  #
+  # Wchodzisz na https://<adres_ip>:8443 (certyfikat self-signed, przeglądarka
+  # ostrzeże raz) albo po kablu USB na http://192.168.7.2:8090.
+  # Żeby wrócić do starego zachowania: expose: all
+  #
+  # Port nie jest tu powtórzony — domyślnie i tak jest to 8090.
+  expose: proxy
+# adc: !include adc.yaml

boneio/{example_config → factory_config/0.8}/24x16/mqtt.yaml

@@ -1,6 +1,6 @@
 host: localhost
 username: boneio
-password: boneio123
+password: !secret mqtt_password
 topic_prefix: boneio
 ha_discovery:
   enabled: yes

boneio/factory_config/0.8/24x16/secrets.yaml

@@ -0,0 +1,4 @@
+# Replaced at the controller's first boot by boneio-mqtt-firstboot with a
+# password drawn for this device alone; the broker gets the same one. The
+# factory value below only exists so the image's config validates.
+mqtt_password: boneio123