rustuya-local 0.1.0.dev8__tar.gz → 0.1.0.dev10__tar.gz

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/CHANGELOG.md

@@ -8,6 +8,18 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.1.0.dev10] — 2026-10-18
+
+### Changed
+- Wait for live bridge acknowledgements and the panel's registry refresh instead of sleeping after device commands.
+- Verify embedded bridge startup through a live MQTT config publication, supervise its native async task, and
+  retain ownership when shutdown times out.
+- Wait for producer presence with an event and an explicit timeout instead of repeated short sleeps.
+- Use manager state-change notifications for wizard progress and cloud-fetch completion; remove status polling.
+- Use manager registry readiness instead of patching its private methods; require rustuya-manager 0.2.3.
+- Create session directories with a regular loop instead of a discarded list comprehension.
+- Wait for daemon readiness events in the subprocess test, allowing both startup timeout stages to finish.
+
 ## [0.1.0.dev8] — 2026-10-13
 
 ### Fixed

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: rustuya-local
-Version: 0.1.0.dev8
+Version: 0.1.0.dev10
 Summary: Local Tuya control: rustuya-bridge -> tuya-interpreter -> IL (ildevice). HA-independent core.
 Project-URL: Homepage, https://github.com/3735943886/rustuya-local
 Project-URL: Repository, https://github.com/3735943886/rustuya-local
@@ -14,7 +14,7 @@ Requires-Dist: tuya-interpreter>=0.1.0a2
 Provides-Extra: fullstack
 Requires-Dist: tuyamock; extra == 'fullstack'
 Provides-Extra: manager
-Requires-Dist: rustuya-manager[web]>=0.2.2; extra == 'manager'
+Requires-Dist: rustuya-manager[web]>=0.2.3; extra == 'manager'
 Provides-Extra: test
 Requires-Dist: httpx2; extra == 'test'
 Requires-Dist: ildevice-homeassistant; extra == 'test'

rustuya_local-0.1.0.dev10/custom_components/rustuya/bridge_supervisor.py

@@ -0,0 +1,104 @@
+"""Own the embedded bridge's native async task and verify its MQTT startup signal."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import secrets
+from urllib.parse import urlsplit
+
+_LOGGER = logging.getLogger(__name__)
+START_TIMEOUT = 15.0
+STOP_TIMEOUT = 10.0
+
+
+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._task: asyncio.Future | None = None
+        self._stopping = False
+
+    async def start(self) -> None:
+        import pyrustuyabridge as pb
+
+        from rustuya_local.host.mqtt import MqttTransport
+
+        if self._task is not None:
+            raise RuntimeError("the embedded bridge has already been started")
+        address = urlsplit(self.broker)
+        observer = MqttTransport(address.hostname, address.port or 1883,
+                                 client_id=f"rustuya-startup-{secrets.token_hex(8)}",
+                                 username=self.username, password=self.password,
+                                 tls=address.scheme == "mqtts")
+        ready = asyncio.Event()
+
+        def on_config(message) -> None:
+            # A retained config may belong to an earlier, dead bridge instance.
+            if message.retain or not message.payload:
+                return
+            try:
+                config = json.loads(message.payload)
+            except (ValueError, UnicodeDecodeError):
+                return
+            if isinstance(config, dict) and config:
+                ready.set()
+
+        waiter = None
+        try:
+            async with asyncio.timeout(START_TIMEOUT):
+                await observer.connect()
+                await observer.subscribe(f"{self.root}/bridge/config", on_config)
+                kwargs = {"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)
+                self._stopping = False
+                self._task = asyncio.ensure_future(self._server.start_async())
+                self._task.add_done_callback(self._exited)
+                waiter = asyncio.create_task(ready.wait())
+                await asyncio.wait((waiter, self._task), return_when=asyncio.FIRST_COMPLETED)
+                if self._task.done():
+                    await self._task  # preserve the native startup exception
+                    raise RuntimeError("the embedded bridge exited during startup")
+        except BaseException:
+            await self.stop()
+            raise
+        finally:
+            if waiter is not None:
+                waiter.cancel()
+                await asyncio.gather(waiter, return_exceptions=True)
+            try:
+                await observer.close()
+            except BaseException:
+                # Startup has not returned ownership to the caller yet.
+                await self.stop()
+                raise
+
+    def _exited(self, task: asyncio.Future) -> None:
+        if task.cancelled():
+            return
+        error = task.exception()
+        if not self._stopping:
+            _LOGGER.error("the embedded bridge stopped unexpectedly: %s", error or "server exited")
+
+    async def stop(self) -> None:
+        if self._task is None:
+            return
+        self._stopping = True
+        self._server.stop()
+        # Shield the native task: a timed-out shutdown must retain ownership so
+        # another stop can still wait for cleanup, rather than losing the server.
+        await asyncio.wait_for(asyncio.shield(asyncio.gather(self._task, return_exceptions=True)), STOP_TIMEOUT)
+        self._task = None
+        self._server = None

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/custom_components/rustuya/config_flow.py

@@ -54,8 +54,6 @@ from .const import (
 
 _LOGGER = logging.getLogger(__name__)
 PROBE_TIMEOUT = 5.0      # seconds each for the broker to accept us and the bridge's retained config to arrive
-TICK = 0.1               # seconds between looks at the login's state while its progress shows
-TICKS = 50               # looks before the progress step is redrawn anyway
 
 
 def _qr_schema(qr_url: str) -> vol.Schema:
@@ -164,7 +162,7 @@ class _ManagerSteps:
             return self.async_show_progress_done(next_step_id="cloud_wizard_scan")
         return self.async_show_progress(step_id="cloud_wizard_progress", progress_action="cloud_wizard_working",
                                         description_placeholders={"message": session.message},
-                                        progress_task=self.hass.async_create_task(self._async_wizard_tick()))
+                                        progress_task=self.hass.async_create_task(self._async_wait_wizard_state()))
 
     async def async_step_cloud_wizard_scan(self, user_input: dict[str, Any] | None = None) -> FlowResult:
         """`async_show_progress` only takes plain description text -- no selector, so a QR needs an actual form
