ha-mcp-dev 9.0.0.dev3101__tar.gz → 9.0.0.dev3105__tar.gz

{ha_mcp_dev-9.0.0.dev3101 → ha_mcp_dev-9.0.0.dev3105}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 9.0.0.dev3101
+Version: 9.0.0.dev3105
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Keywords: mcp,home-assistant,ai,automation,smart-home
 Author: Julien

{ha_mcp_dev-9.0.0.dev3101 → ha_mcp_dev-9.0.0.dev3105}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.0.0.dev3101"
+version = "9.0.0.dev3105"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.15"
@@ -253,6 +253,7 @@ markers = [
     "not_on_haos_embedded: skip on the haos_embedded backend (HAOS_TEST_MODE=embedded) - provably redundant with the lane's own session backend, which enables the entry once and drives the in-process server for the whole suite; #1527",
     "requires_tools_entry: needs the File & YAML Tools config entry - skipped on E2E_NO_TOOLS_ENTRY=1 lanes (#2292)",
     "no_tools_only: runs only on E2E_NO_TOOLS_ENTRY=1 lanes (#2292)",
+    "requires_component_surface: needs an active ha_mcp_tools config entry - skipped on the no-tools lanes without an active server entry (plain container, HAOS inaddon, where it is absent or disabled); #2584",
 ]
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "session"

{ha_mcp_dev-9.0.0.dev3101 → ha_mcp_dev-9.0.0.dev3105}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.0.0.dev3101"
+version = "9.0.0.dev3105"
 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
@@ -328,6 +328,7 @@ markers = [
     "not_on_haos_embedded: skip on the haos_embedded backend (HAOS_TEST_MODE=embedded) - provably redundant with the lane's own session backend, which enables the entry once and drives the in-process server for the whole suite; #1527",
     "requires_tools_entry: needs the File & YAML Tools config entry - skipped on E2E_NO_TOOLS_ENTRY=1 lanes (#2292)",
     "no_tools_only: runs only on E2E_NO_TOOLS_ENTRY=1 lanes (#2292)",
+    "requires_component_surface: needs an active ha_mcp_tools config entry - skipped on the no-tools lanes without an active server entry (plain container, HAOS inaddon, where it is absent or disabled); #2584",
 ]
 
 # Async support - session-scoped loop lets session-scoped fixtures

{ha_mcp_dev-9.0.0.dev3101 → ha_mcp_dev-9.0.0.dev3105}/src/ha_mcp/tools/component_api.py

@@ -19,6 +19,10 @@ or somewhere in between. This module negotiates that with a single cached
   surface entirely; caps are cached as ``None`` and every consumer falls back
   to its legacy path.
 
+``read_info`` reads ``info`` fresh for callers that show a field which can
+change while the client lives (the bug report's component version and webhook
+auth mode); routing and gating keep using the snapshot.
+
 This mirrors the caller-token cache in ``tools_filesystem.py``: weak-keyed by
 client so multi-client / OAuth setups each negotiate independently and the
 entry self-evicts when a client is garbage-collected.
@@ -45,6 +49,8 @@ logger = logging.getLogger(__name__)
 # The WS command every 1.1.0+ component registers; probing it does double duty
 # (existence check + capability enumeration — see module docstring).
 INFO_COMMAND = "ha_mcp_tools/info"
+# The ``result`` of an ``info`` call, as ``read_info`` returns it.
+InfoResult = dict[str, Any]
 
 # HA's structured error code for a command no handler is registered for. Routing
 # keys off this (via the ``code`` attribute threaded onto
@@ -406,3 +412,61 @@ def invalidate_caps(client: Any) -> None:
     _CAPS_CACHE.pop(client, None)
     _NEGATIVE_CACHE_TS.pop(client, None)
     _TRANSIENT_NEGATIVE_TS.pop(client, None)
