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

{ha_mcp_dev-9.1.2.dev3402 → 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.dev3402
+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.dev3402 → 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.dev3402"
+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.dev3402 → 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.dev3402"
+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.dev3402 → 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.dev3402 → 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.dev3402 → ha_mcp_dev-9.2.0.dev3410}/src/ha_mcp/tools/hacs_backend.py

@@ -5,6 +5,7 @@ integration and removes the ``hacs/*`` WebSocket commands. The HACS tools
 talk to whichever API the instance serves, Marketplace first.
 """
 
+import re
 from dataclasses import dataclass, field
 from typing import Any, NoReturn
 
@@ -76,6 +77,47 @@ _GATE_SUGGESTIONS = {
     ],
 }
 
+# Two store records claiming custom_components/ha_mcp_tools (#2993): the
+# Marketplace refuses to update either, and refuses to uninstall a record while
+# any HA-MCP config entry exists, disabled ones included. Both ways out were
+# checked on a live instance; neither can be driven through this server.
+DUPLICATE_RECORD_SUGGESTIONS = [
+    "A current HA-MCP integration files a repair for this under Settings > "
+    + "System > Repairs; its fix keeps homeassistant-ai/ha-mcp and marks the "
+    + "other record as not installed, with no change to entries or files. Ask "
+    + "the user to run it.",
+    "Without that repair: the store refuses to uninstall a record while any "
+    + "HA-MCP entry exists, disabled ones included, and this server cannot "
+    + "drive either route below. Ask the user before suggesting them.",
+    "Route 1 (no terminal): delete every HA-MCP entry under Settings > Devices "
+    + "& services, uninstall the duplicate record in the store, update the kept "
+    + "record, add the entries back and restart. An embedded server entry gets "
+    + "a new connect URL, so MCP clients reconnect.",
+    "Route 2 (keeps the entries): with Home Assistant Core stopped, set "
+    + '"installed": false on the duplicate record in '
+    + ".storage/marketplace.repositories (.storage/hacs.repositories on HACS), "
+    + "start Core, then update the kept record.",
+]
+# Core's ``integration_owned`` message: "The {domain} directory belongs to
+# {owner}." The store sends no error code for it, so the whole sentence is
+# matched, owner as ``owner/repo``, never a fragment of some other message.
+_OWNED_DIRECTORY = re.compile(
+    r"^(?:Command failed: )?The \S+ directory belongs to ([\w.-]+/[\w-][\w.-]*?)\.?$"
+)
+
+
+def _owned_directory_suggestions(owner: str) -> list[str]:
+    """The store refused an install because another installed record owns the
+    integration's directory: the owner is the record to install or update."""
+    return [
+        f"{owner} already provides this integration. Update or reinstall it "
+        f'there: ha_manage_hacs(action="download", repository_id="{owner}").',
+        "To switch repositories instead, uninstall the owner first; the store "
+        "refuses that while any of the integration's config entries exist, so "
+        "ask the user before deleting entries under Settings > Devices & "
+        "services.",
+    ]
+
 
 @dataclass(frozen=True)
 class StoreApi:
@@ -187,15 +229,37 @@ async def detect_store_api(ws_client: Any) -> StoreApi:
     return HACS_API  # unreachable: raise_tool_error always raises
 
 
+def is_owned_directory_refusal(err: HomeAssistantCommandError) -> bool:
+    """Whether the store refused because another installed record owns the
+    integration's directory."""
+    return _OWNED_DIRECTORY.match(str(err).strip()) is not None
+
+
 def raise_store_error(
-    err: HomeAssistantCommandError, context: dict[str, Any]
+    err: HomeAssistantCommandError,
+    context: dict[str, Any],
+    *,
+    installed_records: list[str] | None = None,
 ) -> NoReturn:
     """Raise a store command failure; a Marketplace gate names the UI step.
 
     The gates are told apart by Core's error code: their messages ("Connect a
-    GitHub account ...") would otherwise read as a connection failure.
+    GitHub account ...") would otherwise read as a connection failure. An
+    ownership refusal names the owner to update, unless the owner is one of
+    ha-mcp's own records and ``installed_records`` shows two of them
+    installed: then neither can be updated and the suggestions are the way
+    out of that. A refusal naming some other integration's owner keeps the
+    owner hint whatever ha-mcp's own records look like.
     """
-    if suggestions := _GATE_SUGGESTIONS.get(err.code or ""):
+    suggestions = _GATE_SUGGESTIONS.get(err.code or "")
+    if match := _OWNED_DIRECTORY.match(str(err).strip()):
+        owners = {r.lower() for r in installed_records or []}
+        if len(owners) > 1 and match[1].lower() in owners:
+            suggestions = DUPLICATE_RECORD_SUGGESTIONS
+            context = {**context, "installed": installed_records}
+        else:
+            suggestions = _owned_directory_suggestions(match[1])
+    if suggestions:
         raise_tool_error(
             create_error_response(
                 ErrorCode.SERVICE_CALL_FAILED,

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

@@ -0,0 +1,162 @@
+"""Keep ha-mcp's own integration on the one store repository that owns it.
+
+Two repositories carry the ``ha_mcp_tools`` component: the main repository,
+which the default catalog lists, and the legacy distribution mirror earlier
+installs came from. Both extract to ``custom_components/ha_mcp_tools``. The
+Marketplace (Home Assistant 2026.11+) refuses to install a repository whose
+integration another installed repository owns. HACS never checked, so a
+download of the second repository on Home Assistant 2026.10 or older left both
+records claiming the directory, and after the 2026.11 upgrade the Marketplace
+refuses to update either (#2993). The server's own install guidance names the
+main repository, so a download of either repository goes to the one that is
+installed.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from ..client.rest_client import HomeAssistantCommandError, HomeAssistantCommandTimeout
+from ..errors import ErrorCode, create_error_response
+from ..hacs_auto_refresh import CANDIDATE_REPO_FULL_NAMES
+from .hacs_backend import StoreApi, is_owned_directory_refusal
+from .helpers import raise_tool_error
+
+MAIN_REPOSITORY = "homeassistant-ai/ha-mcp"
+MIRROR_REPOSITORY = "homeassistant-ai/ha-mcp-integration"
+# The stores use the GitHub repository id, fixed for a repository's lifetime.
+OWN_REPOSITORY_IDS = {"1056618941": MAIN_REPOSITORY, "1289599380": MIRROR_REPOSITORY}
+
+# The two repositories tag releases alike, but not development builds:
+# publish-dev.yml tags the main repository ``v<next>.dev<N>`` while
+# sync-integration-mirror.yml tags the mirror ``v<next>-dev.<N>``.
+_MAIN_DEV_REF = re.compile(r"^(v?\d+\.\d+\.\d+)\.dev(\d+)$")
+_MIRROR_DEV_REF = re.compile(r"^(v?\d+\.\d+\.\d+)-dev\.(\d+)$")
+_RELEASE_REF = re.compile(r"^v?(\d+)\.(\d+)\.(\d+)")
+# From 9.0 both repositories tag a release with the server version; before
+# that the mirror carried the component's own numbers (v2.2.1 for 8.6.0).
+_SHARED_TAGS_SINCE = (9, 0, 0)
+
+
+def _tagged_alike(version: str) -> bool:
+    match = _RELEASE_REF.match(version)
+    if match is None:
+        return False
+    return tuple(int(p) for p in match.groups()) >= _SHARED_TAGS_SINCE
+
+
+def translate_version(version: str | None, target: str) -> str | None:
+    """The same release named the way ``target`` tags it."""
+    if not version:
+        return version
+    if target.lower() == MIRROR_REPOSITORY and (match := _MAIN_DEV_REF.match(version)):
+        return f"{match[1]}-dev.{match[2]}"
+    if target.lower() == MAIN_REPOSITORY and (match := _MIRROR_DEV_REF.match(version)):
+        return f"{match[1]}.dev{match[2]}"
+    return version
+
+
+def _own_name(repo: dict[str, Any]) -> str | None:
+    full_name = (repo.get("full_name") or "").lower()
+    if full_name in {n.lower() for n in CANDIDATE_REPO_FULL_NAMES}:
+        return full_name
+    return None
+
+
+async def installed_own_records(
+    ws_client: Any, api: StoreApi
+) -> list[dict[str, Any]] | None:
+    """The store's records for ha-mcp's own repositories that are installed,
+    or None when the store could not be asked."""
+    try:
+        response = await ws_client.send_command(api.command("list"))
+    except (HomeAssistantCommandError, HomeAssistantCommandTimeout):
+        return None
+    listed = response.get("result") if isinstance(response, dict) else None
+    repos = [dict(r) for r in (listed or []) if isinstance(r, dict)]
+    return [r for r in repos if _own_name(r) and r.get("installed")]
+
+
+async def ownership_refusal_records(
+    ws_client: Any, api: StoreApi, err: HomeAssistantCommandError
+) -> list[str] | None:
+    """For a store refusal, the installed own records' names, so the refusal
+    can be explained; None for any other error, with no store call."""
+    if not is_owned_directory_refusal(err):
+        return None
+    records = await installed_own_records(ws_client, api)
+    return [str(r.get("full_name")) for r in records or []]
+
+
+async def route_own_repository_download(
+    ws_client: Any, api: StoreApi, repository_id: str, version: str | None
+) -> tuple[str, str | None, str | None]:
+    """Return the repository and version to download, and a note when rerouted.
+
+    A repository that is not ha-mcp's own, by name or by id, passes through
+    with no store call, so a download stays one store command. For ha-mcp's
+    own, the installed one wins: a request for the other repository is
+    rerouted to it, so the mirror keeps updating from the mirror and the main
+    repository from the catalog, and a development ref is renamed the way the
+    target tags it. With two installed records the store decides: the
+    Marketplace refuses the download itself and that refusal is explained
+    where it is raised; HACS still downloads, with a warning.
+    """
+    wanted = repository_id.strip().lower()
+    wanted = OWN_REPOSITORY_IDS.get(wanted, wanted)
+    if wanted not in {n.lower() for n in CANDIDATE_REPO_FULL_NAMES}:
+        return repository_id, version, None
+
+    installed = await installed_own_records(ws_client, api)
+    if installed is None:
+        # The download itself reports the store's trouble, with its own context
+        return repository_id, version, None
+    if len(installed) > 1:
+        if api.is_marketplace:
+            # The Marketplace refuses this download itself; raise_store_error
+            # explains the refusal with the way out.
+            return repository_id, version, None
+        names = " and ".join(str(r.get("full_name")) for r in installed)
+        # HACS never checked ownership, so the download still works there and
+        # is the way to bring in the release whose repair keeps one listing.
+        note = (
+            f"{names} are both installed and both claim "
+            "custom_components/ha_mcp_tools. HACS still updates either, but the "
+            "Marketplace in Home Assistant 2026.11 will refuse to. After this "
+            "download restart Home Assistant and run the repair under Settings > "
+            f"System > Repairs, which keeps {MAIN_REPOSITORY}. If no repair "
+            "appears, the installed release predates it: update to a current "
+            "release or follow the manual route in the FAQ."
+        )
+        return repository_id, version, note
+    if not installed or _own_name(installed[0]) == wanted:
+        return repository_id, version, None
+    owner = str(installed[0].get("full_name"))
+    if version and not _tagged_alike(version):
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.VALIDATION_INVALID_PARAMETER,
+                f"{owner} owns custom_components/ha_mcp_tools, and releases "
+                f"before {'.'.join(map(str, _SHARED_TAGS_SINCE))} are tagged "
+                f"differently there, so {version} cannot be mapped to it.",
+                suggestions=[
+                    "Pick a version from the installed repository: "
+                    'ha_get_hacs_info(action="info", '
+                    f'repository_id="{owner}", include_releases=True), then '
+                    f'ha_manage_hacs(action="download", repository_id="{owner}", '
+                    'version="<one of its tags>").',
+                    "Or omit version to install its latest release.",
+                ],
+                context={"repository_id": repository_id, "version": version},
+            )
+        )
+    target_version = translate_version(version, owner)
+    note = (
+        f"{repository_id} was rerouted to {owner}, which already owns "
+        "custom_components/ha_mcp_tools; HA-MCP stays on the one listing it "
+        "was installed from."
+    )
+    if target_version != version:
+        note += f" The version was renamed from {version} to {target_version}."
+    return owner, target_version, note

{ha_mcp_dev-9.1.2.dev3402 → 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,