@@ -176,18 +174,14 @@ class _ManagerSteps:
         return self.async_show_form(step_id="cloud_wizard_scan",
                                     data_schema=_qr_schema(self._manager.wizard.session.qr_url))
 
-    async def _async_wizard_tick(self) -> None:
-        """`async_show_progress` needs a task to await; the wizard already runs in the background
-        (`WizardManager._run`), so this just waits for its state to change (or a short cap) so the
-        frontend's re-poll of `cloud_wizard_progress` promptly redraws instead of only on its own timer."""
+    async def _async_wait_wizard_state(self) -> None:
+        """Wake HA progress when the manager reports a wizard state change."""
         from rustuya_manager.wizard import WizardState
 
-        session = self._manager.wizard.session
-        start_state = session.state
-        for _ in range(TICKS):
-            if session.state != start_state or session.state in (WizardState.DONE, WizardState.ERROR):
-                return
-            await asyncio.sleep(TICK)
+        wizard = self._manager.wizard
+        state = wizard.session.state
+        if state not in (WizardState.DONE, WizardState.ERROR):
+            await wizard.wait_state_change(state)
 
     def _sync_form(self, step_id: str, diff: Any, error: str | None = None) -> FlowResult:
         self._sync_shown = True

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/custom_components/rustuya/manager_session.py

