ha-mcp-dev 7.12.3.dev1894__tar.gz → 7.12.3.dev1898__tar.gz

{ha_mcp_dev-7.12.3.dev1894/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.12.3.dev1898}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.12.3.dev1894"
+version = "7.12.3.dev1898"
 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
@@ -176,9 +176,7 @@ ignore = [
 "packaging/mcpb/generate_manifest.py" = ["C901"]
 "scripts/extract_tools.py" = ["C901"]
 "src/ha_mcp/backup_manager.py" = ["C901"]
-"src/ha_mcp/client/rest_client.py" = ["C901"]
 "src/ha_mcp/config.py" = ["C901"]
-"src/ha_mcp/policy/evaluator.py" = ["C901"]
 "src/ha_mcp/policy/handlers.py" = ["C901"]
 "src/ha_mcp/server.py" = ["C901"]
 "src/ha_mcp/settings_ui/__init__.py" = ["C901"]
@@ -188,7 +186,6 @@ ignore = [
 "src/ha_mcp/tools/radio/zigbee.py" = ["C901"]
 "src/ha_mcp/tools/radio/zwave.py" = ["C901"]
 "src/ha_mcp/tools/reference_validator.py" = ["C901"]
-"src/ha_mcp/tools/tools_addons.py" = ["C901"]
 "src/ha_mcp/tools/tools_areas.py" = ["C901"]
 "src/ha_mcp/tools/tools_code.py" = ["C901"]
 "src/ha_mcp/tools/tools_config_automations.py" = ["C901"]
@@ -196,18 +193,13 @@ ignore = [
 "src/ha_mcp/tools/tools_config_scripts.py" = ["C901"]
 "src/ha_mcp/tools/tools_dev.py" = ["C901"]
 "src/ha_mcp/tools/tools_energy.py" = ["C901"]
-"src/ha_mcp/tools/tools_hacs.py" = ["C901"]
 "src/ha_mcp/tools/tools_history.py" = ["C901"]
 "src/ha_mcp/tools/tools_integrations.py" = ["C901"]
 "src/ha_mcp/tools/tools_system.py" = ["C901"]
-"src/ha_mcp/tools/tools_traces.py" = ["C901"]
-"src/ha_mcp/tools/tools_updates.py" = ["C901"]
 "src/ha_mcp/tools/tools_yaml_config.py" = ["C901"]
 "src/ha_mcp/tools/tools_zones.py" = ["C901"]
 "src/ha_mcp/transforms/categorized_search.py" = ["C901"]
-"src/ha_mcp/utils/data_paths.py" = ["C901"]
 "src/ha_mcp/utils/fuzzy_search.py" = ["C901"]
-"src/ha_mcp/utils/skill_loader.py" = ["C901"]
 "src/ha_mcp/visibility/resolver.py" = ["C901"]
 "tests/src/e2e/conftest.py" = ["C901"]
 "tests/src/e2e/error_handling/test_network_errors.py" = ["C901"]

{ha_mcp_dev-7.12.3.dev1894 → ha_mcp_dev-7.12.3.dev1898}/src/ha_mcp/client/rest_client.py

@@ -191,6 +191,25 @@ class HomeAssistantClient:
         await self.httpx_client.aclose()
         logger.debug("Closed Home Assistant client")
 
+    @staticmethod
+    def _error_message_from_response(
+        response: httpx.Response,
+    ) -> tuple[str, dict[str, Any]]:
+        """Build a human message and structured error data from a 4xx/5xx body.
+
+        Prefers the JSON ``message`` field; falls back to reason phrase or a
+        placeholder when the body is empty or unparseable.
+        """
+        try:
+            error_data = response.json()
+        except Exception:
+            error_data = {"message": response.text}
+
+        message = error_data.get("message")
+        if not message or not message.strip():
+            message = response.reason_phrase or "<empty body>"
+        return message, error_data
+
     async def _raw_request(
         self, method: str, endpoint: str, **kwargs: Any
     ) -> httpx.Response:
@@ -216,14 +235,7 @@ class HomeAssistantClient:
                     raise HomeAssistantAuthError("Invalid authentication token")
 
                 if response.status_code >= 400:
-                    try:
-                        error_data = response.json()
-                    except Exception:
-                        error_data = {"message": response.text}
-
-                    message = error_data.get("message")
-                    if not message or not message.strip():
-                        message = response.reason_phrase or "<empty body>"
+                    message, error_data = self._error_message_from_response(response)
 
                     if (
                         response.status_code in _RETRYABLE_STATUS
@@ -665,6 +677,28 @@ class HomeAssistantClient:
         )
         return response.text
 
+    @staticmethod
+    def _supervisor_error_message(text_body: str, reason_phrase: str) -> str:
+        """Extract a human message from a Supervisor 4xx/5xx body.
+
+        Supervisor returns ``{"result":"error","message":"..."}`` on some paths;
+        prefer that message, then fall back to the raw text, reason phrase, or a
+        placeholder.
+        """
+        message = ""
+        try:
+            envelope = json.loads(text_body) if text_body else None
+            if isinstance(envelope, dict):
+                msg = envelope.get("message")
+                if isinstance(msg, str) and msg:
+                    message = msg
+        except json.JSONDecodeError:
+            # Body wasn't a JSON envelope; fall back to raw text below.
+            pass
+        if not message:
+            message = text_body.strip() or reason_phrase or "<empty body>"
+        return message
+
     async def _supervisor_logs_get(self, path: str, lines: int | None = None) -> str:
         """Fetch ``text/plain`` logs from a Supervisor REST endpoint.
 
@@ -751,22 +785,7 @@ class HomeAssistantClient:
             )
         if response.status_code >= 400:
             text_body = response.text
-            # Supervisor returns {"result":"error","message":"..."} JSON on
-            # some 4xx paths. Try parsing that first so the user sees the
-            # human message instead of a JSON blob; then fall back to the
-            # text body, then reason_phrase, then a placeholder.
-            message = ""
-            try:
-                envelope = json.loads(text_body) if text_body else None
-                if isinstance(envelope, dict):
-                    msg = envelope.get("message")
-                    if isinstance(msg, str) and msg:
-                        message = msg
-            except json.JSONDecodeError:
-                # Body wasn't a JSON envelope; fall back to raw text below.
-                pass
-            if not message:
-                message = text_body.strip() or response.reason_phrase or "<empty body>"
+            message = self._supervisor_error_message(text_body, response.reason_phrase)
             logger.warning(
                 "Supervisor returned %s for /%s/logs: %s",
                 response.status_code,

{ha_mcp_dev-7.12.3.dev1894 → ha_mcp_dev-7.12.3.dev1898}/src/ha_mcp/policy/evaluator.py

@@ -56,6 +56,33 @@ def _ci(x: Any) -> Any:
     return x.lower() if isinstance(x, str) else x
 
 
+def _contains_matches(val: Any, pv: Any) -> bool:
+    if isinstance(val, str) and isinstance(pv, str):
+        return pv.lower() in val.lower()
+    # Mirror the case-insensitive treatment that ``eq`` / ``in`` /
+    # ``not_in`` already apply: a rule listing ``["light.kitchen"]``
+    # must match an LLM passing ``"Light.Kitchen"``. Per-element
+    # ``_ci`` guards non-string entries so mixed-type collections
+    # (e.g. ``[1, "two"]``) keep their natural equality semantics.
+    return isinstance(val, (list, tuple, set)) and any(_ci(pv) == _ci(x) for x in val)
+
+
+def _numeric_matches(val: Any, op: str, pv: Any) -> bool:
+    try:
+        return bool(val > pv) if op == "gt" else bool(val < pv)
+    except TypeError:
+        # Numeric rule against a non-numeric arg value — log so
+        # users can tell their "temperature > 30" rule isn't
+        # silently never firing because the arg is a string.
+        logger.debug(
+            "policy: %s type-mismatch (val=%r pv=%r) — predicate skipped",
+            op,
+            val,
+            pv,
+        )
+        return False
+
+
 def _op_matches(val: Any, op: str, pv: Any) -> bool:
     """Apply one op to one concrete value. Predicate dispatches over
     the candidate values (which may be many for wildcard paths).
@@ -82,39 +109,9 @@ def _op_matches(val: Any, op: str, pv: Any) -> bool:
                 and re.search(pv, val, re.IGNORECASE) is not None
             )
         case "contains":
-            if isinstance(val, str) and isinstance(pv, str):
-                return pv.lower() in val.lower()
-            # Mirror the case-insensitive treatment that ``eq`` / ``in`` /
-            # ``not_in`` already apply: a rule listing ``["light.kitchen"]``
-            # must match an LLM passing ``"Light.Kitchen"``. Per-element
-            # ``_ci`` guards non-string entries so mixed-type collections
-            # (e.g. ``[1, "two"]``) keep their natural equality semantics.
-            return isinstance(val, (list, tuple, set)) and any(
-                _ci(pv) == _ci(x) for x in val
-            )
-        case "gt":
-            try:
-                return bool(val > pv)
-            except TypeError:
-                # Numeric rule against a non-numeric arg value — log so
-                # users can tell their "temperature > 30" rule isn't
-                # silently never firing because the arg is a string.
-                logger.debug(
-                    "policy: gt type-mismatch (val=%r pv=%r) — predicate skipped",
-                    val,
-                    pv,
-                )
-                return False
-        case "lt":
-            try:
-                return bool(val < pv)
-            except TypeError:
-                logger.debug(
-                    "policy: lt type-mismatch (val=%r pv=%r) — predicate skipped",
-                    val,
-                    pv,
-                )
-                return False
+            return _contains_matches(val, pv)
+        case "gt" | "lt":
+            return _numeric_matches(val, op, pv)
     return False
 
 

{ha_mcp_dev-7.12.3.dev1894 → ha_mcp_dev-7.12.3.dev1898}/src/ha_mcp/tools/tools_addons.py

@@ -2273,6 +2273,151 @@ class AddOnTools:
             )
         return await self._execute_repository_action(action, repository.strip())
 
+    @staticmethod
+    def _reject_action_mode_conflicts(
+        action: str,
+        path: str | None,
+        config_data: dict[str, Any],
+        array_patch: dict[str, Any] | None,
+    ) -> None:
+        """Raise if lifecycle-action mode is combined with another mode's params."""
+        conflicts = []
+        if path is not None:
+            conflicts.append("path")
+        if config_data:
+            conflicts.append("config parameters")
+        if array_patch is not None:
+            conflicts.append("array_patch")
+        if conflicts:
+            raise_tool_error(
+                create_validation_error(
+                    f"action='{action}' (lifecycle mode) cannot be combined "
+                    f"with {', '.join(conflicts)}. Use one mode at a time.",
+                    parameter="action",
+                )
+            )
+
+    def _reject_config_mode_proxy_params(
+        self,
+        *,
+        method: str,
+        body: dict[str, Any] | str | None,
+        debug: bool,
+        port: int | None,
+        offset: int,
+        limit: int | None,
+        websocket: bool,
+        wait_for_close: bool,
+        message_limit: int | None,
+        message_offset: int,
+        summarize: bool,
+        python_transform: str | None,
+        array_patch: dict[str, Any] | None,
+        request_headers: dict[str, str] | None,
+    ) -> None:
+        """Raise if any proxy-mode-only param is set while config mode is active."""
+        proxy_overrides = self._proxy_overrides_basic(
+            method, body, debug, port, offset, limit, websocket
+        ) + self._proxy_overrides_ws_and_extra(
+            wait_for_close,
+            message_limit,
+            message_offset,
+            summarize,
+            python_transform,
+            array_patch,
+            request_headers,
+        )
+        if proxy_overrides:
+            raise_tool_error(
+                create_validation_error(
+                    f"Proxy-mode parameters cannot be used in config mode: {', '.join(d for _, d in proxy_overrides)}. "
+                    "Remove these parameters or switch to proxy mode by providing 'path'.",
+                    parameter=proxy_overrides[0][0],
+                )
+            )
+
+    async def _execute_ws_proxy(
+        self,
+        slug: str,
+        path: str,
+        body: dict[str, Any] | str | None,
+        debug: bool,
+        port: int | None,
+        wait_for_close: bool,
+        message_limit: int | None,
+        message_offset: int,
+        summarize: bool,
+        python_transform: str | None,
+    ) -> dict[str, Any]:
+        result = await _call_addon_ws(
+            client=self._client,
+            slug=slug,
+            path=path,
+            body=body,
+            timeout=120 if wait_for_close else 10,
+            debug=debug,
+            port=port,
+            wait_for_close=wait_for_close,
+            message_limit=message_limit,
+            message_offset=message_offset,
+            summarize=summarize,
+            python_transform=python_transform,
+        )
+        if not result.get("success"):
+            raise_tool_error(result)
+        return result
+
+    async def _execute_http_proxy(
+        self,
+        *,
+        slug: str,
+        path: str,
+        method: str,
+        body: dict[str, Any] | str | None,
+        debug: bool,
+        port: int | None,
+        offset: int,
+        limit: int | None,
+        python_transform: str | None,
+        request_headers: dict[str, str] | None,
+        message_limit: int | None,
+        message_offset: int,
+        summarize: bool,
+    ) -> dict[str, Any]:
+        valid_methods = {"GET", "POST", "PUT", "DELETE", "PATCH"}
+        if method.upper() not in valid_methods:
+            raise_tool_error(
+                create_validation_error(
+                    f"Invalid HTTP method: {method}. Must be one of: {', '.join(sorted(valid_methods))}",
+                    parameter="method",
+                )
+            )
+        if message_limit is not None or message_offset != 0 or not summarize:
+            raise_tool_error(
+                create_validation_error(
+                    "message_limit / message_offset / summarize apply only to "
+                    "WebSocket mode. Set websocket=True or remove them.",
+                    parameter="message_limit",
+                )
+            )
+
+        result = await _call_addon_api(
+            client=self._client,
+            slug=slug,
+            path=path,
+            method=method,
+            body=body,
+            debug=debug,
+            port=port,
+            offset=offset,
+            limit=limit,
+            python_transform=python_transform,
+            extra_headers=request_headers,
+        )
+        if not result.get("success"):
+            raise_tool_error(result)
+        return result
+
     async def manage_addon(
         self,
         slug: str,
@@ -2326,45 +2471,28 @@ class AddOnTools:
         # Lifecycle mode takes precedence and is mutually exclusive with the
         # proxy / config / array-patch modes.
         if action is not None:
-            conflicts = []
-            if path is not None:
-                conflicts.append("path")
-            if config_data:
-                conflicts.append("config parameters")
-            if array_patch is not None:
-                conflicts.append("array_patch")
-            if conflicts:
-                raise_tool_error(
-                    create_validation_error(
-                        f"action='{action}' (lifecycle mode) cannot be combined "
-                        f"with {', '.join(conflicts)}. Use one mode at a time.",
-                        parameter="action",
-                    )
-                )
+            self._reject_action_mode_conflicts(action, path, config_data, array_patch)
             return await self._execute_action_mode(slug, action)
 
         self._validate_manage_mode(path, config_data)
 
         if config_data:
-            proxy_overrides = self._proxy_overrides_basic(
-                method, body, debug, port, offset, limit, websocket
-            ) + self._proxy_overrides_ws_and_extra(
-                wait_for_close,
-                message_limit,
-                message_offset,
-                summarize,
-                python_transform,
-                array_patch,
-                request_headers,
+            self._reject_config_mode_proxy_params(
+                method=method,
+                body=body,
+                debug=debug,
+                port=port,
+                offset=offset,
+                limit=limit,
+                websocket=websocket,
+                wait_for_close=wait_for_close,
+                message_limit=message_limit,
+                message_offset=message_offset,
+                summarize=summarize,
+                python_transform=python_transform,
+                array_patch=array_patch,
+                request_headers=request_headers,
             )
-            if proxy_overrides:
-                raise_tool_error(
-                    create_validation_error(
-                        f"Proxy-mode parameters cannot be used in config mode: {', '.join(d for _, d in proxy_overrides)}. "
-                        "Remove these parameters or switch to proxy mode by providing 'path'.",
-                        parameter=proxy_overrides[0][0],
-                    )
-                )
             return await self._execute_config_mode(slug, config_data)
 
         # _call_addon_ws does not accept caller headers — reject the combo rather
@@ -2399,43 +2527,20 @@ class AddOnTools:
             )
 
         if websocket:
-            result = await _call_addon_ws(
-                client=self._client,
-                slug=slug,
-                path=path,
-                body=body,
-                timeout=120 if wait_for_close else 10,
-                debug=debug,
-                port=port,
-                wait_for_close=wait_for_close,
-                message_limit=message_limit,
-                message_offset=message_offset,
-                summarize=summarize,
-                python_transform=python_transform,
-            )
-            if not result.get("success"):
-                raise_tool_error(result)
-            return result
-
-        valid_methods = {"GET", "POST", "PUT", "DELETE", "PATCH"}
-        if method.upper() not in valid_methods:
-            raise_tool_error(
-                create_validation_error(
-                    f"Invalid HTTP method: {method}. Must be one of: {', '.join(sorted(valid_methods))}",
-                    parameter="method",
-                )
-            )
-        if message_limit is not None or message_offset != 0 or not summarize:
-            raise_tool_error(
-                create_validation_error(
-                    "message_limit / message_offset / summarize apply only to "
-                    "WebSocket mode. Set websocket=True or remove them.",
-                    parameter="message_limit",
-                )
+            return await self._execute_ws_proxy(
+                slug,
+                path,
+                body,
+                debug,
+                port,
+                wait_for_close,
+                message_limit,
+                message_offset,
+                summarize,
+                python_transform,
             )
 
-        result = await _call_addon_api(
-            client=self._client,
+        return await self._execute_http_proxy(
             slug=slug,
             path=path,
             method=method,
@@ -2445,11 +2550,11 @@ class AddOnTools:
             offset=offset,
             limit=limit,
             python_transform=python_transform,
-            extra_headers=request_headers,
+            request_headers=request_headers,
+            message_limit=message_limit,
+            message_offset=message_offset,
+            summarize=summarize,
         )
-        if not result.get("success"):
-            raise_tool_error(result)
-        return result
 
 
 def register_addon_tools(mcp: Any, client: HomeAssistantClient, **kwargs: Any) -> None:

{ha_mcp_dev-7.12.3.dev1894 → ha_mcp_dev-7.12.3.dev1898}/src/ha_mcp/tools/tools_dev.py

@@ -44,8 +44,25 @@ COMPONENT_DOMAIN = "ha_mcp_tools"
 # (custom_components/ha_mcp_tools/const.py OPT_CHANNEL / OPT_PIP_SPEC).
 _OPT_CHANNEL = "channel"
 _OPT_PIP_SPEC = "pip_spec"
+_OPT_SERVER_URL = "server_url"
+_OPT_EXTERNAL_URL = "external_url"
+_OPT_WEBHOOK_ID_OVERRIDE = "webhook_id_override"
+_OPT_SECRET_PATH_OVERRIDE = "secret_path_override"
 _VALID_CHANNELS = ("stable", "dev")
 
+# Optional text fields the component's options flow pre-fills via
+# suggested_value (so the UI can clear them). Because an OMITTED optional field
+# reads as "cleared" rather than "unchanged", a partial update_source submit
+# must resend these at their current values or it would blank the user's
+# server-URL / connect-secret overrides.
+_PRESERVED_OPTION_KEYS = (
+    _OPT_PIP_SPEC,
+    _OPT_SERVER_URL,
+    _OPT_EXTERNAL_URL,
+    _OPT_WEBHOOK_ID_OVERRIDE,
+    _OPT_SECRET_PATH_OVERRIDE,
+)
+
 # Delay before a self-affecting action (embedded entry reload / options
 # submit) fires, so this tool's JSON response flushes to the MCP client
 # before the serving thread is torn down. Mirrors
@@ -85,6 +102,23 @@ def _spawn_background(coro: Any) -> None:
     task.add_done_callback(_BACKGROUND_TASKS.discard)
 
 
+def _field_prefill(item: dict[str, Any]) -> Any:
+    """Return a serialized options-flow field's current value.
+
+    Reads ``description.suggested_value`` first: a persisted option is
+    serialized there (as ``add_suggested_values_to_schema`` does; this component
+    sets it directly on the ``vol.Optional`` marker), and the clearable text
+    fields carry their value there rather than as a schema ``default`` (a
+    ``default`` equal to the value would make the field impossible to clear).
+    Falls back to ``default`` then ``value`` for the dropdown/toggle fields.
+    Mirrors ``tools_integrations.options_from_form_flow``.
+    """
+    description = item.get("description")
+    if isinstance(description, dict) and description.get("suggested_value") is not None:
+        return description["suggested_value"]
+    return item.get("default", item.get("value"))
+
+
 async def find_server_config_entry(
     client: Any,
 ) -> tuple[str, dict[str, Any], dict[str, Any]] | None:
@@ -95,8 +129,9 @@ async def find_server_config_entry(
     (services) entry's flow aborts immediately. Returns
     ``(entry_id, open_flow, current_options)`` with the options flow left
     OPEN (callers must submit or abort it), or ``None`` when no server
-    entry exists. ``current_options`` maps schema field names to their
-    defaults — i.e. the entry's current option values.
+    entry exists. ``current_options`` maps schema field names to their current
+    values (persisted ``suggested_value`` first, else the schema ``default`` or
+    ``value``, via ``_field_prefill``).
 
     Module-level (not a DevTools method) so the settings UI's embedded
     restart handler can share it.
@@ -131,7 +166,7 @@ async def find_server_config_entry(
             continue
         schema = flow.get("data_schema") or []
         fields: dict[str, Any] = {
-            str(item["name"]): item.get("default")
+            str(item["name"]): _field_prefill(item)
             for item in schema
             if isinstance(item, dict) and item.get("name")
         }
@@ -400,7 +435,16 @@ class DevTools:
         await asyncio.sleep(_SELF_ACTION_FLUSH_DELAY_S)
         try:
             result = await self._client.submit_options_flow_step(flow_id, user_input)
-            logger.info("Deferred options submit result: %s", result.get("type"))
+            if result.get("type") == "create_entry":
+                logger.info("Deferred options submit applied")
+            else:
+                # Fire-and-forget: no caller is left to raise to, so a rejected
+                # self-restart must at least be discoverable in the log.
+                logger.warning(
+                    "Deferred options submit was not applied (type=%s, errors=%s)",
+                    result.get("type"),
+                    result.get("errors") or result.get("reason"),
+                )
         except Exception:
             logger.exception("Deferred options-flow submit failed")
 
@@ -819,7 +863,12 @@ class DevTools:
                 )
             )
         entry_id, flow, current = found
-        user_input: dict[str, Any] = {}
+        # Resend the user's current overrides (see _PRESERVED_OPTION_KEYS) so a
+        # channel/pip-spec change here does not blank them — an omitted optional
+        # field reads as "cleared", not "unchanged".
+        user_input: dict[str, Any] = {
+            key: current[key] for key in _PRESERVED_OPTION_KEYS if current.get(key)
+        }
         if channel is not None:
             user_input[_OPT_CHANNEL] = channel
         if pip_spec is not None: