boneio 1.5.2.dev1__tar.gz → 1.6.0.dev2__tar.gz

boneio-1.6.0.dev2/MANIFEST.in

@@ -0,0 +1,11 @@
+include README.md
+include requirements.txt
+include LICENSE
+recursive-include boneio *.yaml
+recursive-include boneio *.json
+recursive-include boneio *.ttf
+recursive-include boneio/webui/frontend-dist *
+# 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
+recursive-include boneio *.sig

{boneio-1.5.2.dev1/boneio.egg-info → boneio-1.6.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boneio
-Version: 1.5.2.dev1
+Version: 1.6.0.dev2
 Summary: Python App for BoneIO
 Author-email: Paweł Szafer <pszafer@gmail.com>
 License: GNU General Public License v3.0
@@ -33,7 +33,7 @@ Requires-Dist: qrcode==8.2
 Requires-Dist: gpiod==2.3.0
 Requires-Dist: requests==2.32.5
 Requires-Dist: packaging==25.0
-Requires-Dist: aioesphomeapi>=29.0.0
+Requires-Dist: aioesphomeapi>=45.0.0
 Requires-Dist: zeroconf>=0.148.0
 Requires-Dist: canopen-asyncio>=2.4.1
 Dynamic: license-file

{boneio-1.5.2.dev1 → boneio-1.6.0.dev2}/boneio/bonecli.py

@@ -37,6 +37,11 @@ def get_arguments() -> argparse.Namespace:
         description="boneIO app for BeagleBone Black.",
     )
     subparsers = parser.add_subparsers(dest=ACTION, required=True)
+
+    from boneio.core.auth.cli import add_accounts_parser
+
+    add_accounts_parser(subparsers)
+
     run_parser = subparsers.add_parser("run")
     run_parser.add_argument(
         "--debug",
@@ -385,6 +390,10 @@ def main() -> int:
             mqttpassword=args.mqttpassword,
             debug=debug,
         )
+    elif args.action == "accounts":
+        from boneio.core.auth.cli import run_accounts_command
+
+        exit_code = run_accounts_command(args=args)
     elif args.action == "modbus":
         _LOGGER.info("BoneIO Modbus helper %s .", __version__)
         exit_code = run_modbus_command(

boneio-1.6.0.dev2/boneio/components/cover/__init__.py

@@ -0,0 +1,6 @@
+"""Cover classes."""
+from .remote import RemoteCoverOutput
+from .time_based import TimeBasedCover
+from .venetian import VenetianCover
+
+__all__ = ["RemoteCoverOutput", "TimeBasedCover", "VenetianCover"]

boneio-1.6.0.dev2/boneio/components/cover/remote.py

@@ -0,0 +1,277 @@
+"""Remote cover output for covers on remote devices (ESPHome API).
+
+``RemoteCoverOutput`` provides a duck-type compatible interface with
+:class:`TimeBasedCover` / :class:`VenetianCover` so that the conditions
+system (``is_open`` / ``is_closed``), ``CoverManager.get_cover()``,
+and WebSocket event emission work transparently with remote covers.
+
+The actual hardware control is delegated to the parent
+``ESPHomeDeviceManager`` via ``control_cover()``.
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import TYPE_CHECKING, Any
+
+from boneio.const import CLOSED, CLOSING, COVER, IDLE, OPEN, OPENING
+from boneio.core.events import EventBus
+from boneio.models import CoverState
+from boneio.models.events import CoverEvent
+
+if TYPE_CHECKING:
+    from boneio.core.messaging import MessageBus
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class RemoteCoverOutput:
+    """Remote cover from ESPHome — duck-type compatible with local Cover.
+
+    Provides the same public interface that the condition evaluators and
+    the ``CoverManager`` expect:
+
+    - ``is_open`` / ``is_closed`` property for action conditions
+    - ``state`` / ``position`` / ``tilt`` for state reporting
+    - ``on_remote_state_change()`` callback from ESPHome subscription
+    - ``CoverEvent`` emission on EventBus for WebSocket clients
+
+    Args:
+        id: Entity identifier (usually ``{device_id}_{cover_id}``).
+        name: Human-readable display name.
+        device_id: ID of the remote device hosting this cover.
+        cover_id: Entity object_id on the remote device.
+        remote_source: Transport protocol (``esphome_api``).
+        event_bus: Central event bus for emitting ``CoverEvent`` objects.
+        kind: Cover device class (``blind``, ``shutter``, ``gate``, etc.).
+        show_in_ha: Whether to publish HA autodiscovery.
+        area: Optional HA area assignment.
+    """
+
+    # Duck-type compatibility with local covers
+    is_remote: bool = True
+
+    def __init__(
+        self,
+        *,
+        id: str,
+        name: str,
+        device_id: str,
+        cover_id: str,
+        remote_source: str,
+        event_bus: EventBus,
+        message_bus: MessageBus | None = None,
+        topic_prefix: str = "",
+        kind: str = "cover",
+        show_in_ha: bool = False,
+        area: str | None = None,
+    ) -> None:
+        self._id = id
+        self._name = name
+        self._device_id = device_id
+        self._cover_id = cover_id
+        self._remote_source = remote_source
+        self._event_bus = event_bus
+        self._message_bus: MessageBus | None = message_bus
+        self._send_topic = f"{topic_prefix}/{COVER}/{id}" if topic_prefix else ""
+        self._kind = kind
+        self.show_in_ha = show_in_ha
+        self.area: str | None = area
+
+        # State tracking
+        self._position: int = 0  # 0=closed, 100=open
+        self._tilt: int = 0
+        self._current_operation: str = IDLE
+        self._last_timestamp: float = 0.0
+        self._available: bool = False
+
+        # Reference to remote device manager — set by registration.
+        self._device_manager: Any = None
+        self._remote_devices_ref: Any = None
+
+    # ------------------------------------------------------------------
+    # Public properties (duck-type compatible with TimeBasedCover)
+    # ------------------------------------------------------------------
+
+    @property
+    def id(self) -> str:
+        """Entity identifier."""
+        return self._id
+
+    @property
+    def name(self) -> str:
+        """Human-readable name."""
+        return self._name
+
+    @property
+    def kind(self) -> str:
+        """Cover device class (blind, shutter, gate, etc.)."""
+        return self._kind
+
+    @property
+    def state(self) -> str:
+        """Current state as string (open/closed/opening/closing)."""
+        if self._current_operation == OPENING:
+            return OPENING
+        elif self._current_operation == CLOSING:
+            return CLOSING
+        else:
+            return CLOSED if self._position == 0 else OPEN
+
+    @property
+    def is_open(self) -> bool:
+        """True when cover position > 0 (not fully closed)."""
+        return self._position > 0
+
+    @property
+    def is_closed(self) -> bool:
+        """True when cover is fully closed (position == 0)."""
+        return self._position == 0
+
+    @property
+    def position(self) -> int:
+        """Current cover position (0-100)."""
+        return self._position
+
+    @property
+    def tilt(self) -> int:
+        """Current tilt position (0-100)."""
+        return self._tilt
+
+    @property
+    def current_operation(self) -> str:
+        """Current operation (idle/opening/closing)."""
+        return self._current_operation
+
+    @property
+    def last_timestamp(self) -> float:
+        """Timestamp of last state update."""
+        return self._last_timestamp
+
+    # ------------------------------------------------------------------
+    # Remote state callback
+    # ------------------------------------------------------------------
+
+    def on_remote_state_change(self, state_dict: dict[str, Any]) -> None:
+        """Called by ESPHome device manager when cover state changes.
+
+        Args:
+            state_dict: Cover state from ESPHome containing:
+                - position: float (0.0-1.0)
+                - tilt: float | None
+                - current_operation: int (0=IDLE, 1=OPENING, 2=CLOSING)
+        """
+        position_raw = state_dict.get("position")
+        if position_raw is not None:
+            self._position = round(float(position_raw) * 100)
+
+        tilt_raw = state_dict.get("tilt")
+        if tilt_raw is not None:
+            self._tilt = round(float(tilt_raw) * 100)
+
+        current_op_int = state_dict.get("current_operation", 0)
+        if current_op_int == 1:
+            self._current_operation = OPENING
+        elif current_op_int == 2:
+            self._current_operation = CLOSING
+        else:
+            self._current_operation = IDLE
+
+        self._last_timestamp = time.time()
+        self._available = True
+
+        _LOGGER.debug(
+            "Remote cover '%s' state: position=%d%%, tilt=%d%%, operation=%s",
+            self._id,
+            self._position,
+            self._tilt,
+            self._current_operation,
+        )
+
+        # Emit CoverEvent for WebSocket clients
+        self._emit_cover_event()
+
+    def _emit_cover_event(self) -> None:
+        """Emit a CoverEvent on the event bus."""
+        event = CoverState(
+            id=self._id,
+            name=self._name,
+            state=self.state,
+            kind=self._kind,
+            timestamp=self._last_timestamp,
+            current_operation=self._current_operation,
+            position=self._position,
+            tilt=self._tilt,
+        )
+        self._event_bus.trigger_event(CoverEvent(entity_id=self._id, state=event))
+
+    # ------------------------------------------------------------------
+    # Device manager resolution (lazy — same pattern as RemoteOutputBase)
+    # ------------------------------------------------------------------
+
+    def _resolve_device_manager(self) -> bool:
+        """Try to resolve device manager lazily from remote_devices reference.
+
+        Returns:
+            ``True`` if device manager is now available.
+        """
+        if self._device_manager is not None:
+            return True
+        if self._remote_devices_ref is None:
+            return False
+        device = self._remote_devices_ref.get_device(self._device_id)
+        if device is not None:
+            self._device_manager = device
+            self._remote_devices_ref = None
+            self._register_state_callback()
+            _LOGGER.info(
+                "Lazily resolved device manager for remote cover '%s' (device '%s')",
+                self._id,
+                self._device_id,
+            )
+            return True
+        return False
+
+    def _register_state_callback(self) -> None:
+        """Register a cover state change callback on the device manager.
+
+        Called after device manager is resolved (lazy or immediate).
+        ESPHome devices will call back on cover state changes.
+        Also syncs current state from the device if available.
+        """
+        if self._device_manager is None:
+            return
+        register_fn = getattr(self._device_manager, "register_cover_callback", None)
+        if register_fn is not None:
+            register_fn(self._cover_id, self.on_remote_state_change)
+            _LOGGER.debug(
+                "Registered cover callback for remote cover '%s' on device '%s'",
+                self._id,
+                self._device_id,
+            )
+
+        # Sync initial state from device's current known states
+        self._sync_initial_state()
+
+    def _sync_initial_state(self) -> None:
+        """Sync initial state from ESPHome device's cached cover states."""
+        if self._device_manager is None:
+            return
+
+        cover_states: dict[str, dict[str, Any]] = getattr(
+            self._device_manager, "_cover_states", {}
+        )
+        if self._cover_id in cover_states:
+            self.on_remote_state_change(cover_states[self._cover_id])
+            _LOGGER.debug(
+                "Synced initial cover state for '%s': position=%d%%",
+                self._id,
+                self._position,
+            )
+
+    def __repr__(self) -> str:
+        return (
+            f"RemoteCoverOutput(id={self._id!r}, device={self._device_id!r}, "
+            f"cover={self._cover_id!r}, position={self._position})"
+        )

boneio-1.6.0.dev2/boneio/core/auth/__init__.py

@@ -0,0 +1,24 @@
+"""Account model, password hashing and persistence for boneIO web accounts."""
+
+from boneio.core.auth.hashing import hash_password, needs_rehash, verify_password
+from boneio.core.auth.models import Role, User
+from boneio.core.auth.store import (
+    USERS_FILENAME,
+    UserStore,
+    UserStoreError,
+    normalize_username,
+    validate_password,
+)
+
+__all__ = [
+    "USERS_FILENAME",
+    "Role",
+    "User",
+    "UserStore",
+    "UserStoreError",
+    "hash_password",
+    "needs_rehash",
+    "normalize_username",
+    "validate_password",
+    "verify_password",
+]

boneio-1.6.0.dev2/boneio/core/auth/cli.py

@@ -0,0 +1,242 @@
+"""``boneio accounts`` — manage web UI accounts from the shell.
+
+This is the recovery path. A device whose administrator password is lost has no
+other way back in: there is no email to send a link to, and wiping
+``users.json`` by hand would take every other account with it.
+
+It is also how a controller gets an account without a browser, which makes
+provisioning scriptable and means a freshly flashed device does not have to be
+clicked through the wizard.
+
+Passwords are never taken from the command line. An argument is visible in
+``ps`` to every user on the box and lands in shell history, so they are always
+prompted for, with echo off.
+
+Changes take effect immediately: the running web server notices that
+``users.json`` changed and re-reads it, so recovering a password does not mean
+restarting a controller in the middle of whatever it is automating.
+"""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import logging
+import os
+import sys
+from pathlib import Path
+
+from boneio.core.auth.models import Role
+from boneio.core.auth.store import UserStore, UserStoreError, validate_password
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _prompt_password(prompt: str, username: str | None = None) -> str | None:
+    """Ask for a password twice, with echo off.
+
+    Args:
+        prompt: Text for the first prompt.
+        username: Account the password is for, so the same policy the store
+            applies is reported here rather than after the second prompt.
+
+    Returns:
+        The password, or None if the two entries differed, it was empty, or the
+        policy rejected it.
+    """
+    first = getpass.getpass(f"{prompt}: ")
+    if not first:
+        print("Aborted: empty password.", file=sys.stderr)
+        return None
+
+    try:
+        validate_password(first, username)
+    except UserStoreError as err:
+        print(f"Rejected: {err}", file=sys.stderr)
+        return None
+
+    second = getpass.getpass("Repeat password: ")
+    if first != second:
+        print("Aborted: the passwords do not match.", file=sys.stderr)
+        return None
+
+    return first
+
+
+def _warn_on_ownership(store: UserStore, config_path: Path) -> None:
+    """Warn when the file was written as the wrong user.
+
+    Running this under ``sudo`` leaves ``users.json`` owned by root, and the
+    service — which runs as the ``boneio`` user — then cannot rewrite it. The
+    failure would only show up later, when someone changes a password from the
+    web UI and it silently fails, so it is called out here instead.
+
+    Args:
+        store: The account store just written.
+        config_path: Path to config.yaml, used as the reference owner.
+    """
+    try:
+        written_uid = store.path.stat().st_uid
+        expected_uid = config_path.stat().st_uid
+    except OSError:
+        return
+
+    if written_uid != expected_uid:
+        print(
+            f"WARNING: {store.path} is now owned by uid {written_uid}, but "
+            f"{config_path} belongs to uid {expected_uid}. The boneIO service "
+            f"probably cannot write it. Fix with:\n"
+            f"  sudo chown {expected_uid} {store.path}",
+            file=sys.stderr,
+        )
+
+
+def run_accounts_command(args: argparse.Namespace) -> int:
+    """Execute an ``accounts`` subcommand.
+
+    Args:
+        args: Parsed arguments, carrying ``accounts_action``, ``config`` and,
+            depending on the subcommand, ``username`` and ``role``.
+
+    Returns:
+        Process exit code.
+    """
+    config_path = Path(args.config).expanduser()
+    if not config_path.exists():
+        print(f"No config file at {config_path}", file=sys.stderr)
+        return 1
+
+    store = UserStore.for_config_file(config_path)
+    try:
+        store.load()
+    except UserStoreError as err:
+        print(f"Cannot read the account store: {err}", file=sys.stderr)
+        return 1
+
+    action = args.accounts_action
+
+    if action == "list":
+        users = store.list_users()
+        if not users:
+            print(f"No accounts yet ({store.path} does not exist).")
+            print("Create one with:  boneio accounts add <username> --role admin")
+            return 0
+        width = max(len(user.username) for user in users)
+        for user in users:
+            print(f"{user.username:<{width}}  {user.role}  created {user.created_at}")
+        return 0
+
+    if action == "add":
+        password = _prompt_password(
+            f"New password for '{args.username}'", args.username
+        )
+        if password is None:
+            return 1
+        try:
+            user = store.add_user(args.username, password, Role(args.role))
+        except UserStoreError as err:
+            print(f"Could not create the account: {err}", file=sys.stderr)
+            return 1
+        _warn_on_ownership(store, config_path)
+        print(f"Created {user.role} account '{user.username}'.")
+        return 0
+
+    if action == "reset":
+        if store.get_user(args.username) is None:
+            print(f"No such account: {args.username}", file=sys.stderr)
+            return 1
+        password = _prompt_password(
+            f"New password for '{args.username}'", args.username
+        )
+        if password is None:
+            return 1
+        try:
+            store.set_password(args.username, password)
+        except UserStoreError as err:
+            print(f"Could not change the password: {err}", file=sys.stderr)
+            return 1
+        _warn_on_ownership(store, config_path)
+        print(f"Password changed for '{args.username}'. It takes effect immediately.")
+        return 0
+
+    if action == "delete":
+        try:
+            store.delete_user(args.username)
+        except UserStoreError as err:
+            print(f"Could not delete the account: {err}", file=sys.stderr)
+            return 1
+        print(f"Deleted account '{args.username}'.")
+        return 0
+
+    print(f"Unknown accounts action: {action}", file=sys.stderr)
+    return 1
+
+
+def add_accounts_parser(subparsers: argparse._SubParsersAction) -> None:
+    """Register the ``accounts`` subcommand.
+
+    Args:
+        subparsers: The top-level subparser collection from bonecli.
+    """
+    accounts_parser = subparsers.add_parser(
+        "accounts",
+        help="Manage web UI accounts (create, reset a password, list, delete)",
+        description=(
+            "Manage the accounts in users.json. This is the recovery path when "
+            "an administrator password is lost, and the way to provision a "
+            "device without a browser. Passwords are always prompted for, "
+            "never passed as arguments."
+        ),
+    )
+    # bonecli's main() reads args.debug before dispatching, so every subcommand
+    # has to carry one.
+    accounts_parser.set_defaults(debug=0)
+    accounts_parser.add_argument(
+        "-c",
+        "--config",
+        metavar="path_to_config",
+        default=os.environ.get("BONEIO_CONFIG", "./config.yaml"),
+        help="boneIO config file; users.json lives next to it",
+    )
+
+    actions = accounts_parser.add_subparsers(dest="accounts_action", required=True)
+
+    def _with_config(parser: argparse.ArgumentParser) -> argparse.ArgumentParser:
+        """Accept -c after the subcommand as well as before it.
+
+        argparse only looks for an option on the parser that is parsing at the
+        time, so `accounts add pawel -c cfg.yaml` — the order everyone reaches
+        for — is rejected unless each action accepts it too. SUPPRESS keeps the
+        action's default from overwriting a value already given to `accounts`.
+
+        Args:
+            parser: Action subparser to extend.
+
+        Returns:
+            The same parser, for chaining.
+        """
+        parser.add_argument(
+            "-c",
+            "--config",
+            metavar="path_to_config",
+            default=argparse.SUPPRESS,
+            help="boneIO config file; users.json lives next to it",
+        )
+        return parser
+
+    _with_config(actions.add_parser("list", help="List accounts and their roles"))
+
+    add_action = _with_config(actions.add_parser("add", help="Create an account"))
+    add_action.add_argument("username", help="Username to create")
+    add_action.add_argument(
+        "--role",
+        choices=[str(Role.ADMIN), str(Role.VIEWER)],
+        default=str(Role.VIEWER),
+        help="Role to grant (default: viewer)",
+    )
+
+    reset_action = _with_config(actions.add_parser("reset", help="Set a new password"))
+    reset_action.add_argument("username", help="Account to change")
+
+    delete_action = _with_config(actions.add_parser("delete", help="Remove an account"))
+    delete_action.add_argument("username", help="Account to remove")