ha-mcp-dev 7.6.0.dev644__tar.gz → 7.6.0.dev645__tar.gz

{ha_mcp_dev-7.6.0.dev644/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.6.0.dev645}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.6.0.dev644"
+version = "7.6.0.dev645"
 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.6.0.dev644 → ha_mcp_dev-7.6.0.dev645}/src/ha_mcp/tools/tools_system.py

@@ -60,51 +60,6 @@ class SystemTools:
     def __init__(self, client: Any) -> None:
         self._client = client
 
-    @tool(
-        name="ha_check_config",
-        tags={"System"},
-        annotations={
-            "idempotentHint": True,
-            "readOnlyHint": True,
-            "title": "Check Configuration",
-        },
-    )
-    @log_tool_usage
-    async def ha_check_config(self) -> dict[str, Any]:
-        """
-        Check Home Assistant configuration for errors.
-
-        Validates configuration files without applying changes.
-        Always run this before ha_restart() to ensure configuration is valid.
-        """
-        try:
-            config_result = await self._client.check_config()
-
-            # The API returns {"result": "valid"} or {"result": "invalid", "errors": [...]}
-            is_valid = config_result.get("result") == "valid"
-            errors = config_result.get("errors") or []  # Handle None case
-
-            return {
-                "success": True,
-                "result": "valid" if is_valid else "invalid",
-                "is_valid": is_valid,
-                "errors": errors,
-                "message": (
-                    "Configuration is valid"
-                    if is_valid
-                    else f"Configuration has {len(errors)} error(s)"
-                ),
-            }
-
-        except Exception as e:
-            exception_to_structured_error(
-                e,
-                suggestions=[
-                    "Ensure Home Assistant is running and accessible",
-                    "Check your connection settings",
-                ],
-            )
-
     @tool(
         name="ha_restart",
         tags={"System"},
@@ -127,15 +82,16 @@ class SystemTools:
                    measure to prevent accidental restarts.
 
         **Best Practices:**
-        1. Always run ha_check_config() first to ensure configuration is valid
+        1. Config is validated automatically before the restart proceeds; to
+           pre-check, call ha_get_system_health(include="config_check")
         2. Notify users before restarting (if applicable)
         3. Schedule restarts during low-activity periods
 
         **Example Usage:**
         ```python
-        # Always check config first
-        config = ha_check_config()
-        if config["result"] == "valid":
+        # Optional pre-check (ha_restart also validates config automatically)
+        health = ha_get_system_health(include="config_check")
+        if health["config_check"]["is_valid"]:
             # Restart with confirmation
             result = ha_restart(confirm=True)
         ```
@@ -153,7 +109,7 @@ class SystemTools:
                         "This is a safety measure to prevent accidental restarts."
                     ),
                     suggestions=[
-                        "Run ha_check_config() first to validate configuration",
+                        'Pre-check config via ha_get_system_health(include="config_check")',
                         "Call ha_restart(confirm=True) to proceed with restart",
                         "Consider using ha_reload_core() for config-only changes",
                     ],
@@ -391,7 +347,10 @@ class SystemTools:
             be large (Hue ~290 KB, ZHA/MQTT/ESPHome several MB) — pair with
             ``diagnostics_fields`` or ``diagnostics_truncate_at_bytes`` to fit the LLM
             context budget.
-          - Example: include="repairs,zha_network,zwave_network"
+          - "config_check": Validate HA configuration via POST /config/core/check_config
+            (the pre-restart safety check; ha_restart runs it automatically). Returns
+            {result: valid|invalid, is_valid, errors}; read-only/idempotent, takes no args.
+          - Example: include="repairs,zha_network,zwave_network,config_check"
           - Example: include="diagnostics", config_entry_id="abc123..."
         - include_dismissed_repairs: Include user-dismissed/ignored repairs (default: False). Only meaningful when "repairs" is in `include`.
         - config_entry_id: Required when ``include`` contains ``diagnostics``. The config
@@ -430,10 +389,47 @@ class SystemTools:
         includes = self._parse_includes(include)
         include_dismissed_repairs_bool = bool(include_dismissed_repairs)
 
+        # Sections that require the system_health WebSocket connection; the
+        # REST-based sections (config_check, diagnostics) do not.
+        ws_backed = {"repairs", "zha_network", "zha_network_full", "zwave_network"}
+
         ws_client = None
 
         try:
-            ws_client, result = await self._fetch_health_info()
+            try:
+                ws_client, result = await self._fetch_health_info()
+            except ToolError as health_err:
+                # The system_health/info baseline (WebSocket) is unavailable.
+                # Only ``await self._fetch_health_info()`` runs in this inner
+                # try, and it raises ToolError solely for baseline-unavailable
+                # conditions (connect failure / timeout / WS error), so this
+                # catch cannot swallow an unrelated ToolError.
+                #
+                # Degrade gracefully ONLY when the caller asked for a REST-based
+                # section (config_check / diagnostics) that can still be served
+                # without the WebSocket. config_check is the pure-REST
+                # replacement for the removed ha_check_config tool, so it must
+                # not depend on the health WebSocket (the system_health/info
+                # command carries its own 10s timeout and can hang/be absent on
+                # some installs). If the caller asked for nothing (the health
+                # baseline itself) or only WS-backed sections, the baseline WAS
+                # the deliverable: re-raise so the failure surfaces as
+                # isError=true, exactly as before this change.
+                if not (includes & {"config_check", "diagnostics"}):
+                    raise
+                logger.warning("system_health baseline unavailable: %s", health_err)
+                ws_client = None
+                result = {
+                    "success": True,
+                    "baseline_available": False,
+                    "health_info": {},
+                    "component_count": 0,
+                    "message": "System health baseline unavailable.",
+                    "warnings": [
+                        "system_health baseline unavailable; "
+                        "returning REST-based sections only."
+                    ],
+                }
 
             # Warn about unrecognized include values
             VALID_INCLUDES = {
@@ -442,6 +438,7 @@ class SystemTools:
                 "zha_network_full",
                 "zwave_network",
                 "diagnostics",
+                "config_check",
             }
             unknown = includes - VALID_INCLUDES
             if unknown:
