ha-mcp-dev 9.1.2.dev3405__tar.gz → 9.2.0.dev3410__tar.gz

{ha_mcp_dev-9.1.2.dev3405 → ha_mcp_dev-9.2.0.dev3410}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 9.1.2.dev3405
+Version: 9.2.0.dev3410
 Summary: Configure and automate Home Assistant with Claude, ChatGPT, and other AI assistants.
 Keywords: mcp,home-assistant,ai,automation,smart-home
 Author: Julien

{ha_mcp_dev-9.1.2.dev3405 → ha_mcp_dev-9.2.0.dev3410}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.1.2.dev3405"
+version = "9.2.0.dev3410"
 description = "Configure and automate Home Assistant with Claude, ChatGPT, and other AI assistants."
 readme = "README.md"
 requires-python = ">=3.13,<3.15"

{ha_mcp_dev-9.1.2.dev3405 → ha_mcp_dev-9.2.0.dev3410}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.1.2.dev3405"
+version = "9.2.0.dev3410"
 description = "Configure and automate Home Assistant with Claude, ChatGPT, and other AI assistants."
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

ha_mcp_dev-9.2.0.dev3410/src/ha_mcp/backup_files.py

@@ -0,0 +1,88 @@
+"""Auto-backup fetch and restore for whole files (``file`` / ``yaml_file``).
+
+Kept out of ``backup_manager.py``, which is at its module-size baseline.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .client.rest_client import HomeAssistantError
+
+# The component flag that gates read_file's ``keep_line_endings`` field.
+LINE_ENDINGS_CAPABILITY = "read_file_line_endings"
+
+
+async def _fetch_file(
+    client: Any, entity_id: str, *, keep_line_endings: bool = False
+) -> Any:
+    """Read a file's current content via the read_file service.
+
+    ``entity_id`` is the file path. Returns the content string, or None
+    when the file does not exist — a brand-new write has no prior content
+    to snapshot, so capture skips (same as creating a new entity). A
+    binary file also returns None: snapshots store text only, so capture
+    skips it instead of blocking the write or delete. Other read failures
+    raise so the capture pipeline logs them at WARNING.
+    """
+    from .tools.auto_backup import PathNotAllowedError
+    from .tools.tools_filesystem import call_mcp_tools_service
+    from .tools.util_helpers import unwrap_service_response
+
+    service_data: dict[str, Any] = {"path": entity_id}
+    if keep_line_endings:
+        service_data["keep_line_endings"] = True
+    result = await call_mcp_tools_service(client, "read_file", service_data)
+    if not isinstance(result, dict):
+        return None
+    result = unwrap_service_response(result)
+    if result.get("success", False):
+        content = result.get("content")
+        return content if isinstance(content, str) else None
+    error = str(result.get("error", ""))
+    skips = ("does not exist", "not a file", "Cannot read binary file")
+    if any(marker in error for marker in skips):
+        return None
+    if error.startswith("Path not allowed"):
+        raise PathNotAllowedError(entity_id, error)
+    raise HomeAssistantError(f"read_file failed for {entity_id!r}: {error}")
+
+
+async def _restore_file(client: Any, entity_id: str, config: Any) -> Any:
+    """Re-write a file's captured content via the write_file service."""
+    from .tools.tools_filesystem import call_mcp_tools_service
+    from .tools.util_helpers import unwrap_service_response
+
+    result = await call_mcp_tools_service(
+        client,
+        "write_file",
+        {
+            "path": entity_id,
+            "content": str(config),
+            "overwrite": True,
+            "create_dirs": True,
+        },
+    )
+    if isinstance(result, dict):
+        result = unwrap_service_response(result)
+        if not result.get("success", False):
+            raise HomeAssistantError(
+                f"write_file restore failed for {entity_id!r}: {result.get('error')}"
+            )
+    return result
+
+
+async def _fetch_file_as_stored(client: Any, entity_id: str) -> Any:
+    """``_fetch_file`` for a snapshot: CRLF stays CRLF, so a restore is exact.
+
+    A component without the ``read_file_line_endings`` flag would refuse the
+    field, so it gets the LF read it always served.
+    """
+    from .tools.component_api import component_supports, get_component_caps
+
+    caps = await get_component_caps(client)
+    return await _fetch_file(
+        client,
+        entity_id,
+        keep_line_endings=component_supports(caps, LINE_ENDINGS_CAPABILITY),
+    )

{ha_mcp_dev-9.1.2.dev3405 → ha_mcp_dev-9.2.0.dev3410}/src/ha_mcp/backup_manager.py