+
+
+async def read_info(client: Any) -> InfoResult | None:
+    """The ``result`` of a fresh ``ha_mcp_tools/info`` call (#2584).
+
+    For callers that show a field which can change while the client lives:
+    the bug report's component version and webhook auth mode. Routing and
+    gating keep the ``get_component_caps`` snapshot, which lasts as long as the
+    client (for a server running outside HA, an HA restart does not end it),
+    while a component update changes the version and an options change the
+    mode. Only a component whose ``info`` the snapshot accepted is asked. The
+    call goes to ``send_command`` on the pooled WebSocket directly, as the
+    probe does, bypassing ``send_websocket_message``'s ERROR log (a report
+    quotes its log sections); an ``unknown_command`` drops the snapshot so the
+    next caller re-probes. None in that case and on any failure.
+    """
+    if await get_component_caps(client) is None:
+        return None
+    try:
+        ws = await get_websocket_client(
+            url=client.base_url,
+            token=client.token,
+            verify_ssl=getattr(client, "verify_ssl", None),
+        )
+        response = await ws.send_command(INFO_COMMAND)
+    except Exception as e:  # noqa: BLE001
+        if is_unknown_command(e):
+            invalidate_caps(client)
+        logger.info("Fresh %s read failed: %s (%s)", INFO_COMMAND, e, type(e).__name__)
+        return None
+    result = response.get("result") if isinstance(response, dict) else None
+    return result if isinstance(result, dict) else None
+
+
+async def read_component_version(client: Any, info: InfoResult | None) -> str | None:
+    """The component version for a report: from ``info``, else the snapshot's.
+
+    ``info`` is a ``read_info`` result. When that read failed, the snapshot
+    still shows the component is installed. After an ``unknown_command``,
+    ``read_info`` has dropped the snapshot, so the re-probe normally finds no
+    ``info`` either and the result is None. ``""`` when the component reports no
+    version; None only when there is no usable ``info``.
+    """
+    if info is not None:
+        return str(info.get("component_version") or "")
+    caps = await get_component_caps(client)
+    return caps.component_version if caps is not None else None
+
+
+def webhook_auth(info: InfoResult | None) -> str | None:
+    """The server entry's webhook auth mode from a ``read_info`` result.
+
+    Python None, not the ``"none"`` mode: without ``info``, or when its
+    ``webhook_auth`` is missing (an older component) or not a string. The
+    component sends None without a running in-process server.
+    """
+    auth = info.get("webhook_auth") if info else None
+    return auth if isinstance(auth, str) else None

ha_mcp_dev-9.0.0.dev3105/src/ha_mcp/tools/server_version.py

@@ -0,0 +1,77 @@
+"""The running ha-mcp version against the one installed on disk.
+
+``__version__`` is frozen when the process first imports ha_mcp, so after an
+in-place update the running process keeps reporting the old version while the
+disk already carries the new one. Reporting both turns a "which server am I
+talking to" hunt into a single tool call.
+"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+from typing import Any
+
+from ha_mcp import __version__
+
+from .._version import get_version, is_dev_version, is_embedded
+
+logger = logging.getLogger(__name__)
+
+
+def detect_installed_version() -> str | None:
+    """Return the installed ha-mcp version as ``get_version`` resolves it now.
+
+    That is the package metadata on disk, or ``HA_MCP_BUILD_VERSION`` when set.
+    None when it cannot be read.
+    """
+    try:
+        importlib.invalidate_caches()
+    except KeyError as e:
+        # Python 3.14 with an editable homeassistant install (the official
+        # container image, where the in-process server runs) raises here
+        # (#1891); a read without the refresh still beats none.
+        logger.warning("importlib.invalidate_caches() failed: %s", e)
+    try:
+        version = get_version()
+    except Exception as e:  # noqa: BLE001
+        logger.info("Installed-version probe failed: %s", e)
+        return None
+    return None if version == "unknown" else version
+
+
+def version_mismatch(installed: str | None) -> bool:
+    """True when ``installed`` is not the version this process imported.
+
+    A failed probe (None) is no mismatch.
+    """
+    return bool(installed and installed != __version__)
+
+
+def running_version_report() -> tuple[dict[str, Any], list[str]]:
+    """``info``'s version fields, and a warning when they disagree or the
+    installed version cannot be read.
+
+    ``server_version`` is the running one. In-process the hint names a Home
+    Assistant restart, as the component's own staleness warning does.
+    """
+    installed = detect_installed_version()
+    mismatch = version_mismatch(installed)
+    fields = {
+        "server_version": __version__,
+        "installed_version": installed,
+        "version_mismatch": mismatch,
+        "is_dev_build": is_dev_version(__version__),
+    }
+    if installed is None:
+        return fields, [
+            "Could not read the installed server version; the running and "
+            "installed versions were not compared."
+        ]
+    if not mismatch:
+        return fields, []
+    restart = "Home Assistant" if is_embedded() else "the server"
+    return fields, [
+        f"Running {__version__}, but {installed} is installed; restart "
+        f"{restart} to finish applying the update."
+    ]

{ha_mcp_dev-9.0.0.dev3101 → ha_mcp_dev-9.0.0.dev3105}/src/ha_mcp/tools/tools_bug_report.py

@@ -26,7 +26,7 @@ from ha_mcp._vendor.fastmcp import Context
 from ha_mcp._vendor.fastmcp.server.dependencies import get_http_headers
 from ha_mcp._vendor.fastmcp.tools import tool
 
-from .._version import get_version, is_embedded, is_running_in_addon
+from .._version import is_embedded, is_running_in_addon
 from ..client.supervisor_client import make_supervisor_httpx_client
 from ..config import Settings, get_global_settings
 from ..errors import create_validation_error
@@ -55,13 +55,14 @@ from .bug_report_templates import (
     _suggested_title,
 )
 from .coercion import ANSI_ESCAPE_RE, JSON_STRING_COERCION, parse_string_list_param
-from .component_api import get_component_caps
+from .component_api import InfoResult, read_component_version, read_info, webhook_auth
 from .helpers import (
     log_tool_usage,
     raise_tool_error,
     register_tool_methods,
 )
 from .response_helpers import project_fields
+from .server_version import detect_installed_version, version_mismatch
 from .tool_hints import read_only_hints
 
 logger = logging.getLogger(__name__)
@@ -197,23 +198,6 @@ def _detect_installation_method() -> str:
     return "unknown"
 
 
-def _detect_installed_version() -> str | None:
-    """Return the ha-mcp version installed ON DISK right now.
-
-    ``__version__`` is frozen when the process first imports ha_mcp, so after
-    an in-place update the running process keeps reporting the old version
-    while the disk already carries the new one. Reporting both (plus
-    ``version_mismatch``) turns a "which server am I talking to" hunt into a
-    single tool call.
-    """
-    try:
-        importlib.invalidate_caches()
-        return get_version()
-    except Exception as e:  # noqa: BLE001
-        logger.info("Installed-version probe failed: %s", e)
-        return None
-
-
 def _instance_identity() -> dict[str, Any]:
     """Return process identity (id, start time, uptime).
 
@@ -684,24 +668,23 @@ class BugReportTools:
     def __init__(self, client: Any) -> None:
         self._client = client
 
-    async def _detect_component_version(self) -> str | None:
+    async def _detect_component_version(self, info: InfoResult | None) -> str | None:
         """Read the ha_mcp_tools custom component's version, best-effort.
 
-        Prefers the shared cached capability probe (``get_component_caps`` — one
-        ``ha_mcp_tools/info`` round-trip per client): a component new enough to
-        answer it (1.1.0+) reports its version there, so the report reuses that
-        cached probe instead of a bespoke round-trip. A component in the
-        0.11.0-1.1.0 band has services but no ``info`` command (caps is None),
-        so it falls back to the ``get_caller_token`` bootstrap service, whose
-        response also carries the manifest version. Returns None when the
-        component is not installed or the call fails — the report path must
-        never break on it.
+        Prefers the report's fresh ``ha_mcp_tools/info`` read (``info``): the
+        cached capability snapshot would still hold the version running when the
+        client first probed, which outlives a component update on a server
+        running outside HA; the snapshot only stands in when the fresh read
+        fails. A component without a usable ``info`` (the 0.11.0-1.1.0 band has
+        services but no such command) falls back to the ``get_caller_token``
+        bootstrap service, whose response also carries the manifest version.
+        Returns None when the component is not installed or the call fails —
+        the report path must never break on it.
         """
