ha-mcp-dev 7.5.0.dev554__tar.gz → 7.5.0.dev556__tar.gz

{ha_mcp_dev-7.5.0.dev554/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.5.0.dev556}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.5.0.dev554
+Version: 7.5.0.dev556
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT

{ha_mcp_dev-7.5.0.dev554 → ha_mcp_dev-7.5.0.dev556}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.5.0.dev554"
+version = "7.5.0.dev556"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{ha_mcp_dev-7.5.0.dev554 → ha_mcp_dev-7.5.0.dev556}/src/ha_mcp/client/websocket_client.py

@@ -584,24 +584,68 @@ class HomeAssistantWebSocketClient:
     async def subscribe_events(self, event_type: str | None = None) -> int:
         """Subscribe to Home Assistant events.
 
+        HA's WebSocket API identifies a subscription by the ``id`` of the
+        original ``subscribe_events`` command — not by a field inside the
+        ``result`` payload. ``handle_subscribe_events`` in HA Core
+        (``websocket_api/commands.py``) ends with
+        ``connection.send_result(msg["id"])``, and ``send_result(msg_id)``
+        emits ``{"id": N, "type": "result", "success": true, "result": null}``.
+        Subsequent event deliveries arrive as
+        ``{"id": N, "type": "event", "event": {...}}`` with the same ``id``.
+
+        The previous implementation called ``send_command`` (which discards
+        the message_id it generated) and then looked for
+        ``response["result"]["subscription"]``, a field HA does not send.
+        That branch never matched, so this function always raised
+        ``"Failed to get subscription ID"`` — even though the underlying
+        subscription on HA's side WAS established. The ``WebSocketListenerService``
+        treated the raised exception as a startup failure and left
+        ``_listener_started = False``, so every device-control call
+        repeatedly retried (and re-failed) and ``OperationManager.process_state_change``
+        was never invoked, leaving every async operation in PENDING until
+        ``OperationManager.get_operation`` flipped it to TIMEOUT after
+        the 10s ``timeout_ms`` budget. Surfaced during PR #1375 HAOS log
+        audit (3x "Failed to get subscription ID" per bulk-control test).
+
         Args:
             event_type: Specific event type to subscribe to (None for all)
 
         Returns:
-            Subscription ID
+            Subscription ID (the message_id used when subscribing)
         """
-        kwargs = {}
+        if not self._state.is_ready:
+            raise HomeAssistantConnectionError("WebSocket not authenticated")
+
+        message_id = self.get_next_message_id()
+        message: dict[str, Any] = {"id": message_id, "type": "subscribe_events"}
         if event_type:
-            kwargs["event_type"] = event_type
+            message["event_type"] = event_type
+
+        future = self.register_pending_response(message_id)
+        try:
+            await self.send_json_message(message)
+        except Exception:
+            self.cancel_pending_response(message_id)
+            raise
+
+        try:
+            response = await asyncio.wait_for(future, timeout=30.0)
+        except TimeoutError:
+            self.cancel_pending_response(message_id)
+            raise
 
-        response = await self.send_command("subscribe_events", **kwargs)
-        result = response.get("result")
-        if isinstance(result, dict):
-            subscription_id = result.get("subscription")
-            if isinstance(subscription_id, int):
-                return subscription_id
+        if response.get("type") == "result" and response.get("success"):
+            return message_id
 
-        raise Exception("Failed to get subscription ID")
+        error = response.get("error", {})
+        error_msg = (
+            error.get("message", str(error))
+            if isinstance(error, dict)
+            else str(error)
+        )
+        raise HomeAssistantCommandError(
+            f"subscribe_events failed: {error_msg}"
+        )
 
     def add_event_handler(
         self,

{ha_mcp_dev-7.5.0.dev554 → ha_mcp_dev-7.5.0.dev556}/src/ha_mcp/client/websocket_listener.py

@@ -107,19 +107,48 @@ class WebSocketListenerService:
     async def _handle_state_change(self, event: dict[str, Any]) -> None:
         """Handle state change events from Home Assistant.
 
+        HA's WS ``state_changed`` event arrives shaped as::
+
+            {
+                "event_type": "state_changed",
+                "data": {
+                    "entity_id": "light.x",
+                    "new_state": {...},
+                    "old_state": {...}
+                },
+                "time_fired": "...",
+                "origin": "LOCAL",
+                "context": {...}
+            }
+
+        The handler receives the full event object (the WS dispatcher
+        in ``websocket_client._handle_event_message`` passes
+        ``message["event"]``). entity_id / new_state / old_state live
+        under ``event["data"]``, NOT at the top level. Previously this
+        function read from the top level and the guard fired silently
+        on every event — ``update_pending_operations`` was never
+        invoked and async device operations stayed PENDING until they
+        expired. Surfaced during PR #1375 HAOS log audit
+        (TIMEOUT_OPERATION x 3 per bulk-control test).
+
         Args:
-            event: State change event data
+            event: HA state_changed event payload
         """
+        # Initialised here so the narrow ``except`` log at the bottom can
+        # safely reference them even if extraction below hasn't run yet.
+        entity_id: str | None = None
+        new_state: dict[str, Any] | None = None
         try:
             events_processed = self.stats["events_processed"]
             if isinstance(events_processed, int):
                 self.stats["events_processed"] = events_processed + 1
             self.stats["last_event_time"] = datetime.now()
 
-            # Extract event data
-            entity_id = event.get("entity_id")
-            new_state = event.get("new_state")
-            old_state = event.get("old_state")
+            # Extract event data — fields are nested under ``event["data"]``.
+            event_data = event.get("data") or {}
+            entity_id = event_data.get("entity_id")
+            new_state = event_data.get("new_state")
+            old_state = event_data.get("old_state")
 
             if not entity_id or not new_state:
                 return
@@ -138,8 +167,23 @@ class WebSocketListenerService:
                     self.stats["operations_updated"] = operations_updated + len(updated_ops)
                 logger.info(f"Updated {len(updated_ops)} operations for {entity_id}")
 
-        except Exception as e:
-            logger.error(f"Error handling state change event: {e}")
+        except (RuntimeError, ConnectionError, OSError) as e:
+            # Narrow catch: keep the listener alive on transport-level
+            # transients so a single bad event doesn't kill the
+            # subscription, but let code bugs (KeyError, TypeError,
+            # AttributeError) propagate. That discipline is what would
+            # have caught the data-nesting silent failure this PR just
+            # fixed — broad ``except Exception`` is how that bug
+            # survived for months. Use ``logger.exception`` to capture
+            # the traceback and include event context so the next
+            # regression is debuggable.
+            logger.exception(
+                "Transient error handling state_changed event "
+                "(entity_id=%r, event_type=%r): %r",
+                entity_id,
+                event.get("event_type"),
+                e,
+            )
 
     async def _connection_monitor(self) -> None:
         """Monitor WebSocket connection health."""

{ha_mcp_dev-7.5.0.dev554 → ha_mcp_dev-7.5.0.dev556}/src/ha_mcp/settings_ui.py

@@ -874,7 +874,7 @@ def register_settings_routes(
             }
         )
 
