ha-mcp-dev 7.5.0.dev512__tar.gz → 7.5.0.dev514__tar.gz

{ha_mcp_dev-7.5.0.dev512/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.5.0.dev514}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.5.0.dev512"
+version = "7.5.0.dev514"
 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.dev512 → ha_mcp_dev-7.5.0.dev514}/src/ha_mcp/tools/tools_config_dashboards.py

@@ -21,12 +21,68 @@ from ..utils.python_sandbox import (
     get_security_documentation,
     safe_execute,
 )
-from .helpers import exception_to_structured_error, log_tool_usage, raise_tool_error
+from .helpers import (
+    exception_to_structured_error,
+    extract_tool_error_message,
+    log_tool_usage,
+    raise_tool_error,
+)
 from .util_helpers import parse_json_param
 
 logger = logging.getLogger(__name__)
 
 
+async def _get_dashboard_config_internal(
+    client: Any, url_path: str | None
+) -> tuple[dict[str, Any], str]:
+    """Fetch dashboard config from HA and compute its hash.
+
+    Returns ``(config, config_hash)`` tuple where ``config`` is the
+    authoritative Lovelace config dict returned by HA's ``lovelace/config``
+    WebSocket call (with ``force=True`` to bypass any cache) and
+    ``config_hash`` is computed from that config via ``compute_config_hash``.
+
+    Used internally to obtain the authoritative post-save hash and as the
+    fetch+hash building block for the optimistic-locking pre-read paths.
+    Mirrors the ``_get_<entity>_config_internal`` helpers in the sibling
+    files (``tools_config_scripts.py``, ``tools_config_automations.py``,
+    ``tools_config_scenes.py``).
+
+    Raises ``ToolError`` with ``ErrorCode.SERVICE_CALL_FAILED`` if the
+    WebSocket call reports failure or the response is not a dict; callers
+    can rely on the returned tuple being populated.
+    """
+    get_data: dict[str, Any] = {"type": "lovelace/config", "force": True}
+    if url_path:
+        get_data["url_path"] = url_path
+
+    response = await client.send_websocket_message(get_data)
+
+    if isinstance(response, dict) and not response.get("success", True):
+        error_msg = response.get("error", {})
+        if isinstance(error_msg, dict):
+            error_msg = error_msg.get("message", str(error_msg))
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.SERVICE_CALL_FAILED,
+                f"Dashboard fetch failed: {error_msg}",
+                context={"url_path": url_path},
+            )
+        )
+
+    config = response.get("result") if isinstance(response, dict) else response
+    if not isinstance(config, dict):
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.SERVICE_CALL_FAILED,
+                "Dashboard config response was not a dict",
+                context={"url_path": url_path},
+            )
+        )
+
+    return cast(dict[str, Any], config), compute_config_hash(config)
+
+
 async def _verify_config_unchanged(
     client: Any,
     url_path: str,
@@ -1029,21 +1085,19 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
                         )
                     )
 