-        # get_component_caps never raises (it caches/returns None on every
-        # failure mode), so no guard is needed around it.
-        caps = await get_component_caps(self._client)
-        if caps is not None:
-            return caps.component_version or None
+        # None means no usable info.
+        version = await read_component_version(self._client, info)
+        if version is not None:
+            return version or None
         try:
             resp = await self._client.call_service(
                 "ha_mcp_tools", "get_caller_token", {}, return_response=True
@@ -744,17 +727,15 @@ class BugReportTools:
             return "set up, but the component is pre-0.5.0 (update via HACS)"
         return "set up (ha_mcp_tools services registered)"
 
-    async def _detect_server_entry_status(self) -> str | None:
+    async def _detect_server_entry_status(self, info: InfoResult | None) -> str | None:
         """Describe the in-process "HA-MCP Server" entry state, best-effort.
 
-        Both parts of the custom component ship under the single
-        ``ha_mcp_tools`` domain, so "the component is installed" says nothing
-        about WHICH part is set up. The File & YAML tools part is covered by
-        the services probe; this one classifies the domain's config entries by
-        their flow-assigned titles to show whether the in-process server entry
-        exists — e.g. an add-on install that erroneously also added it (a
-        second, redundant server) becomes visible next to Installation Method.
-        Returns None when the probe fails; the report must never break on it.
+        Both parts of the component share the ``ha_mcp_tools`` domain; the File
+        & YAML part is covered by the services probe. Entries are classified by
+        flow-assigned title, so e.g. an add-on install that also added a redundant
+        server entry shows next to Installation Method. A recognized server entry
+        gets the webhook auth mode when the report's ``info`` read has one.
+        Returns None when ``config_entries/get`` fails; the report must not break.
         """
         try:
             response = await self._client.send_websocket_message(
@@ -770,7 +751,8 @@ class BugReportTools:
             return None
         server, unrecognized = _classify_component_entries(result)
         if server:
-            return ", ".join(server)
+            auth = webhook_auth(info)
+            return ", ".join(server) + (f", webhook auth: {auth}" if auth else "")
         if unrecognized:
             # A renamed entry cannot be classified by title — report it
             # rather than claiming the server entry is absent.
@@ -1016,17 +998,17 @@ class BugReportTools:
             else {}
         )
         user_agent = _http_user_agent()
-        installed_version = await asyncio.to_thread(_detect_installed_version)
-        component_version = await self._detect_component_version()
+        installed_version = await asyncio.to_thread(detect_installed_version)
+        # One read_info call, so the version and the auth mode share an answer.
+        component_info = await read_info(self._client)
+        component_version = await self._detect_component_version(component_info)
         tools_entry_status = await self._detect_tools_entry_status()
-        server_entry_status = await self._detect_server_entry_status()
+        server_entry_status = await self._detect_server_entry_status(component_info)
 
         diagnostic_info: dict[str, Any] = {
             "ha_mcp_version": __version__,
             "installed_version": installed_version,
-            "version_mismatch": bool(
-                installed_version and installed_version != __version__
-            ),
+            "version_mismatch": version_mismatch(installed_version),
             "component_version": component_version,
             "tools_entry_status": tools_entry_status,
             "server_entry_status": server_entry_status,

{ha_mcp_dev-9.0.0.dev3101 → ha_mcp_dev-9.0.0.dev3105}/src/ha_mcp/tools/tools_dev.py

@@ -22,7 +22,7 @@ from pydantic import Field
 from ha_mcp._vendor.fastmcp.exceptions import ToolError
 from ha_mcp._vendor.fastmcp.tools import tool
 
-from .._version import get_version, is_dev_version, is_embedded, is_running_in_addon
+from .._version import is_embedded, is_running_in_addon
 from ..client.rest_client import (
     HomeAssistantAPIError,
     HomeAssistantCommandError,
@@ -47,6 +47,7 @@ from .helpers import (
     raise_tool_error,
     register_tool_methods,
 )
+from .server_version import running_version_report
 from .tool_hints import write_hints
 
 logger = logging.getLogger(__name__)
@@ -1885,7 +1886,7 @@ class DevTools:
     async def _server_info(self) -> dict[str, Any]:
         from ..utils.data_paths import get_data_dir
 
-        version = await asyncio.to_thread(get_version)
+        versions, warnings = await asyncio.to_thread(running_version_report)
         if is_embedded():
             mode = "embedded"
         elif is_running_in_addon():
@@ -1893,13 +1894,11 @@ class DevTools:
         else:
             mode = "standalone"
         data: dict[str, Any] = {
-            "server_version": version,
-            "is_dev_build": is_dev_version(version),
+            **versions,
             "deployment_mode": mode,
             "python_version": sys.version.split()[0],
             "data_dir": str(get_data_dir()),
         }
-        warnings: list[str] = []
         try:
             ha_config = await self._client.get_config()
             data["ha_version"] = ha_config.get("version")