@@ -95,6 +95,7 @@ from .backup_entity_ids import (
     update_with_registry_icon,
     with_registry_icon,
 )
+from .backup_files import _fetch_file, _fetch_file_as_stored, _restore_file
 from .backup_helper_target import fetch_helper as _fetch_helper
 from .backup_helper_target import note_no_safety_backup as _note_no_safety_backup
 from .backup_helper_target import (
@@ -2475,60 +2476,6 @@ async def _registry_snapshot(client: Any, helper_type: str, item: dict) -> Any:
 # ``edit_yaml_config``. Both store the content as ``kind: "text"``.
 
 
-async def _fetch_file(client: Any, entity_id: str) -> Any:
-    """Read a file's current content via the read_file service.
-
-    ``entity_id`` is the file path. Returns the content string, or None
-    when the file does not exist — a brand-new write has no prior content
-    to snapshot, so capture skips (same as creating a new entity). A
-    binary file also returns None: snapshots store text only, so capture
-    skips it instead of blocking the write or delete. Other read failures
-    raise so the capture pipeline logs them at WARNING.
-    """
-    from .tools.auto_backup import PathNotAllowedError
-    from .tools.tools_filesystem import call_mcp_tools_service
-    from .tools.util_helpers import unwrap_service_response
-
-    result = await call_mcp_tools_service(client, "read_file", {"path": entity_id})
-    if not isinstance(result, dict):
-        return None
-    result = unwrap_service_response(result)
-    if result.get("success", False):
-        content = result.get("content")
-        return content if isinstance(content, str) else None
-    error = str(result.get("error", ""))
-    skips = ("does not exist", "not a file", "Cannot read binary file")
-    if any(marker in error for marker in skips):
-        return None
-    if error.startswith("Path not allowed"):
-        raise PathNotAllowedError(entity_id, error)
-    raise HomeAssistantError(f"read_file failed for {entity_id!r}: {error}")
-
-
-async def _restore_file(client: Any, entity_id: str, config: Any) -> Any:
-    """Re-write a file's captured content via the write_file service."""
-    from .tools.tools_filesystem import call_mcp_tools_service
-    from .tools.util_helpers import unwrap_service_response
-
-    result = await call_mcp_tools_service(
-        client,
-        "write_file",
-        {
-            "path": entity_id,
-            "content": str(config),
-            "overwrite": True,
-            "create_dirs": True,
-        },
-    )
-    if isinstance(result, dict):
-        result = unwrap_service_response(result)
-        if not result.get("success", False):
-            raise HomeAssistantError(
-                f"write_file restore failed for {entity_id!r}: {result.get('error')}"
-            )
-    return result
-
-
 async def _fetch_yaml(client: Any, entity_id: str) -> Any:
     """Read the current YAML subtree for a ``{file}::{yaml_path}`` target.
 
@@ -2586,12 +2533,12 @@ async def _restore_yaml(client: Any, entity_id: str, config: Any) -> Any:
     and can therefore be left off.
     """
     from .config import get_global_settings
-    from .tools.tools_filesystem import (
+    from .tools.tools_filesystem import call_mcp_tools_service
+    from .tools.util_helpers import unwrap_service_response
+    from .tools.yaml_extra_keys import (
         assert_extra_yaml_keys_supported,
-        call_mcp_tools_service,
         effective_extra_yaml_write_keys,
     )
-    from .tools.util_helpers import unwrap_service_response
 
     # Split on the LAST "::" (see _fetch_yaml) so an exotic file path
     # containing "::" still restores to the right file and key.
@@ -3601,12 +3548,12 @@ def register_default_handlers(mgr: BackupManager, _client: Any) -> None:
     mgr.register(DomainHandler("entity", fetch_entity, restore_entity))
     mgr.register(DomainHandler("device", _fetch_device, _restore_device))
     mgr.register(DomainHandler("integration", fetch_integration, restore_integration))
-    mgr.register(DomainHandler("file", _fetch_file, _restore_file))
+    mgr.register(DomainHandler("file", _fetch_file_as_stored, _restore_file))
     mgr.register(DomainHandler("yaml", _fetch_yaml, _restore_yaml))
     # Whole-file YAML config: same fetch as "file" (read_file), but restored via
     # edit_yaml_config(replace_file) since write_file rejects config files.
     # Backs the legacy-restore write path and its pre-restore safety snapshot.
-    mgr.register(DomainHandler("yaml_file", _fetch_file, _restore_yaml_file))
+    mgr.register(DomainHandler("yaml_file", _fetch_file_as_stored, _restore_yaml_file))
     # Blueprint files (#2329): the pre-write snapshot for
     # ha_manage_blueprints(action="delete" / "save").
     for blueprint_domain in ("automation", "script"):

{ha_mcp_dev-9.1.2.dev3405 → ha_mcp_dev-9.2.0.dev3410}/src/ha_mcp/tools/auto_backup.py

@@ -43,6 +43,7 @@ from ..backup_manager import (
 )
 from ..config import get_global_settings
 from ..errors import TOOL_ERROR_LOG_LEVEL, ErrorCode, create_error_response
+from ..utils.registry_update_lock import registry_update_lock
 from .helpers import raise_tool_error
 from .resource_patch import resource_write_lock
 
@@ -412,6 +413,11 @@ async def _template_write_context(
     Assistant UI or other processes are not serialized, so the snapshot can
     predate an edit made there that the write then replaces. The resource
     tools must not take the lock again: ``asyncio.Lock`` is not reentrant.
+
+    File tools share one lock rather than one per path, because a link and its
+    target are the same file under two names. YAML edits take it as well: a
+    theme file is written by both, and two snapshots taken before either write
+    would let a restore of the later one remove the earlier change.
     """
     # Both options-update tools take stable config-entry IDs. Alias-based helper
     # removal and dotted subentry targets have separate resolution paths.
@@ -425,6 +431,10 @@ async def _template_write_context(
     elif domain == "dashboard_resource" and entity_id:
         async with resource_write_lock(entity_id):
             yield
+    elif domain in ("file", "yaml") and entity_id:
+        # YAML edits too: ha_config_set_yaml and ha_write_file both write themes/.
+        async with registry_update_lock("file", "all_files"):
+            yield
     else:
         yield
 

ha_mcp_dev-9.2.0.dev3410/src/ha_mcp/tools/file_edit_refusal.py

@@ -0,0 +1,55 @@
+"""Turn an edit_file refusal into the structured error the edit tools share.
+
+``ha_config_set_dashboard_resource(edits=...)`` raises its refusals through
+``create_error_response`` with ``reason`` in the context; ``ha_write_file``
+edits do the same, so both edit surfaces answer in one shape.
+"""
+
+from typing import Any, NoReturn
+
+from ..errors import ErrorCode, create_error_response
+from .helpers import raise_tool_error
+
+# Refusals of the edits themselves; any other reason is about the file or call.
+_EDIT_REASONS = frozenset(
+    {"invalid_edit", "old_not_found", "old_not_unique", "line_endings_only"}
+)
+_CONTEXT_KEYS = (
+    "reason",
+    "edit_index",
+    "invalid_edit_indexes",
+    "matches",
+    "line_endings",
+    "parent",
+)
+_SUGGESTIONS = {
+    "invalid_edit": ["Every edit needs a non-empty 'old' that differs from its 'new'"],
+    "old_not_found": [
+        "Match the stored text exactly, including whitespace",
+        "Earlier edits apply first; account for text they changed",
+        "Read the current text with ha_read_file",
+    ],
+    "old_not_unique": ["Add surrounding context to 'old' so it matches once"],
+    "line_endings_only": ["Send the whole file with content= to change line endings"],
+    "not_found": ["Create the file with content= instead of edits"],
+}
+
+
+def raise_edit_file_refusal(result: dict[str, Any], path: str) -> NoReturn:
+    """Raise the component's ``success: false`` edit_file reply as a ToolError."""
+    reason = result.get("reason")
+    code = (
+        ErrorCode.VALIDATION_INVALID_PARAMETER
+        if reason in _EDIT_REASONS
+        else ErrorCode.SERVICE_CALL_FAILED
+    )
+    context: dict[str, Any] = {"path": path}
+    context.update({key: result[key] for key in _CONTEXT_KEYS if key in result})
+    raise_tool_error(
+        create_error_response(
+            code,
+            str(result.get("error") or "edit_file failed"),
+            suggestions=_SUGGESTIONS.get(str(reason)),
+            context=context,
+        )
+    )

{ha_mcp_dev-9.1.2.dev3405 → ha_mcp_dev-9.2.0.dev3410}/src/ha_mcp/tools/resource_patch.py

@@ -44,7 +44,7 @@ def resource_write_lock(resource_id: str | None) -> AbstractAsyncContextManager[
 
 
 class ResourceEdit(TypedDict):
-    """One exact-match replacement in an inline resource."""
+    """One exact-match replacement."""
 
     old: Annotated[
         str,