@@ -68,9 +68,7 @@ async def open_manager(*, broker: str, root: str, devices_path: str, username: s
         # `sync()`'s diff is only meaningful once the bridge's device list has arrived; without this every cloud
         # device looks "missing" (an empty bridge side), which is how a whole device list ended up offered for
         # registration.
-        from .manager_registry import ready_registry
-
-        await ready_registry(manager, WAIT)
+        await manager.wait_ready(bootstrap_timeout=WAIT, bridge_timeout=WAIT)
     except BaseException:
         await close_manager(manager)
         raise
@@ -103,7 +101,12 @@ async def open_for_entry(hass: Any, data: dict[str, Any], *, run_bridge: bool =
         dirs.append(os.path.dirname(state_file))
         bridge = {"bridge_state": state_file,
                   "bridge_log_level": data.get(CONF_BRIDGE_LOG_LEVEL, DEFAULT_BRIDGE_LOG_LEVEL)}
-    await hass.async_add_executor_job(lambda: [os.makedirs(d, exist_ok=True) for d in dirs if d])
+    def ensure_directories() -> None:
+        for directory in dirs:
+            if directory:
+                os.makedirs(directory, exist_ok=True)
+
+    await hass.async_add_executor_job(ensure_directories)
     username, password = broker.credentials(data)
     return await open_manager(broker=broker.url(data), root=data[CONF_BRIDGE_ROOT],
                               devices_path=data[CONF_DEVICES_PATH], username=username, password=password, **bridge)

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/custom_components/rustuya/manifest.json

@@ -11,10 +11,10 @@
   "requirements": [
     "tuya-interpreter>=0.1.0a2",
     "paho-mqtt>=2.0",
-    "rustuya-manager>=0.2.2",
+    "rustuya-manager>=0.2.3",
     "pyrustuyabridge>=0.4",
-    "rustuya-local>=0.1.0.dev8"
+    "rustuya-local>=0.1.0.dev10"
   ],
   "single_config_entry": true,
-  "version": "0.1.0.dev8"
+  "version": "0.1.0.dev10"
 }

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/custom_components/rustuya/panel.py

@@ -392,7 +392,6 @@ class CloudFetch:
 
     IDLE_TIMEOUT = 30.0         # seconds without a poll before the session is closed
     MAX_TIME = 600.0            # a QR not scanned in 10 minutes is given up
-    WATCH_INTERVAL = 0.5        # seconds between looks at the wizard's state
 
     def __init__(self, hass: HomeAssistant, entry: Any) -> None:
         self.hass, self.entry = hass, entry
@@ -435,14 +434,21 @@ class CloudFetch:
 
     async def _watch(self) -> None:
         while self.running and not self._finishing:
-            await asyncio.sleep(self.WATCH_INTERVAL)
             session = self.manager.wizard.session
             state = _wizard_state(session)
-            now = self.hass.loop.time()
             if state in ("done", "error"):
                 await self._finish(_outcome(state, session.message or "", session.error))
-            elif now - self._polled > self.IDLE_TIMEOUT or now - self._started > self.MAX_TIME:
+                return
+            now = self.hass.loop.time()
+            remaining = min(self._polled + self.IDLE_TIMEOUT, self._started + self.MAX_TIME) - now
+            if remaining <= 0:
                 await self._finish(_outcome("cancelled", "Stopped: the page stopped asking, or it took too long"))
+                return
+            try:
+                await asyncio.wait_for(self.manager.wizard.wait_state_change(session.state), remaining)
+            except TimeoutError:
+                # A page poll may have extended the idle deadline while we waited.
+                continue
 
     async def _finish(self, final: dict[str, Any]) -> None:
         from . import async_refresh_devices, manager_session
@@ -457,6 +463,9 @@ class CloudFetch:
         finally:
             # reported only now: the page reloads the bridge list on `done`, which needs the session lock this held
             self.final = final
+            if self._task is not None and self._task is not asyncio.current_task():
+                self._task.cancel()
+                await asyncio.gather(self._task, return_exceptions=True)
 
 
 def _fetch_status(fetch: CloudFetch | None) -> dict[str, Any]:
@@ -554,7 +563,6 @@ class BridgeView(_View):
 
     url = "/api/rustuya/bridge"
     name = "api:rustuya:bridge"
-    SETTLE = 1.5            # seconds for the bridge's replies to land before the list is read again after a POST
 
     @_entry_view
     async def get(self, request: web.Request, entry: Any, runtime: Any) -> web.Response:
@@ -587,13 +595,6 @@ class BridgeView(_View):
             return self.json_message(str(e), HTTPStatus.BAD_REQUEST)
         return await self._session(request, entry, runtime, None, manual=device, editing=True)
 
-    @staticmethod
-    async def _wait_registry_refresh(manager: Any) -> None:
-        # Older manager versions refresh immediately and have no wait method.
-        wait = getattr(manager, "wait_registry_refresh", None)
-        if wait is not None:
-            await wait()
-
     async def _session(self, request: web.Request, entry: Any, runtime: Any,
                        selection: dict[str, list[str]] | None, *, manual: dict[str, str] | None = None,
                        editing: bool = False) -> web.Response:
@@ -622,14 +623,12 @@ class BridgeView(_View):
                 await manager.publish_command("add", target_id=manual["id"], target_name=manual.get("name"),
                                               extra={k: v for k, v in manual.items() if k not in ("id", "name")} or None)
                 sent = 1
-                await asyncio.sleep(self.SETTLE)
-                await self._wait_registry_refresh(manager)
+                await manager.wait_registry_refresh()
                 diff = await manager.sync()
             if selection is not None:
                 sent = await bridge_sync.apply(manager, diff, selection)      # gateways first, as the flows do
                 if sent:
-                    await asyncio.sleep(self.SETTLE)
-                    await self._wait_registry_refresh(manager)
+                    await manager.wait_registry_refresh()
                     diff = await manager.sync()
             state = getattr(manager, "state", None)
             return self.json({"devices": bridge_sync.listing(diff, getattr(state, "bridge", None)), "sent": sent,

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/docs/ARCHITECTURE.md

@@ -74,5 +74,6 @@ requests share a lock covering the current-entry read, patch merge, validation,
 ## Verification and coupling
 
 Unit tests, in-process services, real MQTT brokers, Tuya emulators and HA integration tests verify different
-boundaries. They do not replace real LAN-device tests. Driver state internals and the manager's private registry API
-remain coupling points that need checking when dependencies change. See [REVIEW](REVIEW.md) for fixes and limits.
+boundaries. They do not replace real LAN-device tests. Driver state internals remain a coupling point that needs
+checking when dependencies change. Manager sessions use public registry readiness and wizard state-change APIs;
+HA no longer patches manager internals or polls wizard state. See [REVIEW](REVIEW.md) for fixes and limits.

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/docs/ROADMAP.md

@@ -14,7 +14,8 @@ Completed milestones and earlier deployment records are preserved in the [previo
 
 ## Maintenance
 
-- [ ] Reduce dependence on driver state internals in `Hub._same` and private manager registry APIs through public contracts.
+- [x] Replace private manager registry patches and wizard state polling with public async contracts.
+- [ ] Reduce dependence on driver state internals in `Hub._same` through a public contract.
 - [ ] Verify Python 3.13 with minimum supported dependency versions. The full CI suite uses 3.14; wheel import/CLI smoke tests pass on 3.13.
 - [ ] Define the supported drop-in OS/architectures and provide platform assets as needed. Each archive includes its build host's native library.
 - [ ] Verify ownership/conflict policy when manual file editing, IL settings saves and automatic pack updates overlap.

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/docs/STATUS.md

@@ -1,6 +1,6 @@
 # Current status
 
-Updated: 2026-10-13. Baseline: this repository's `0.1.0.dev8` code.
+Updated: 2026-10-18. Baseline: `0.1.0.dev10`.
 The state of deployed servers has not been checked.
 
 ## Implementation
@@ -12,12 +12,12 @@ rule files and settings persistence. It does not create HA entities or publish M
 
 | Component | Declared requirement |
 |---|---|
-| rustuya-local | `0.1.0.dev8` |
+| rustuya-local | `0.1.0.dev10` |
 | Python | Base package `>=3.13`; full tests use 3.14 |
 | tuya-interpreter | `>=0.1.0a2` |
 | pyrustuyabridge | `>=0.4` |
 | paho-mqtt | `>=2.0` |
-| rustuya-manager | `>=0.2.2` in the manager test extra and HA manifest |
+| rustuya-manager | `>=0.2.3` in the manager test extra and HA manifest |
 
 These are minimum requirements; installed versions may differ.
 

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rustuya-local"
-version = "0.1.0.dev8"
+version = "0.1.0.dev10"
 description = "Local Tuya control: rustuya-bridge -> tuya-interpreter -> IL (ildevice). HA-independent core."
 readme = "README.md"
 requires-python = ">=3.13"
@@ -31,7 +31,7 @@ rustuya-local = "rustuya_local.manager_plugin:register"
 test = ["pytest", "pytest-asyncio", "ildevice-homeassistant", "httpx2"]      # ildevice-homeassistant: the IL consumer; httpx2: Starlette TestClient
 test-ha = ["pytest-homeassistant-custom-component"]   # custom_components/rustuya's own tests
 fullstack = ["tuyamock"]      # the device emulator, for tests/e2e/test_full_stack*.py (pyrustuyabridge is now a base dep)
-manager = ["rustuya-manager[web]>=0.2.2"]      # tests/e2e/test_manager_plugin*.py: the manager's real plugin host, its web app
+manager = ["rustuya-manager[web]>=0.2.3"]      # tests/e2e/test_manager_plugin*.py: the manager's real plugin host, its web app
 
 [tool.hatch.build.targets.wheel]
 packages = ["src/rustuya_local"]

rustuya_local-0.1.0.dev10/release-notes.md

@@ -0,0 +1,9 @@
+### Changed
+- Wait for live bridge acknowledgements and the panel's registry refresh instead of sleeping after device commands.
+- Verify embedded bridge startup through a live MQTT config publication, supervise its native async task, and
+  retain ownership when shutdown times out.
+- Wait for producer presence with an event and an explicit timeout instead of repeated short sleeps.
+- Use manager state-change notifications for wizard progress and cloud-fetch completion; remove status polling.
+- Use manager registry readiness instead of patching its private methods; require rustuya-manager 0.2.3.
+- Create session directories with a regular loop instead of a discarded list comprehension.
+- Wait for daemon readiness events in the subprocess test, allowing both startup timeout stages to finish.

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/src/rustuya_local/bridge_client.py

@@ -168,6 +168,7 @@ class BridgeClient(_BridgeFollower):
         super().__init__(transport, root)
         self.runner: Runner | None = None
         self._pending: set[asyncio.Task] = set()
+        self._command_waiters: dict[tuple[str, str], asyncio.Future] = {}
         # registration tracking (only when `sync_devices` was ever called; otherwise the caller owns the Hub's set)
         self._records: dict[str, dict] | None = None      # every device in the device file, by id
         self._registered: set[str] | None = None          # what the bridge holds; None until its first `status`
@@ -186,6 +187,9 @@ class BridgeClient(_BridgeFollower):
         self._last_state: dict[str, dict] = {}
 
     def stop(self) -> None:
+        for waiter in self._command_waiters.values():
+            if not waiter.done():
+                waiter.set_exception(RuntimeError("bridge client stopped"))
         self._registry_ready.clear()
         if self._status_timer is not None:
             self._status_timer.cancel()
@@ -223,11 +227,30 @@ class BridgeClient(_BridgeFollower):
         return {key: dict(value) for key, value in (self._registry or {}).items()}
 
     async def publish_command(self, action: str, *, target_id: str, target_name: str | None = None,
-                              extra: dict[str, Any] | None = None) -> None:
-        """Send a panel command through the service's established connection."""
-        await asyncio.wait_for(self._ready.wait(), 15.0)
-        await self._publish(action, target_id, {**(extra or {}), **({"name": target_name} if target_name else {})},
-                            strict=True)
+                              extra: dict[str, Any] | None = None, timeout: float = 15.0) -> None:
+        """Send a panel mutation and wait for its live bridge acknowledgement.
+
+        A subsequent status request can otherwise overtake a concurrent mutation.
+        The bridge has no request IDs; reject overlapping commands for the same action/id.
+        """
+        key = (action, target_id)
+        if key in self._command_waiters:
+            raise RuntimeError(f"bridge {action} for {target_id} is already pending")
+        waiter = asyncio.get_running_loop().create_future()
+        self._command_waiters[key] = waiter
+        try:
+            async with asyncio.timeout(timeout):
+                await self._ready.wait()
+                await self._publish(action, target_id,
+                                    {**(extra or {}), **({"name": target_name} if target_name else {})}, strict=True)
+                await waiter
+        finally:
+            self._command_waiters.pop(key, None)
+            # Retrieve a shutdown error even if publishing failed at the same time.
+            if waiter.done() and not waiter.cancelled():
+                waiter.exception()
+            else:
+                waiter.cancel()
 
     async def _publish(self, action: str, device_id: str, extra: dict[str, Any], *, strict: bool = False) -> None:
         if self._templates is None:
@@ -355,6 +378,16 @@ class BridgeClient(_BridgeFollower):
             self._last_conn[device_id] = conn
             self.runner.on_bridge_message(device_id, conn, retained=retained)       # a retained one asks for no `get`
             return
+        if not retained:
+            key = (parsed.get("action"), parsed.get("id") or vars_.get("id"))
+            # Only string identities are valid, including in malformed broker input.
+            if all(isinstance(part, str) for part in key):
+                waiter = self._command_waiters.get(key)
+                if waiter is not None and not waiter.done():
+                    if parsed.get("status") == "ok":
+                        waiter.set_result(None)
+                    elif parsed.get("status") == "error":
+                        waiter.set_exception(RuntimeError(str(parsed.get("error") or "bridge command failed")))
         if self._records is None or retained:                # a retained reply is an old one; `status` is asked live
             return
         if parsed.get("action") == "status":

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/src/rustuya_local/host/runner.py

@@ -44,12 +44,21 @@ async def producer_running(il: Transport, presence: str, timeout: float = 2.0) -
     None: it is `online` but nothing answered: a producer whose Last Will never reached the broker (a power cut that
     took the broker along), or one on tuya2ildevice before 0.3.5, which does not answer."""
     seen: list[str] = []
-    unsub = await il.subscribe(presence, lambda m: seen.append(_text(m.payload)) if m.retain else None)
+    received = asyncio.Event()
+
+    def on_presence(message: Message) -> None:
+        if message.retain:
+            seen.append(_text(message.payload))
+            received.set()
+
+    unsub = await il.subscribe(presence, on_presence)
     try:
-        for _ in range(10):                        # the retained replay, if any
-            if seen:
-                break
-            await asyncio.sleep(0.05)
+        # MQTT has no end-of-retained-replay signal. Bound the wait explicitly;
+        # an arriving presence wakes us immediately instead of waiting for a tick.
+        try:
+            await asyncio.wait_for(received.wait(), timeout)
+        except TimeoutError:
+            return False
     finally:
         unsub()
     if not seen or seen[-1] != "online":

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/tests/e2e/test_bridge_registration.py

@@ -321,10 +321,19 @@ async def test_panel_uses_service_registry_and_transport_without_a_manager_conne
     diff = await panel.sync()
     assert {d.id for d in diff.synced} == {'a', 'sub'}
     assert len(status_requests(bridge)) == asked
-    await panel.publish_command('add', target_id='new', target_name='New', extra={'cid': 'c2', 'parent_id': 'a'})
+    command = asyncio.create_task(panel.publish_command(
+        'add', target_id='new', target_name='New', extra={'cid': 'c2', 'parent_id': 'a'}))
+    await settle(runner, client, bridge, il)
+    await asyncio.sleep(0)
     assert json.loads(bridge.published[-1][1]) == {
         'action': 'add', 'id': 'new', 'name': 'New', 'cid': 'c2', 'parent_id': 'a'}
-    await panel.remove_device('a')
+    assert not command.done()
+    await reply(bridge, json.dumps({'action': 'add', 'id': 'new', 'status': 'ok'}))
+    await command
+    command = asyncio.create_task(panel.remove_device('a'))
+    await asyncio.sleep(0)
+    await reply(bridge, json.dumps({'action': 'remove', 'id': 'a', 'status': 'ok'}))
+    await command
     refresh = asyncio.create_task(panel.wait_registry_refresh())
     await asyncio.sleep(0)
     await settle(runner, client, bridge, il)
@@ -334,3 +343,44 @@ async def test_panel_uses_service_registry_and_transport_without_a_manager_conne
     diff = await panel.sync()
     assert [d.id for d in diff.missing] == ['a']
     assert [d.id for d in diff.orphaned] == ['new']
+
+
+async def test_panel_command_ignores_retained_and_unrelated_acknowledgements(chain):
+    import asyncio
+
+    from rustuya_local.host.transport import Message
+
+    bridge, _il, _runner, client = chain
+    command = asyncio.create_task(client.publish_command('add', target_id='new'))
+    await asyncio.sleep(0)
+    client._on_message(Message('rustuya/response/new', '{"action":"add","id":"new","status":"ok"}', True))
+    await reply(bridge, '{"action":"add","id":"other","status":"ok"}')
+    await reply(bridge, '{"action":"remove","id":"new","status":"ok"}')
+    await asyncio.sleep(0)
+    assert not command.done()
+    await reply(bridge, '{"action":"add","id":"new","status":"ok"}')
+    await command
+    assert not client._command_waiters
+
+
+@pytest.mark.parametrize('outcome', ['timeout', 'cancel', 'stop', 'error'])
+async def test_panel_command_cleans_up_pending_acknowledgement(chain, outcome):
+    import asyncio
+
+    bridge, _il, _runner, client = chain
+    command = asyncio.create_task(client.publish_command('add', target_id='new', timeout=0.02))
+    await asyncio.sleep(0)
+    if outcome == 'cancel':
+        command.cancel()
+        expected = asyncio.CancelledError
+    elif outcome == 'stop':
+        client.stop()
+        expected = RuntimeError
+    elif outcome == 'error':
+        await reply(bridge, '{"action":"add","id":"new","status":"error","error":"rejected"}')
+        expected = RuntimeError
+    else:
+        expected = TimeoutError
+    with pytest.raises(expected):
+        await command
+    assert not client._command_waiters

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/tests/e2e/test_daemon.py

@@ -23,24 +23,29 @@ async def test_the_daemon_publishes_devices_and_goes_offline_on_sigterm(broker,
     cfg.write_text(json.dumps({"bridge": {"port": broker}, "il": {"port": broker, "prefix": "ild"},
                                "devices": [lamp("daemon1")]}))
     seen = {}
+    online, offline = asyncio.Event(), asyncio.Event()
+
+    def on_message(message):
+        seen[message.topic] = message.payload.decode()
+        if seen.get("ild/_producer/tuya") == "online" and "ild/daemon1" in seen:
+            online.set()
+        if seen.get("ild/_producer/tuya") == "offline":
+            offline.set()
+
     watcher = MqttTransport("127.0.0.1", broker, client_id="watcher")
     await watcher.connect()
-    await watcher.subscribe("ild/#", lambda m: seen.__setitem__(m.topic, m.payload.decode()))
+    await watcher.subscribe("ild/#", on_message)
     await answer_status(watcher, "rustuya", ["daemon1"])
     proc = subprocess.Popen([sys.executable, "-m", "rustuya_local", "run", "--config", str(cfg)],  # noqa: ASYNC220  (spawning does not block; the test waits on the broker)
                             stderr=subprocess.DEVNULL)
     try:
-        for _ in range(100):
-            if seen.get("ild/_producer/tuya") == "online" and "ild/daemon1" in seen:
-                break
-            await asyncio.sleep(0.05)
-        assert seen["ild/_producer/tuya"] == "online" and json.loads(seen["ild/daemon1"])["kind"] == "light"
+        # Startup includes the producer-presence deadline and the missing
+        # bridge-config fallback. Wait for readiness, not 100 polling ticks.
+        await asyncio.wait_for(online.wait(), 10)
+        assert json.loads(seen["ild/daemon1"])["kind"] == "light"
         proc.send_signal(signal.SIGTERM)
-        assert proc.wait(10) == 0
-        for _ in range(100):
-            if seen["ild/_producer/tuya"] == "offline":
-                break
-            await asyncio.sleep(0.05)
+        assert await asyncio.to_thread(proc.wait, 10) == 0
+        await asyncio.wait_for(offline.wait(), 10)
         assert seen["ild/_producer/tuya"] == "offline"
     finally:
         if proc.poll() is None:

{rustuya_local-0.1.0.dev8 → rustuya_local-0.1.0.dev10}/tests/ha/fake_manager.py

@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from dataclasses import dataclass, field
 
 
@@ -23,12 +24,11 @@ class Session:
 class FakeWizard:
     """No background task, no wall-clock timing: `session.state` only changes when a test calls `advance()` (or the
     convenience `autoplay`, for a test that just wants a normal login to finish). `async_step_cloud_wizard_progress`
-    polls with a real `asyncio.sleep`-based task (`_async_wait_wizard_tick`), so driving state changes from a task
-    the flow's own machinery can observe — not a task of the fake's own that Home Assistant doesn't track — is what
-    keeps `hass.async_block_till_done()` able to settle deterministically instead of racing it."""
+    waits for `wait_state_change()`, so `advance()` wakes its progress task without a polling timer."""
 
     def __init__(self, script: list[str] | None = None, autoplay: bool = True) -> None:
         self.session = Session()
+        self._changed = asyncio.Event()
         self._script = script or [WizardState.REQUESTING_QR, WizardState.AWAITING_SCAN, WizardState.LOGGED_IN,
                                   WizardState.FETCHING, WizardState.DONE]
         self._i = 0
@@ -40,6 +40,11 @@ class FakeWizard:
         self._advance()
         return self.session
 
+    async def wait_state_change(self, state):
+        while self.session.state == state:
+            await self._changed.wait()
+        return self.session
+
     async def read_saved_user_code(self):
         return None
 
@@ -49,6 +54,8 @@ class FakeWizard:
         self._advance()
 
     def _advance(self) -> None:
+        changed, self._changed = self._changed, asyncio.Event()
+        changed.set()
         self.session.state = self._script[self._i]
         if self.session.state == WizardState.AWAITING_SCAN:
             self.session.qr_url = "tuyaSmart--qrLogin?token=fake"
@@ -108,6 +115,9 @@ class FakeManager:
     async def __aexit__(self, *exc):
         self.closed = True
 
+    async def wait_registry_refresh(self):
+        pass
+
     async def sync(self):
         return self._sync_result