@@ -464,6 +461,27 @@ class SystemTools:
             want_zha = zha_full or zha_summary
             want_zwave = "zwave_network" in includes
 
+            if ws_client is None:
+                # Health WebSocket unavailable: WS-backed sections can't run.
+                # Give each requested WS-backed section a machine-readable error
+                # sub-dict under its own key (same shape the section carries when
+                # the baseline is up but the fetch fails), plus a summary
+                # warning, then skip them so the REST sections below still run.
+                ws_error = "requires the system_health WebSocket, which is unavailable"
+                if want_repairs:
+                    result["repairs"] = {"error": ws_error}
+                if want_zha:
+                    result["zha_network"] = {"error": ws_error}
+                if want_zwave:
+                    result["zwave_network"] = {"error": ws_error}
+                unavailable = sorted(includes & ws_backed)
+                if unavailable:
+                    result.setdefault("warnings", []).append(
+                        "These sections require the system_health WebSocket, "
+                        f"which is unavailable: {', '.join(unavailable)}"
+                    )
+                want_repairs = want_zha = want_zwave = False
+
             sections: list[tuple[str, Coroutine[Any, Any, dict[str, Any]]]] = []
             if want_repairs:
                 sections.append(
@@ -593,6 +611,14 @@ class SystemTools:
                     "in include"
                 )
 
+            if "config_check" in includes:
+                # REST call on self._client (POST /config/core/check_config),
+                # not a ws_client command — so it runs inline like diagnostics
+                # rather than in the ws ``sections`` gather above. Standalone
+                # ``if`` (not chained to diagnostics) so both can be requested
+                # in one call.
+                result["config_check"] = await self._fetch_config_check()
+
             return result
 
         except ToolError:
@@ -606,11 +632,7 @@ class SystemTools:
                 ],
             )
         finally:
-            if ws_client:
-                try:
-                    await ws_client.disconnect()
-                except Exception:
-                    pass
+            await self._safe_disconnect(ws_client)
 
     @staticmethod
     def _parse_includes(include: str | None) -> set[str]:
@@ -619,6 +641,16 @@ class SystemTools:
             return set()
         return {s.strip().lower() for s in include.split(",") if s.strip()}
 
+    @staticmethod
+    async def _safe_disconnect(ws_client: Any) -> None:
+        """Best-effort WebSocket disconnect; never raises."""
+        if ws_client is None:
+            return
+        try:
+            await ws_client.disconnect()
+        except Exception:
+            pass
+
     async def _fetch_health_info(self) -> tuple[Any, dict[str, Any]]:
         """Connect to WebSocket and retrieve system health info.
 
@@ -645,6 +677,9 @@ class SystemTools:
                 "system_health/info", wait_timeout=10.0
             )
         except TimeoutError:
+            # The connection opened but the command stalled — disconnect it
+            # before raising so we don't leak the socket.
+            await self._safe_disconnect(ws_client)
             raise_tool_error(
                 create_error_response(
                     ErrorCode.SERVICE_CALL_FAILED,
@@ -652,6 +687,7 @@ class SystemTools:
                 )
             )
         except Exception as e:
+            await self._safe_disconnect(ws_client)
             raise_tool_error(
                 create_error_response(
                     ErrorCode.SERVICE_CALL_FAILED,
@@ -818,6 +854,38 @@ class SystemTools:
             )
         return zwave_network
 
+    async def _fetch_config_check(self) -> dict[str, Any]:
+        """Validate HA configuration via POST /config/core/check_config.
+
+        Returns an embeddable sub-dict (matching the ``_fetch_repairs`` /
+        ``_fetch_zha_network`` convention): baseline keys always present, with
+        an ``error`` field on backend failure. Never raises, so a config-check
+        failure surfaces as ``result["config_check"]["error"]`` without sinking
+        the rest of ha_get_system_health. Instance method (not @staticmethod)
+        because it calls the REST client (``self._client``), like the
+        diagnostics path.
+        """
+        config_check: dict[str, Any] = {
+            "result": "unknown",
+            "is_valid": False,
+            "errors": [],
+        }
+        try:
+            config_result = await self._client.check_config()
+            # The API returns {"result": "valid"} or
+            # {"result": "invalid", "errors": [...]}.
+            is_valid = config_result.get("result") == "valid"
+            errors = config_result.get("errors") or []  # Handle None case
+            config_check = {
+                "result": "valid" if is_valid else "invalid",
+                "is_valid": is_valid,
+                "errors": errors,
+            }
+        except Exception as e:
+            logger.warning("Failed to check config: %s", e)
+            config_check["error"] = f"Config check not available: {e}"
+        return config_check
+
 
 def register_system_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
     """Register Home Assistant system management tools."""

{ha_mcp_dev-7.6.0.dev644 → ha_mcp_dev-7.6.0.dev645/src/ha_mcp_dev.egg-info}/PKG-INFO

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