ha-mcp-dev 7.12.3.dev1928__tar.gz → 7.12.3.dev1929__tar.gz

{ha_mcp_dev-7.12.3.dev1928/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.12.3.dev1929}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.12.3.dev1928
+Version: 7.12.3.dev1929
 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.12.3.dev1928 → ha_mcp_dev-7.12.3.dev1929}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.12.3.dev1928"
+version = "7.12.3.dev1929"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-7.12.3.dev1928 → ha_mcp_dev-7.12.3.dev1929}/src/ha_mcp/policy/evaluator.py

@@ -145,4 +145,22 @@ def find_matching_rule(
 def evaluate(tool_name: str, args: dict[str, Any], policy: Policy) -> Verdict:
     if find_matching_rule(tool_name, args, policy) is not None:
         return Verdict.REQUIRE_APPROVAL
+    # ha_call_service exposes a raw WebSocket escape hatch (``ws_command``) that
+    # carries no ``domain``/``service`` argument, so a rule keyed on
+    # ``args.domain``/``args.service`` cannot match it and it would otherwise slip
+    # through the fail-open default. If the operator has ANY rule that applies to
+    # ha_call_service -- one scoped to it by name, or a wildcard ``*`` rule, which
+    # ``match_rule`` treats as applying to every tool -- treat an unmatched
+    # ws_command call as require-approval (fail safe) so the escape hatch cannot
+    # sneak past that oversight. Blocking the call (require-approval) rather than
+    # silently allowing it is the safe error direction for a raw WS escape hatch,
+    # especially since the write-command blocklist is a deliberately
+    # non-exhaustive wrapper-bypass list that leans on this gate.
+    # Operators who want finer control can add a rule keyed on ``args.ws_command``.
+    if (
+        tool_name == "ha_call_service"
+        and args.get("ws_command")
+        and any(rule.tool_name in ("ha_call_service", "*") for rule in policy.rules)
+    ):
+        return Verdict.REQUIRE_APPROVAL
     return Verdict.ALLOW

{ha_mcp_dev-7.12.3.dev1928 → ha_mcp_dev-7.12.3.dev1929}/src/ha_mcp/tools/tools_code.py

@@ -36,6 +36,7 @@ from fastmcp.server.context import Context
 from ..config import get_global_settings
 from ..errors import ErrorCode, create_error_response
 from .helpers import log_tool_usage, raise_tool_error
+from .util_helpers import BLOCKED_WS_WRITE_COMMANDS
 
 logger = logging.getLogger(__name__)
 
@@ -156,53 +157,6 @@ _BLOCKED_HA_INTERNAL_EVENTS: frozenset[str] = frozenset(
     }
 )
 
-# WebSocket commands the sandbox must not send. Each one either changes
-# persistent state in a way that bypasses a wrapping tool's validation
-# (lovelace, registry mutations) or has no sandbox-appropriate use case
-# at all (``config/core/update`` rewrites the HA installation's location/
-# timezone/currency/lat-long).
-_BLOCKED_WS_COMMANDS: frozenset[str] = frozenset(
-    {
-        "config/core/update",
-        "lovelace/config/save",
-        "lovelace/dashboards/create",
-        "lovelace/dashboards/delete",
-        "lovelace/dashboards/update",
-        "config/area_registry/delete",
-        "config/area_registry/disable",
-        "config/area_registry/update",
-        "config/device_registry/delete",
-        "config/device_registry/disable",
-        "config/device_registry/update",
-        # Device registry deletion is registered as ``remove_config_entry`` on
-        # HA Core, not ``delete`` — see ``tools_registry.py:753`` for the
-        # actually-emitted command. ``ha_remove_device`` wraps it; raw
-        # ``ws_send`` would skip those checks.
-        "config/device_registry/remove_config_entry",
-        "config/entity_registry/delete",
-        "config/entity_registry/disable",
-        "config/entity_registry/update",
-        # Entity registry deletion is registered as ``remove`` on HA Core,
-        # not ``delete`` — see ``tools_entities.py:1130`` for the
-        # actually-emitted command. ``ha_remove_entity`` wraps it.
-        "config/entity_registry/remove",
-        # Floor / label / category registries follow the same rationale as
-        # area / device / entity above: each has a wrapping MCP tool
-        # (``ha_set_area_or_floor``, ``ha_config_set_label``,
-        # ``ha_config_set_category``) that performs invariant checks the
-        # raw WS command skips.
-        "config/floor_registry/create",
-        "config/floor_registry/delete",
-        "config/floor_registry/update",
-        "config/label_registry/create",
-        "config/label_registry/delete",
-        "config/label_registry/update",
-        "config/category_registry/create",
-        "config/category_registry/delete",
-        "config/category_registry/update",
-    }
-)
-
 
 def _classify_sandbox_error(exc: Exception) -> tuple[ErrorCode, str, list[str]]:
     """Map a sandbox exception to ``(code, message, suggestions)``.
@@ -859,7 +813,7 @@ class _SandboxBridge:
         code is dynamic and may pass non-dict values; the runtime guard
         below converts that into an error dict.
 
-        Commands listed in ``_BLOCKED_WS_COMMANDS`` are rejected with an
+        Commands listed in ``BLOCKED_WS_WRITE_COMMANDS`` are rejected with an
         explanatory error: those either rewrite persistent state in ways
         that have no sandbox-appropriate use case (``config/core/update``)
         or bypass the validation in their wrapping MCP tool
@@ -876,7 +830,7 @@ class _SandboxBridge:
         msg_type = message.get("type")
         if not isinstance(msg_type, str):
             return {"error": "ws_send(message) requires a 'type' field"}
-        if msg_type in _BLOCKED_WS_COMMANDS:
+        if msg_type in BLOCKED_WS_WRITE_COMMANDS:
             logger.info("sandbox.ws_send.blocked type=%r", msg_type)
             return {
                 "error": (

{ha_mcp_dev-7.12.3.dev1928 → ha_mcp_dev-7.12.3.dev1929}/src/ha_mcp/tools/tools_search.py

@@ -2689,7 +2689,10 @@ class SearchTools:
                 default=False,
                 description=(
                     "Include user-dismissed/ignored repairs (default: False). "
-                    "Matches the HA Repairs UI which hides dismissed items by default."
+                    "Matches the HA Repairs UI which hides dismissed items by default. "
+                    "To dismiss/ignore a repair, call ha_call_service with "
+                    'ws_command="repairs/ignore_issue" and data={"domain": ..., '
+                    '"issue_id": ..., "ignore": true}.'
                 ),
             ),
         ] = False,

{ha_mcp_dev-7.12.3.dev1928 → ha_mcp_dev-7.12.3.dev1929}/src/ha_mcp/tools/tools_service.py

@@ -15,6 +15,8 @@ from pydantic import Field
 
 from ..client.rest_client import HomeAssistantConnectionError
 from ..errors import (
+    ErrorCode,
+    create_error_response,
     create_validation_error,
 )
 from .helpers import (
@@ -24,6 +26,7 @@ from .helpers import (
     register_tool_methods,
 )
 from .util_helpers import (
+    BLOCKED_WS_WRITE_COMMANDS,
     JSON_STRING_COERCION,
     compact_service_result,
     parse_json_param,
@@ -126,6 +129,50 @@ _SERVICE_TO_STATE: dict[str, str] = {
 }
 
 
+# WebSocket commands that stream events or reply in two phases (an initial ack
+# then the real payload as a follow-up event) rather than resolving to a single
+# terminal result. ha_call_service's ws_command escape hatch only supports
+# one-shot request/response commands, so these are rejected: the "subscribe"
+# substring catches subscription commands, and the set names known two-phase /
+# streaming commands whose names don't contain "subscribe". The set is a floor,
+# not an exhaustive list -- HA's WS command naming isn't consistent enough for a
+# name check alone to be fully reliable.
+_WS_COMMAND_EVENT_BLOCKLIST = frozenset(
+    {
+        "render_template",  # event-based; use ha_eval_template instead
+        "system_health/info",  # two-phase (see tools_system._fetch_health_info)
+        "assist_pipeline/run",  # streams pipeline events
+    }
+)
+
+# Substrings that mark a WS command as streaming / subscription-based even when
+# its name isn't in the blocklist above. Such commands ack once and then push
+# follow-up events on the same id; the one-shot send_command path returns the
+# ack and leaks the subscription. "subscribe" covers subscribe_* and */subscribe;
+# "stream" covers history/stream, logbook/event_stream, camera/stream, ...;
+# "start_preview" covers template/start_preview and the config-flow preview family.
+_WS_STREAMING_SUBSTRINGS = ("subscribe", "stream", "start_preview")
+
+# One-shot WS commands that re-enter Home Assistant's service invocation. Routing
+# them through the escape hatch would bypass the service-mode guards (notably the
+# reserved ha_mcp_tools domain block), so they are rejected -- use the
+# domain/service parameters for service calls instead.
+_WS_COMMAND_SERVICE_INVOKERS = frozenset({"call_service", "execute_script"})
+
+# Reserved WebSocket envelope keys the transport owns. Allowing them inside data
+# would let a caller override the validated command type (defeating every check
+# below) or collide with the transport's message id, so they are rejected.
+_WS_RESERVED_ENVELOPE_KEYS = frozenset({"type", "id"})
+
+
+def _is_streaming_ws_command(command_type: str) -> bool:
+    """Return True for subscription / streaming / two-phase WS commands."""
+    lowered = command_type.lower()
+    if lowered in _WS_COMMAND_EVENT_BLOCKLIST:
+        return True
+    return any(sub in lowered for sub in _WS_STREAMING_SUBSTRINGS)
+
+
 def _build_service_suggestions(
     domain: str, service: str, entity_id: str | None
 ) -> list[str]:
@@ -162,6 +209,80 @@ class ServiceTools:
             service_data["entity_id"] = entity_id
         return service_data
 
+    @staticmethod
+    def _validate_service_call_params(
+        domain: str | None, service: str | None
+    ) -> tuple[str, str]:
+        """Validate service-mode params and return the (domain, service) pair.
+
+        Raises a structured ToolError when domain/service are missing (the caller
+        likely wants the ws_command escape hatch) or when the domain targets the
+        reserved ha_mcp_tools namespace.
+        """
+        if not domain or not service:
+            raise_tool_error(
+                create_validation_error(
+                    "domain and service are required for a service call. To send "
+                    "a raw WebSocket command instead, pass ws_command.",
+                    parameter="domain" if not domain else "service",
+                )
+            )
+        # ha_mcp_tools.* services are restricted to the ha-mcp server's dedicated
+        # wrappers (which inject the required caller token). Block ha_call_service
+        # from forwarding to that domain — it would otherwise be a bypass path
+        # around the dedicated tools. HA core's service registry lowercases the
+        # domain on fallback lookup (homeassistant/core.py
+        # ServiceRegistry.async_call), so normalise here to make sure a mixed-case
+        # `HA_MCP_TOOLS` can't slip past this exact-string check and still resolve
+        # downstream.
+        if domain.strip().lower() == "ha_mcp_tools":
+            raise_tool_error(
+                create_validation_error(
+                    (
+                        "ha_call_service cannot invoke services in the "
+                        "'ha_mcp_tools' domain. Use the dedicated MCP tool "
+                        "instead: ha_list_files, ha_read_file, ha_write_file, "
+                        "ha_delete_file, or ha_config_set_yaml."
+                    ),
+                    parameter="domain",
+                )
+            )
+        return domain, service
+
+    @staticmethod
+    def _reject_incompatible_ws_params(
+        entity_id: str | None,
+        return_response: bool,
+        verbose: bool,
+        result_fields: str | list[str] | None,
+        result_attribute_keys: str | list[str] | None,
+    ) -> None:
+        """Reject service-mode-only params when the ws_command escape hatch is used.
+
+        These shape a registered-service call and have no meaning for a raw
+        WebSocket command; silently ignoring them would be a confusing no-op, so
+        (mirroring the domain/service "not both" guard) they must be omitted.
+        """
+        offenders = [
+            name
+            for name, is_set in (
+                ("entity_id", entity_id is not None),
+                ("return_response", return_response),
+                ("verbose", verbose),
+                ("result_fields", result_fields is not None),
+                ("result_attribute_keys", result_attribute_keys is not None),
+            )
+            if is_set
+        ]
+        if offenders:
+            raise_tool_error(
+                create_validation_error(
+                    "These parameters apply only to service calls and must be "
+                    f"omitted when ws_command is set: {', '.join(offenders)}.",
+                    parameter="ws_command",
+                )
+            )
+
     @staticmethod
     def _parse_result_projection_params(
         result_fields: str | list[str] | None,
@@ -372,6 +493,125 @@ class ServiceTools:
             suggestions=suggestions,
         )
 
+    async def _call_ws_command(
+        self,
+        ws_command: str,
+        data: str | dict[str, Any] | None,
+        *,
+        domain: str | None,
+        service: str | None,
+    ) -> dict[str, Any]:
+        """Send a one-shot WebSocket command via ha_call_service's escape hatch.
+
+        Reaches Home Assistant WebSocket commands that are not registered
+        services (e.g. ``repairs/ignore_issue``). Only one-shot
+        request/response commands are supported — streaming / subscription
+        commands are rejected up front.
+        """
+        command_type = ws_command.strip()
+        if domain is not None or service is not None:
+            raise_tool_error(
+                create_validation_error(
+                    "Provide either domain + service (a registered service call) "
+                    "OR ws_command (a raw WebSocket command), not both.",
+                    parameter="ws_command",
+                )
+            )
+        if not command_type:
+            raise_tool_error(
+                create_validation_error(
+                    "ws_command must be a non-empty WebSocket command type, "
+                    "e.g. 'repairs/ignore_issue'.",
+                    parameter="ws_command",
+                )
+            )
+        if _is_streaming_ws_command(command_type):
+            raise_tool_error(
+                create_validation_error(
+                    f"ws_command '{command_type}' is a streaming or two-phase "
+                    "command; ha_call_service only sends one-shot "
+                    "request/response commands. For template rendering use "
+                    "ha_eval_template.",
+                    parameter="ws_command",
+                )
+            )
+        if command_type.lower() in _WS_COMMAND_SERVICE_INVOKERS:
+            raise_tool_error(
+                create_validation_error(
+                    f"ws_command '{command_type}' invokes Home Assistant services "
+                    "and would bypass ha_call_service's safeguards. Use the "
+                    "domain/service parameters for service calls instead.",
+                    parameter="ws_command",
+                )
+            )
+        if command_type.lower().startswith("ha_mcp_tools/"):
+            raise_tool_error(
+                create_validation_error(
+                    "ha_call_service cannot invoke 'ha_mcp_tools/*' WebSocket "
+                    "commands. Use the dedicated ha-mcp tools instead.",
+                    parameter="ws_command",
+                )
+            )
+        if command_type.lower() in BLOCKED_WS_WRITE_COMMANDS:
+            raise_tool_error(
+                create_validation_error(
+                    f"ws_command '{command_type}' mutates persistent state that a "
+                    "dedicated tool guards with backups and conflict checks. Use "
+                    "the corresponding ha-mcp tool (e.g. ha_config_set_dashboard, "
+                    "ha_set_area_or_floor, ha_remove_entity) instead.",
+                    parameter="ws_command",
+                )
+            )
+        command_params = (
+            _parse_json_dict_param(
+                data, type_error_message="ws_command data must be a JSON object"
+            )
+            or {}
+        )
+        reserved = _WS_RESERVED_ENVELOPE_KEYS & command_params.keys()
+        if reserved:
+            raise_tool_error(
+                create_validation_error(
+                    "data must not contain the reserved WebSocket envelope key(s) "
+                    f"{', '.join(sorted(reserved))}; the command type is set by "
+                    "ws_command, and the message id is managed by the transport.",
+                    parameter="data",
+                )
+            )
+        # send_websocket_message catches its own transport errors and always
+        # returns a {"success": ...} dict (never raises), so the failure is
+        # handled by the result-shape check below -- matching the other
+        # send_websocket_message call sites in the codebase.
+        result = await self._client.send_websocket_message(
+            {"type": command_type, **command_params}
+        )
+
+        if not isinstance(result, dict) or not result.get("success", False):
+            error_msg = (
+                result.get("error") if isinstance(result, dict) else None
+            ) or "WebSocket command failed"
+            raise_tool_error(
+                create_error_response(
+                    ErrorCode.SERVICE_CALL_FAILED,
+                    str(error_msg),
+                    context={"ws_command": command_type},
+                    suggestions=[
+                        "Verify the command type and its parameters (e.g. "
+                        + "repairs/ignore_issue needs domain, issue_id, ignore)",
+                        "Confirm the target still exists (a repair must be "
+                        + "present to ignore it)",
+                    ],
+                )
+            )
+
+        return {
+            "success": True,
+            "ws_command": command_type,
+            "parameters": command_params or None,
+            "result": result.get("result"),
+            "message": f"Successfully executed WebSocket command '{command_type}'",
+        }
+
     @tool(
         name="ha_call_service",
         tags={"Service & Device Control"},
@@ -380,8 +620,8 @@ class ServiceTools:
     @log_tool_usage
     async def ha_call_service(
         self,
-        domain: str,
-        service: str,
+        domain: str | None = None,
+        service: str | None = None,
         entity_id: str | None = None,
         data: Annotated[dict[str, Any] | None, JSON_STRING_COERCION] = None,
         return_response: bool = False,
@@ -425,6 +665,21 @@ class ServiceTools:
                 ),
             ),
         ] = None,
+        ws_command: Annotated[
+            str | None,
+            Field(
+                default=None,
+                description=(
+                    "Advanced escape hatch: send a raw one-shot Home Assistant "
+                    "WebSocket command that is NOT a registered service (e.g. "
+                    "'repairs/ignore_issue' to dismiss a Repairs issue). When set, "
+                    "omit domain/service and the other service params; put the "
+                    "command's parameters in data. Streaming/two-phase and "
+                    "service-invoking commands (call_service, execute_script) are "
+                    "rejected."
+                ),
+            ),
+        ] = None,
     ) -> dict[str, Any]:
         """
         Execute Home Assistant services to control entities and trigger automations.
@@ -462,27 +717,40 @@ class ServiceTools:
 
         Common patterns: Use ha_get_state() to check current values before making changes.
         Use ha_search() to find correct entity IDs.
+
+        **WebSocket command escape hatch (advanced):**
+        A few Home Assistant operations are WebSocket-only commands, not
+        registered services — most notably dismissing a Repairs issue. Pass
+        ``ws_command`` (instead of domain/service) to send one, with its
+        parameters in ``data``:
+        ```python
+        # Dismiss a repair (get domain/issue_id from ha_get_overview repairs
+        # or ha_get_system_health include="repairs")
+        ha_call_service(ws_command="repairs/ignore_issue",
+                        data={"domain": "sun", "issue_id": "abc", "ignore": True})
+        ```
+        Only one-shot request/response commands are supported; streaming/two-phase
+        and service-invoking commands are rejected, and the other service
+        parameters (entity_id, return_response, etc.) don't apply.
         """
-        # ha_mcp_tools.* services are restricted to the ha-mcp server's
-        # dedicated wrappers (which inject the required caller token). Block
-        # ha_call_service from forwarding to that domain — it would otherwise
-        # be a bypass path around the dedicated tools.
-        # HA core's service registry lowercases the domain on fallback lookup
-        # (homeassistant/core.py ServiceRegistry.async_call), so normalise
-        # here to make sure a mixed-case `HA_MCP_TOOLS` can't slip past this
-        # exact-string check and still resolve downstream.
-        if isinstance(domain, str) and domain.strip().lower() == "ha_mcp_tools":
-            raise_tool_error(
-                create_validation_error(
-                    (
-                        "ha_call_service cannot invoke services in the "
-                        "'ha_mcp_tools' domain. Use the dedicated MCP tool "
-                        "instead: ha_list_files, ha_read_file, ha_write_file, "
-                        "ha_delete_file, or ha_config_set_yaml."
-                    ),
-                    parameter="domain",
-                )
+        # WebSocket-command escape hatch (issue #1839): reach one-shot WS
+        # commands that aren't registered services (e.g. repairs/ignore_issue).
+        if ws_command is not None:
+            self._reject_incompatible_ws_params(
+                entity_id,
+                return_response,
+                verbose,
+                result_fields,
+                result_attribute_keys,
+            )
+            return await self._call_ws_command(
+                ws_command, data, domain=domain, service=service
             )
+
+        # Service mode requires domain + service (optional at the signature level
+        # only to make room for the ws_command escape hatch) and rejects the
+        # reserved ha_mcp_tools domain.
+        domain, service = self._validate_service_call_params(domain, service)
         try:
             service_data = self._parse_service_data(data, entity_id)
 

{ha_mcp_dev-7.12.3.dev1928 → ha_mcp_dev-7.12.3.dev1929}/src/ha_mcp/tools/tools_system.py

@@ -541,7 +541,7 @@ class SystemTools:
 
         **Parameters:**
         - include: Optional comma-separated list of additional data to include.
-          - "repairs": Repair items from Settings > System > Repairs (active only by default; pass `include_dismissed_repairs=True` for all)
+          - "repairs": Repair items from Settings > System > Repairs (active only by default; pass `include_dismissed_repairs=True` for all). To dismiss/ignore a repair, call `ha_call_service(ws_command="repairs/ignore_issue", data={"domain": <domain>, "issue_id": <issue_id>, "ignore": true})`.
           - "zha_network": ZHA Zigbee devices with radio signal summary (name, LQI, RSSI)
           - "zha_network_full": ZHA Zigbee devices with all device details (can be large on 100+ device networks; prefer "zha_network" for summary)
           - "zwave_network": Z-Wave JS network status and node summary (status, security, routing)

{ha_mcp_dev-7.12.3.dev1928 → ha_mcp_dev-7.12.3.dev1929}/src/ha_mcp/tools/util_helpers.py

@@ -480,6 +480,46 @@ def unwrap_service_response(result: dict[str, Any]) -> dict[str, Any]:
     return sr if isinstance(sr, dict) else result
 
 
+# WebSocket commands that mutate persistent state in a way that bypasses a
+# wrapping MCP tool's validation (auto-backup, config-hash optimistic locking,
+# registry invariant checks), or that have no escape-hatch-appropriate use case
+# (`config/core/update` rewrites the installation's location/timezone/currency/
+# lat-long). Shared by the code sandbox's `ws_send` bridge (tools_code.py) and
+# ha_call_service's `ws_command` escape hatch (tools_service.py) so the two raw
+# WebSocket surfaces stay in lockstep. Registry deletion command names differ on
+# HA Core: device deletion is `remove_config_entry` and entity deletion is
+# `remove` (not `delete`) -- ha_remove_device / ha_remove_entity emit those.
+BLOCKED_WS_WRITE_COMMANDS: frozenset[str] = frozenset(
+    {
+        "config/core/update",
+        "lovelace/config/save",
+        "lovelace/dashboards/create",
+        "lovelace/dashboards/delete",
+        "lovelace/dashboards/update",
+        "config/area_registry/delete",
+        "config/area_registry/disable",
+        "config/area_registry/update",
+        "config/device_registry/delete",
+        "config/device_registry/disable",
+        "config/device_registry/update",
+        "config/device_registry/remove_config_entry",
+        "config/entity_registry/delete",
+        "config/entity_registry/disable",
+        "config/entity_registry/update",
+        "config/entity_registry/remove",
+        "config/floor_registry/create",
+        "config/floor_registry/delete",
+        "config/floor_registry/update",
+        "config/label_registry/create",
+        "config/label_registry/delete",
+        "config/label_registry/update",
+        "config/category_registry/create",
+        "config/category_registry/delete",
+        "config/category_registry/update",
+    }
+)
+
+
 # Fields surfaced from each repair issue. Includes `ignored` / `dismissed_version`
 # so callers can distinguish active vs. user-dismissed repairs when both are
 # returned (e.g., `include_dismissed_repairs=True`).

{ha_mcp_dev-7.12.3.dev1928 → ha_mcp_dev-7.12.3.dev1929/src/ha_mcp_dev.egg-info}/PKG-INFO

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