-    async def _restart_addon(_: Request) -> JSONResponse:
+    async def _restart_addon(request: Request) -> JSONResponse:
         if not os.environ.get("SUPERVISOR_TOKEN"):
             return JSONResponse(
                 create_error_response(
@@ -884,13 +884,44 @@ def register_settings_routes(
                 ),
                 status_code=400,
             )
-        # Short timeout — the supervisor kills our process during restart so
-        # the connection will drop. A connection drop is actually success.
+        # Optional slug from the request body lets callers restart a sibling
+        # addon instead of self. The UI's restart button posts an empty body
+        # and gets the historical self-restart behavior; the inaddon E2E
+        # suite uses ``slug`` to exercise the Supervisor restart wire
+        # contract against a non-test-critical addon (the dev addon's
+        # session would otherwise drop). The token's hassio_role gates
+        # whether the call actually succeeds for non-self targets.
+        #
+        # The slug is interpolated into the Supervisor endpoint URL, so it
+        # must be tightly constrained — Supervisor addon slugs are
+        # ``[a-z0-9_]+`` per the addon-config schema, but defending against
+        # path-traversal (``..``, ``/``, URL-encoded variants) at the edge
+        # is cheaper than relying on Supervisor to reject every bad shape.
+        # Reject anything outside ``[A-Za-z0-9_-]`` and silently fall back
+        # to ``self`` — same outcome as no body.
+        target_slug = "self"
+        try:
+            payload = await request.json()
+        except (ValueError, json.JSONDecodeError):
+            payload = None
+        if isinstance(payload, dict):
+            requested = payload.get("slug")
+            if (
+                isinstance(requested, str)
+                and requested.strip()
+                and all(c.isalnum() or c in "_-" for c in requested.strip())
+            ):
+                target_slug = requested.strip()
+
+        endpoint = f"/addons/{target_slug}/restart"
+        # Short timeout — when restarting self, the supervisor kills our
+        # process during restart so the connection will drop. A connection
+        # drop is actually success on that path.
         try:
             async with make_supervisor_httpx_client(
                 timeout=5.0, verify=server.settings.verify_ssl
             ) as client:
-                resp = await client.post("/addons/self/restart")
+                resp = await client.post(endpoint)
         except (httpx.ReadError, httpx.RemoteProtocolError):
             # Connection dropped mid-request — restart is happening.
             # `ConnectError` is deliberately NOT in this tuple: it fires
@@ -898,7 +929,7 @@ def register_settings_routes(
             # Supervisor socket misconfigured) and means the restart was
             # never initiated. Falls through to the `httpx.HTTPError`
             # handler below, which returns 502 + CONNECTION_FAILED.
-            logger.info("Restart request connection dropped (expected during restart)")
+            logger.info("Restart request connection dropped (expected during self-restart)")
             return JSONResponse({"success": True, "message": "Restart initiated"})
         except httpx.HTTPError as e:
             logger.exception("Failed to reach Supervisor for restart")
@@ -912,7 +943,12 @@ def register_settings_routes(
 
         if resp.status_code >= 400:
             body = resp.text
-            logger.error("Supervisor restart failed: %d %s", resp.status_code, body)
+            logger.error(
+                "Supervisor restart failed (slug=%s): %d %s",
+                target_slug,
+                resp.status_code,
+                body,
+            )
             return JSONResponse(
                 create_error_response(
                     ErrorCode.INTERNAL_ERROR,

{ha_mcp_dev-7.5.0.dev554 → ha_mcp_dev-7.5.0.dev556}/src/ha_mcp/tools/tools_config_helpers.py

@@ -2811,9 +2811,15 @@ def register_config_helper_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                     # ``result.get("warnings", [])`` uniformly.
                     warnings: list[str] = []
 
-                    # Wait for entity to be properly registered before proceeding
+                    # Wait for entity to be properly registered before proceeding.
+                    # Tags live in their own tag registry and never appear in
+                    # ``/api/states/<entity_id>`` — polling there always 404s
+                    # for the full timeout. The sibling ``helper_type == "tag"``
+                    # branch under the update action below already skips the
+                    # wait for this reason; mirror it here so create doesn't
+                    # burn 10s per tag on every CI run.
                     wait_bool = coerce_bool_param(wait, "wait", default=True)
-                    if wait_bool and entity_id:
+                    if wait_bool and entity_id and helper_type != "tag":
                         try:
                             registered = await wait_for_entity_registered(
                                 client, entity_id

{ha_mcp_dev-7.5.0.dev554 → ha_mcp_dev-7.5.0.dev556/src/ha_mcp_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.5.0.dev554
+Version: 7.5.0.dev556
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Author-email: Julien <github@qc-h.net>
 License: MIT