-                # Fetch current dashboard config
-                get_data: dict[str, Any] = {"type": "lovelace/config", "force": True}
-                if url_path:
-                    get_data["url_path"] = url_path
-
-                response = await client.send_websocket_message(get_data)
-
-                if isinstance(response, dict) and not response.get("success", True):
-                    error_msg = response.get("error", {})
-                    if isinstance(error_msg, dict):
-                        error_msg = error_msg.get("message", str(error_msg))
+                # Fetch current dashboard config + hash via the shared helper.
+                # Re-wrap helper's generic fetch error with python_transform-
+                # specific UX suggestions so the caller learns this branch
+                # requires an existing dashboard.
+                try:
+                    current_config, current_hash = await _get_dashboard_config_internal(
+                        client, url_path
+                    )
+                except ToolError as e:
                     raise_tool_error(
                         create_error_response(
                             ErrorCode.SERVICE_CALL_FAILED,
-                            f"Dashboard not found or inaccessible: {error_msg}",
+                            f"Dashboard not found or inaccessible: {extract_tool_error_message(e)}",
                             suggestions=[
                                 "python_transform requires an existing dashboard",
                                 "Use 'config' parameter to create a new dashboard",
@@ -1056,26 +1110,7 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
                         )
                     )
 
-                current_config = (
-                    response.get("result") if isinstance(response, dict) else response
-                )
-                if not isinstance(current_config, dict):
-                    raise_tool_error(
-                        create_error_response(
-                            ErrorCode.SERVICE_CALL_FAILED,
-                            "Current dashboard config is invalid",
-                            suggestions=[
-                                "Initialize dashboard with 'config' parameter first"
-                            ],
-                            context={
-                                "action": "python_transform",
-                                "url_path": url_path,
-                            },
-                        )
-                    )
-
                 # Validate config_hash for optimistic locking
-                current_hash = compute_config_hash(current_config)
                 if current_hash != config_hash:
                     raise_tool_error(
                         create_error_response(
@@ -1153,8 +1188,10 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
                         )
                     )
 
-                # Compute new hash for potential chaining
-                new_config_hash = compute_config_hash(transformed_config)
+                # Re-fetch to get authoritative hash (HA may normalize after save)
+                _, new_config_hash = await _get_dashboard_config_internal(
+                    client, url_path
+                )
 
                 transform_result: dict[str, Any] = {
                     "success": True,
@@ -1309,38 +1346,44 @@ def register_config_dashboard_tools(mcp: Any, client: Any, **kwargs: Any) -> Non
 
                 # For existing dashboards, optionally validate config_hash and warn on large replacement
                 if dashboard_exists:
-                    # Fetch current config for validation/comparison
-                    get_data = {
-                        "type": "lovelace/config",
-                        "force": True,
-                    }
-                    if url_path:
-                        get_data["url_path"] = url_path
-                    current_response = await client.send_websocket_message(get_data)
-                    current_config = (
-                        current_response.get("result")
-                        if isinstance(current_response, dict)
-                        else current_response
-                    )
-
-                    if isinstance(current_config, dict):
-                        existing_config_size = len(json.dumps(current_config))
+                    # Fetch current config + hash via the shared helper.
+                    # Tolerate fetch failures here — full-config replacement
+                    # should still proceed even if the pre-read can't load
+                    # the current state (force-replace path). The strict
+                    # ``ToolError`` raised by the helper is downgraded to a
+                    # skip of both the optimistic-locking check and the
+                    # large-config soft warning, matching the prior
+                    # silently-fall-through behaviour.
+                    # Distinct names from the python_transform branch's
+                    # ``current_config``/``current_hash`` so the optional
+                    # type here doesn't redefine the non-optional binding
+                    # mypy infers there.
+                    existing_config: dict[str, Any] | None = None
+                    existing_hash: str | None = None
+                    try:
+                        (
+                            existing_config,
+                            existing_hash,
+                        ) = await _get_dashboard_config_internal(client, url_path)
+                    except ToolError:
+                        pass
+
+                    if isinstance(existing_config, dict):
+                        existing_config_size = len(json.dumps(existing_config))
 
                         # Optional config_hash validation for full replacement
-                        if config_hash is not None:
-                            current_hash = compute_config_hash(current_config)
-                            if current_hash != config_hash:
-                                raise_tool_error(
-                                    create_error_response(
-                                        ErrorCode.SERVICE_CALL_FAILED,
-                                        "Dashboard modified since last read (conflict)",
-                                        suggestions=[
-                                            "Call ha_config_get_dashboard() again",
-                                            "Use the fresh config_hash, or omit config_hash to force replace",
-                                        ],
-                                        context={"action": "set", "url_path": url_path},
-                                    )
+                        if config_hash is not None and existing_hash != config_hash:
+                            raise_tool_error(
+                                create_error_response(
+                                    ErrorCode.SERVICE_CALL_FAILED,
+                                    "Dashboard modified since last read (conflict)",
+                                    suggestions=[
+                                        "Call ha_config_get_dashboard() again",
+                                        "Use the fresh config_hash, or omit config_hash to force replace",
+                                    ],
+                                    context={"action": "set", "url_path": url_path},
                                 )
+                            )
 
                         # Soft warning for large config full replacement (10KB ≈ 2-3k tokens)
                         if existing_config_size >= 10000:

{ha_mcp_dev-7.5.0.dev512 → ha_mcp_dev-7.5.0.dev514/src/ha_mcp_dev.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 7.5.0.dev512
+Version: 7.5.0.dev514
 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.dev512 → ha_mcp_dev-7.5.0.dev514}/tests/test_env_manager.py

@@ -17,6 +17,7 @@ import sys
 import time
 from pathlib import Path
 
+import docker.errors
 import requests
 from testcontainers.core.container import DockerContainer
 
@@ -302,13 +303,26 @@ def main():
         env.print_status()
 
         if args.no_interactive:
-            # Non-interactive mode: just wait for interrupt
+            # Non-interactive mode: wait for interrupt, and exit if the container dies
+            # so systemd's Restart=on-failure kicks in with a fresh instance.
             logger.info("🔄 Running in non-interactive mode. Press Ctrl+C to stop.")
             try:
                 while True:
-                    time.sleep(1)
+                    time.sleep(30)
+                    if env.container:
+                        wrapped = env.container.get_wrapped_container()
+                        wrapped.reload()
+                        if wrapped.status not in ("running",):
+                            logger.error(
+                                f"❌ Container stopped unexpectedly "
+                                f"(status: {wrapped.status}), exiting for restart..."
+                            )
+                            sys.exit(1)
             except KeyboardInterrupt:
                 logger.info("\n🛑 Received interrupt signal")
+            except (OSError, RuntimeError, docker.errors.DockerException) as e:
+                logger.error(f"❌ Watchdog failure: {e}, exiting for restart...")
+                sys.exit(1)
         else:
             # Interactive menu loop
             while True: