rustuya-local 0.0.1__tar.gz

rustuya_local-0.0.1/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

rustuya_local-0.0.1/.github/workflows/_test.yml

@@ -0,0 +1,103 @@
+name: Test (reusable)
+
+# Single source of truth for rustuya-local's pre-merge / pre-publish checks. Called from ci.yml
+# on push/PR and as a gate from release.yml, so a commit that fails these can't reach PyPI.
+#
+# rustuya-local depends on sibling repos that are not on PyPI yet (il-ha, rustuya-manager,
+# tuyamock -- see pyproject.toml's [tool.uv.sources]), so this checks them out as siblings under
+# $GITHUB_WORKSPACE and installs with `uv`: `uv` is what resolves [tool.uv.sources]'s local-path
+# overrides, plain `pip install -e ".[test]"` cannot see them and would try (and fail) to fetch
+# "il-ha" from PyPI.
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: test (py${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        # il-ha (the test/fullstack sibling dep) requires Python>=3.14; rustuya-local's own
+        # requires-python floor (3.13, in pyproject.toml) stays lower since only the test extras
+        # need 3.14, not the base package.
+        python-version: ["3.14"]
+
+    steps:
+      - name: Check out rustuya-local
+        uses: actions/checkout@v7
+        with:
+          path: rustuya-local
+
+      # Siblings for the path dependencies in rustuya-local's [tool.uv.sources]. None of the
+      # three is on PyPI yet -- if a checkout here 404s, that sibling repo hasn't been pushed to
+      # GitHub (or renamed/moved) and this needs updating to match.
+      - name: Check out il-ha
+        uses: actions/checkout@v7
+        with:
+          repository: 3735943886/ildevice-homeassistant
+          path: il-ha
+
+      - name: Check out rustuya-manager
+        uses: actions/checkout@v7
+        with:
+          repository: 3735943886/rustuya-manager
+          path: rustuya-manager
+
+      - name: Check out tuyamock
+        uses: actions/checkout@v7
+        with:
+          repository: 3735943886/tuyamock
+          path: tuyamock
+
+      # tuya2ildevice is on PyPI (installed below via uv), so this isn't for dependency
+      # resolution -- it's so tests/e2e/test_full_stack_devices.py can reach its sibling
+      # checkout's tests/golden fixture data, which isn't shipped in the published package.
+      - name: Check out tuya2ildevice
+        uses: actions/checkout@v7
+        with:
+          repository: 3735943886/tuya2ildevice
+          path: tuya2ildevice
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Install + start mosquitto
+        # tests/ha/ and tests/e2e/ each skip gracefully (pytest.skip / importorskip) when
+        # mosquitto, pyrustuyabridge or tuyamock is missing (see their conftest.py) -- installed
+        # here so CI actually exercises those tests instead of silently skipping them.
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends mosquitto mosquitto-clients
+          sudo tee /etc/mosquitto/conf.d/ci.conf > /dev/null <<'EOF'
+          listener 1883
+          allow_anonymous true
+          EOF
+          sudo systemctl restart mosquitto
+          for _ in $(seq 1 20); do
+            if mosquitto_sub -h localhost -t '$SYS/broker/version' -C 1 -W 2 >/dev/null 2>&1; then
+              echo "mosquitto reachable"
+              exit 0
+            fi
+            sleep 0.5
+          done
+          echo "mosquitto did not become reachable"
+          sudo journalctl -u mosquitto --no-pager | tail -50
+          exit 1
+
+      - name: Install rustuya-local + test extras
+        working-directory: rustuya-local
+        run: uv pip install --system -e ".[test,test-ha,fullstack]"
+
+      - name: pytest
+        working-directory: rustuya-local
+        run: pytest -q

rustuya_local-0.0.1/.github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+
+# Runs on PRs targeting main and on direct pushes to main.
+# The actual pytest matrix lives in _test.yml so the same checks also run as a
+# pre-flight gate inside release.yml.
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    uses: ./.github/workflows/_test.yml

rustuya_local-0.0.1/.github/workflows/hacs.yml

@@ -0,0 +1,24 @@
+name: HACS Validation
+
+# Validates that custom_components/rustuya can be installed through HACS (hacs.json, manifest.json
+# shape, repo metadata). Runs on every push/PR plus a daily schedule so a change on GitHub's side
+# (e.g. a new HACS check) surfaces without needing a code change here to trigger it.
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: HACS validation
+        uses: hacs/action@main
+        with:
+          category: integration

rustuya_local-0.0.1/.github/workflows/hassfest.yml

@@ -0,0 +1,20 @@
+name: Hassfest
+
+# Home Assistant's own manifest.json / translations / config-flow schema validator for
+# custom_components/rustuya. HACS runs this same check before listing an integration, so it's
+# worth catching here first.
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: home-assistant/actions/hassfest@master

rustuya_local-0.0.1/.github/workflows/release.yml

@@ -0,0 +1,108 @@
+name: Release
+
+# Builds + publishes rustuya-local when a `v*` tag is pushed. Routes based on the tag shape:
+#   v0.1.0        -> PyPI      (plain MAJOR.MINOR.PATCH = final release)
+#   v0.1.0rc1     -> TestPyPI  (any PEP 440 pre-release/dev/post suffix)
+#   v0.0.1.dev0   -> TestPyPI
+#
+# PyPI refuses re-uploads of the same version forever, so the pre-release cycle on TestPyPI is
+# the safety net: tag a pre-release, verify the wheel installs, fix any issues, then tag the
+# plain version for the real index.
+#
+# OIDC trusted publishing -- no API tokens stored in repo secrets. One-time setup needed on BOTH
+# registries before the first tag (the trust DBs are separate):
+#   https://pypi.org/manage/account/publishing/
+#   https://test.pypi.org/manage/account/publishing/
+# Same entry on each:
+#   Project name: rustuya-local
+#   Owner:        3735943886
+#   Repository:   rustuya-local
+#   Workflow:     release.yml
+#   Environment:  pypi
+
+on:
+  push:
+    tags:
+      - "v*"
+
+# OIDC needs id-token: write. The publish job additionally needs contents: write to create the
+# GitHub Release; that's granted at the job level below so the reusable test job inherits only read.
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  # Same checks as CI -- gates the publish so a broken tag can't reach PyPI.
+  test:
+    uses: ./.github/workflows/_test.yml
+
+  publish:
+    name: Build + publish
+    needs: test
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/rustuya-local
+    permissions:
+      contents: write
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Set up Python
+        uses: actions/setup-python@v7
+        with:
+          python-version: "3.13"
+
+      - name: Sanity-check that the tag matches the package version
+        # rustuya-local's version is single-sourced as a static field in pyproject.toml (no
+        # dynamic __version__.py to read instead) -- catches tagging without bumping it.
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          PKG_VER=$(python -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          if [ "$TAG" != "$PKG_VER" ]; then
+            echo "Tag v$TAG does not match pyproject.toml version $PKG_VER" >&2
+            exit 1
+          fi
+
+      - name: Decide TestPyPI vs PyPI from the tag shape
+        id: target
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          if [[ "$TAG" =~ ^[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            echo "url=https://upload.pypi.org/legacy/" >> "$GITHUB_OUTPUT"
+            echo "name=PyPI" >> "$GITHUB_OUTPUT"
+            echo "prerelease=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "url=https://test.pypi.org/legacy/" >> "$GITHUB_OUTPUT"
+            echo "name=TestPyPI" >> "$GITHUB_OUTPUT"
+            echo "prerelease=true" >> "$GITHUB_OUTPUT"
+          fi
+          echo "Target: $TAG -> $(grep '^name=' "$GITHUB_OUTPUT" | tail -1)"
+
+      - name: Install build tooling
+        run: python -m pip install --upgrade pip build twine
+
+      - name: Build sdist + wheel
+        # Building only needs rustuya-local's own checkout: [tool.uv.sources]'s sibling paths are
+        # a uv dev-install convenience, not something `python -m build` resolves or needs.
+        run: python -m build --sdist --wheel
+
+      - name: Check distribution metadata
+        run: twine check dist/*
+
+      - name: Publish to ${{ steps.target.outputs.name }}
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: ${{ steps.target.outputs.url }}
+
+      - name: Create or update the GitHub Release
+        uses: softprops/action-gh-release@v3
+        with:
+          files: dist/*
+          draft: false
+          prerelease: ${{ steps.target.outputs.prerelease }}
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

rustuya_local-0.0.1/.gitignore

@@ -0,0 +1,8 @@
+.claude/
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+.ruff_cache/
+*.egg-info/
+legacy/

rustuya_local-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 3735943886
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rustuya_local-0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.5
+Name: rustuya-local
+Version: 0.0.1
+Summary: Local Tuya control: rustuya-bridge -> tuya2ildevice -> IL (ildevice). HA-independent core.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: pyrustuyabridge<0.4,>=0.3.0
+Requires-Dist: tuya2ildevice[host]<0.3,>=0.2.0
+Provides-Extra: fullstack
+Requires-Dist: tuyamock; extra == 'fullstack'
+Provides-Extra: test
+Requires-Dist: il-ha; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio; extra == 'test'
+Provides-Extra: test-ha
+Requires-Dist: pytest-homeassistant-custom-component; extra == 'test-ha'

rustuya_local-0.0.1/README.md

@@ -0,0 +1,67 @@
+# rustuya-local
+
+[![hacs_badge](https://img.shields.io/badge/HACS-Custom-41BDF5.svg)](https://github.com/hacs/integration)
+
+Local control of Tuya devices through [rustuya-bridge](https://github.com/3735943886/rustuya-bridge), as IL
+([ildevice](../ildevice)) devices. It runs without Home Assistant as the standalone `rustuya-local` daemon
+(this package); `custom_components/rustuya` is a thin Home Assistant integration on top of the same core, installable
+through HACS.
+
+```
+rustuya-bridge ──MQTT──► rustuya-local ──MQTT (il/…)──► il-ha / any IL consumer
+ raw LAN dps             Runner + tuya2ildevice.Hub      descriptors, values, commands (il-mqtt.md)
+```
+
+- **tuya2ildevice** (sibling repo) is the only place that interprets Tuya *and* the host around it: `tuya2ildevice.host`
+  runs the Hub on MQTT (Last Will presence, reconnects, runtime add/remove, following `tuyadevices.json`, the bridge's
+  own topic templates).
+- **rustuya-local** is only the deployment: a configuration file and the `rustuya-local run` daemon on top of that host
+  (about 150 lines). It does not depend on il-ha.
+- **il-ha** (sibling repo) turns IL descriptors into Home Assistant entities; it never sees Tuya.
+
+## Run
+
+```
+uv venv && uv pip install -e ".[test]"        # sibling checkouts ../tuya2ildevice and ../il-ha are path dependencies
+rustuya-local run --config config.json
+```
+
+`config.json` (see `src/rustuya_local/config.py`): the bridge and IL brokers, the IL prefix, the device list and options
+for the Hub (`allow_hazardous`, `expose_unused`, `overrides`). The device list is the `tuyadevices.json` that
+[rustuya-manager](../rustuya-manager) keeps (its QR-login wizard writes it, with each device's cloud
+`category`/`function`/`status_range`/`local_strategy`); rustuya-local follows it as it changes and never writes it. The
+bridge's own topic templates are read from its retained `{root}/bridge/config`.
+
+## Home Assistant (HACS)
+
+`custom_components/rustuya` runs the same `Hub`/`Runner` as the standalone daemon, as a background task tied to a
+config entry, with an optional embedded rustuya-bridge. It creates no entities itself — install
+[il-ha](../il-ha) (or any IL consumer) separately to turn its devices into entities.
+
+1. HACS → the three-dot menu → **Custom repositories** → add this repository URL with category **Integration**.
+2. Install **Rustuya**, restart Home Assistant.
+3. Settings → Devices & Services → **Add Integration** → **Rustuya**, and follow the config flow.
+
+## Tests
+
+```
+.venv/bin/python -m pytest
+```
+
+Everything here needs the sibling repos and, for the last two groups, `mosquitto`, `pyrustuya-bridge` and `tuyamock`
+(`pip install -e ".[test,fullstack]"`); those are skipped when missing. Parity with Home Assistant core's fixtures lives in
+`tuya2ildevice/tests/chain`, the wire and topic vectors in `ildevice/vectors`.
+
+- `tests/unit/`: the configuration.
+- `tests/e2e/test_chain_*.py`, `test_daemon.py`: the runner with il-ha's consumer model on the other side, in one process
+  and over a real broker; the daemon as a subprocess.
+- `tests/e2e/test_full_stack*.py`: the real rustuya-bridge (`pyrustuyabridge`, in process) and Tuya device emulators
+  (`tuyamock`) around the daemon: state, commands, rejections, a device dropping off and returning, a daemon restart, and a
+  differential check that 38 real device shapes come out of the whole chain exactly as `tuya2ildevice` computes them.
+
+## Status
+
+Planning, progress and open decisions: `docs/REDESIGN.md`. The earlier Home Assistant-only implementation is kept in
+`legacy/` (not in git) until the new one is verified; `docs/STATUS.md` describes it.
+
+Licence: `LICENSE` (MIT). Third-party notices: `THIRD_PARTY_NOTICES.md`.

rustuya_local-0.0.1/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,28 @@
+# Third-party notices
+
+This repository is config and a daemon/HA integration only: it contains no vendored or reproduced third-party
+code. The Apache-2.0-derived reproduction of Home Assistant core's `tuya` integration, tuya-device-handlers and
+tuya-device-sharing-sdk that this project used to carry directly (`entity_engine.py`, `bridge_device.py`,
+`rustuya_ha.tuya2ha.v2`) moved out during the redesign to `tuya2ildevice` — see
+[that repository's THIRD_PARTY_NOTICES.md](https://github.com/3735943886/tuya2ildevice/blob/main/THIRD_PARTY_NOTICES.md)
+for those notices; nothing of it remains here.
+
+## rustuya / rustuya-bridge / rustuya-manager / tuya2ildevice
+
+This project is a client, over MQTT, of [rustuya-bridge](https://github.com/3735943886/rustuya-bridge) (itself
+built on [rustuya](https://github.com/3735943886/rustuya)), converts what it publishes with
+[tuya2ildevice](https://github.com/3735943886/tuya2ildevice), and depends on
+[rustuya-manager](https://github.com/3735943886/rustuya-manager)'s `Manager` facade for device
+registration/removal and the Tuya Cloud QR-login wizard, used only by `custom_components/rustuya_local`'s config
+and options flows. No code from any of these is vendored. `custom_components/rustuya_local/bridge_supervisor.py`
+optionally depends at runtime on the `pyrustuyabridge` PyO3 bindings package, only when the user opts into
+embedded-bridge mode; in external-bridge mode this integration never imports it (the topic layer it talks over is
+`tuya2ildevice`'s own, not `pyrustuyabridge`).
+
+## History
+
+Earlier versions of this repository generated Home Assistant entities directly (`tuya2ha.v2`, later moved here as
+`rustuya_ha.tuya2ha.v2`); see git history for that design. The current architecture produces IL
+(`ildevice`/`il-ha`'s Instance Layer) instead: this repository has no Home Assistant entity code and creates no
+entities itself. All Apache-2.0-derived attribution now lives with the code it actually describes, in
+`tuya2ildevice`.

rustuya_local-0.0.1/custom_components/rustuya/__init__.py

@@ -0,0 +1,127 @@
+"""Rustuya as a Home Assistant integration: runs the same `tuya2ildevice.host.Runner` the standalone
+`rustuya-local` daemon does, as a background task tied to this config entry, with an optional embedded
+rustuya-bridge (`pyrustuyabridge`). It creates no entities and does not depend on il-ha: it is only an IL
+*producer* — install il-ha (or any IL consumer) separately to turn its devices into entities.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+
+from .const import (
+    BRIDGE_EMBEDDED,
+    CONF_ALLOW_HAZARDOUS,
+    CONF_BRIDGE_LOG_LEVEL,
+    CONF_BRIDGE_MODE,
+    CONF_BRIDGE_ROOT,
+    CONF_BRIDGE_STATE_FILE,
+    CONF_BROKER_HOST,
+    CONF_BROKER_PASSWORD,
+    CONF_BROKER_PORT,
+    CONF_BROKER_USERNAME,
+    CONF_DEVICES_PATH,
+    CONF_EXPOSE_UNUSED,
+    CONF_IL_PREFIX,
+    CONF_IL_SOURCE,
+    CONF_WATCH_INTERVAL,
+    DEFAULT_WATCH_INTERVAL,
+    DOMAIN,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class RuntimeData:
+    runner: Any
+    watcher: Any | None
+    bridge_transport: Any
+    il_transport: Any
+    embedded_bridge: Any | None
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    from rustuya_local.bridge_client import BridgeClient
+    from tuya2ildevice import Hub, IlTopics
+    from tuya2ildevice.host import DeviceWatcher, MqttTransport, Runner, load_devices
+
+    from .bridge_supervisor import EmbeddedBridge
+
+    data, options = entry.data, entry.options
+    broker = f"mqtt://{data[CONF_BROKER_HOST]}:{data[CONF_BROKER_PORT]}"
+    username, password = data.get(CONF_BROKER_USERNAME) or None, data.get(CONF_BROKER_PASSWORD) or None
+
+    # a failure partway through (a later transport, the device file, Runner.start) must not leak what already
+    # connected — each `push_async_callback` only runs if everything after it is unwound because of an exception,
+    # or immediately by `stack.pop_all()` never being reached
+    async with contextlib.AsyncExitStack() as stack:
+        embedded_bridge = None
+        if data[CONF_BRIDGE_MODE] == BRIDGE_EMBEDDED:
+            embedded_bridge = EmbeddedBridge(broker, data[CONF_BRIDGE_ROOT], data[CONF_BRIDGE_STATE_FILE],
+                                             data.get(CONF_BRIDGE_LOG_LEVEL, "warn"), username, password)
+            await embedded_bridge.start()
+            stack.push_async_callback(embedded_bridge.stop)
+
+        bridge_transport = MqttTransport(data[CONF_BROKER_HOST], data[CONF_BROKER_PORT],
+                                         client_id=f"rustuya-bridge-{entry.entry_id[:8]}",
+                                         username=username, password=password)
+        await bridge_transport.connect()
+        stack.push_async_callback(bridge_transport.close)
+        bridge_client = BridgeClient(bridge_transport, data[CONF_BRIDGE_ROOT])
+
+        devices = await hass.async_add_executor_job(load_devices, data[CONF_DEVICES_PATH])
+        hub = Hub(devices, il=IlTopics(data.get(CONF_IL_PREFIX, "il"), data.get(CONF_IL_SOURCE, "tuya")),
+                 allow_hazardous=options.get(CONF_ALLOW_HAZARDOUS, False),
+                 expose_unused=options.get(CONF_EXPOSE_UNUSED, False))
+        will = hub.presence(False)
+        il_transport = MqttTransport(data[CONF_BROKER_HOST], data[CONF_BROKER_PORT],
+                                     client_id=f"rustuya-il-{entry.entry_id[:8]}", username=username,
+                                     password=password, will=(will.topic, will.payload, will.qos, will.retain))
+        await il_transport.connect()
+        stack.push_async_callback(il_transport.close)
+
+        runner = Runner(hub, il_transport, on_bridge_command=bridge_client.send_command)
+        bridge_client.runner = runner
+        await runner.start()
+        stack.push_async_callback(runner.stop)
+        await bridge_client.start()
+
+        watcher = None
+        interval = options.get(CONF_WATCH_INTERVAL, DEFAULT_WATCH_INTERVAL)
+        if interval > 0:
+            watcher = DeviceWatcher(data[CONF_DEVICES_PATH], runner, interval)
+            watcher.start()
+            stack.push_async_callback(watcher.stop)
+
+        hass.data.setdefault(DOMAIN, {})[entry.entry_id] = RuntimeData(
+            runner=runner, watcher=watcher, bridge_transport=bridge_transport, il_transport=il_transport,
+            embedded_bridge=embedded_bridge,
+        )
+        entry.async_on_unload(entry.add_update_listener(_async_reload))
+        _LOGGER.info("driving %d device(s) via %s (bridge: %s)", len(devices), data[CONF_BRIDGE_ROOT], data[CONF_BRIDGE_MODE])
+
+        # everything above succeeded: async_unload_entry (RuntimeData) owns closing it now, not this stack
+        stack.pop_all()
+    return True
+
+
+async def _async_reload(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    await hass.config_entries.async_reload(entry.entry_id)
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    runtime: RuntimeData = hass.data[DOMAIN].pop(entry.entry_id)
+    if runtime.watcher:
+        await runtime.watcher.stop()
+    await runtime.runner.stop()
+    await runtime.il_transport.close()
+    await runtime.bridge_transport.close()
+    if runtime.embedded_bridge:
+        await runtime.embedded_bridge.stop()
+    return True

rustuya_local-0.0.1/custom_components/rustuya/bridge_supervisor.py

@@ -0,0 +1,66 @@
+"""An embedded rustuya-bridge: `pyrustuyabridge.PyBridgeServer` run in a background thread, tied to this config
+entry's lifecycle instead of a separate rustuya-bridge process. Same class our own end-to-end tests drive
+(tuya2ildevice/rustuya-local tests/e2e/test_full_stack.py) — proven against a real broker and real Tuya-protocol
+devices, just supervised here instead of by a test fixture.
+
+The embedded bridge still needs a real MQTT broker to talk through (it manages its own native MQTT client); it does
+not remove that requirement, only who launches and owns the bridge process.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import threading
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class EmbeddedBridge:
+    def __init__(self, broker: str, root: str, state_file: str, log_level: str = "warn",
+                 username: str | None = None, password: str | None = None) -> None:
+        self.broker = broker
+        self.root = root
+        self.state_file = state_file
+        self.log_level = log_level
+        self.username = username
+        self.password = password
+        self._server = None
+        self._thread: threading.Thread | None = None
+
+    async def start(self) -> None:
+        import pyrustuyabridge as pb
+
+        kwargs = dict(mqtt_broker=self.broker, mqtt_root_topic=self.root, mqtt_retain=True,
+                      state_file=self.state_file, no_signals=True, log_level=self.log_level)
+        if self.username:
+            kwargs["mqtt_username"] = self.username
+        if self.password:
+            kwargs["mqtt_password"] = self.password
+        self._server = pb.PyBridgeServer(**kwargs)
+        loop = asyncio.get_running_loop()
+        started = loop.create_future()
+
+        def run() -> None:
+            try:
+                self._server.start()
+            except Exception:
+                _LOGGER.exception("the embedded bridge stopped unexpectedly")
+            finally:
+                if not started.done():
+                    loop.call_soon_threadsafe(started.set_result, None)
+
+        self._thread = threading.Thread(target=run, name="rustuya-embedded-bridge", daemon=True)
+        self._thread.start()
+        # give the bridge a moment to fail fast (a bad broker URL, a locked state file) before reporting success;
+        # `run()` resolves `started` on exit, so a quick crash surfaces as this future finishing early too
+        await asyncio.wait([asyncio.ensure_future(asyncio.sleep(0.2)), started], return_when=asyncio.FIRST_COMPLETED)
+        if self._thread is not None and not self._thread.is_alive():
+            raise RuntimeError("the embedded bridge exited during startup; check the log")
+
+    async def stop(self) -> None:
+        if self._server is not None:
+            self._server.stop()
+        if self._thread is not None:
+            await asyncio.get_running_loop().run_in_executor(None, self._thread.join, 10)
+            self._thread = None