ha-mcp-dev 7.13.0.dev2002__tar.gz → 7.13.0.dev2005__tar.gz

{ha_mcp_dev-7.13.0.dev2002/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.13.0.dev2005}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.13.0.dev2002"
+version = "7.13.0.dev2005"
 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

{ha_mcp_dev-7.13.0.dev2002 → ha_mcp_dev-7.13.0.dev2005}/src/ha_mcp/__main__.py

@@ -25,6 +25,7 @@ import hashlib  # noqa: E402
 import ipaddress  # noqa: E402
 import logging  # noqa: E402
 import os  # noqa: E402
+import secrets  # noqa: E402
 import signal  # noqa: E402
 import stat  # noqa: E402
 import sys  # noqa: E402
@@ -1050,14 +1051,43 @@ def register_browser_landing(
     )
 
 
-def _log_settings_url(host: str, port: int, path: str) -> None:
+def _log_settings_url(
+    host: str,
+    port: int,
+    path: str,
+    *,
+    level: int = logging.INFO,
+    note_autogen: bool = False,
+    base_url: str | None = None,
+) -> None:
     """Log the web settings-UI URL at HTTP startup.
 
     Non-add-on operators (Docker / standalone) otherwise have no easy way to
     discover the settings page or its secret-path URL (issue #1458). When the
     bind host is the wildcard (``0.0.0.0`` / ``::``) the process can't know its
     externally reachable address, so we log a ``<host>`` placeholder.
+
+    ``level`` and ``note_autogen`` let the OAuth/OIDC dedicated-secret path log
+    an auto-generated URL at WARNING (visible even when internet-facing
+    deployments run at ``LOG_LEVEL=WARNING``), since that path rotates each
+    restart and is the only way for the admin to find it. ``base_url``, when
+    given (OAuth/OIDC modes, where it is the required public front), is used
+    verbatim instead of the local ``host:port`` — those deployments are reached
+    through a tunnel/proxy, not the bind address.
     """
+    if base_url:
+        url = f"{base_url.rstrip('/')}{path.rstrip('/')}/settings"
+        logger.log(
+            level,
+            f"Settings UI available at: {url}"
+            + (
+                "  [auto-generated, rotates each restart; "
+                "set MCP_SETTINGS_SECRET_PATH for a stable URL]"
+                if note_autogen
+                else ""
+            ),
+        )
+        return
     is_wildcard = host in ("0.0.0.0", "::")
     if is_wildcard:
         display_host = "<host>"
@@ -1068,7 +1098,158 @@ def _log_settings_url(host: str, port: int, path: str) -> None:
         display_host = host
     url = f"http://{display_host}:{port}{path.rstrip('/')}/settings"
     note = "  (substitute this server's address for <host>)" if is_wildcard else ""
-    logger.info(f"Settings UI available at: {url}{note}")
+    if note_autogen:
+        note += (
+            "  [auto-generated, rotates each restart; "
+            "set MCP_SETTINGS_SECRET_PATH for a stable URL]"
+        )
+    logger.log(level, f"Settings UI available at: {url}{note}")
+
+
+# Truthy / falsy env-var spellings for HA_MCP_DISABLE_SETTINGS_UI, matching the
+# parsing in stdio_settings_sidecar.py so the toggle behaves the same across
+# transports. A value in neither set is unrecognized: fail closed (disable) with
+# a warning, since this is a security kill switch and failing open on a typo
+# would leave an unauthenticated surface up.
+_SETTINGS_TRUTHY = {"1", "true", "yes", "on"}
+_SETTINGS_FALSY = {"0", "false", "no", "off", ""}
+
+
+def _settings_ui_disabled() -> bool:
+    """Return True when ``HA_MCP_DISABLE_SETTINGS_UI`` turns the settings UI off.
+
+    Honored by every long-lived HTTP transport (standard ``ha-mcp-web`` /
+    ``ha-mcp-sse`` as well as OAuth/OIDC) and, with matching semantics, by the
+    stdio sidecar. As a security kill switch it fails **closed**: any value that
+    is neither a recognized truthy nor falsy spelling disables the UI and warns
+    (so the operator learns why it vanished), rather than leaving an
+    unauthenticated surface up on a typo. Unset — or an explicit falsy value —
+    keeps the UI served.
+    """
+    disable = os.getenv("HA_MCP_DISABLE_SETTINGS_UI", "").strip().lower()
+    if disable in _SETTINGS_FALSY:
+        return False
+    if disable not in _SETTINGS_TRUTHY:
+        logger.warning(
+            "HA_MCP_DISABLE_SETTINGS_UI=%r is not a recognized on/off value; "
+            "disabling the settings UI (fail-closed). Use one of %s to disable, "
+            "or one of %s to keep it served.",
+            disable,
+            ", ".join(sorted(_SETTINGS_TRUTHY)),
+            ", ".join(sorted(s for s in _SETTINGS_FALSY if s)),
+        )
+    return True
+
+
+def _resolve_settings_secret_path() -> str | None:
+    """Resolve the dedicated settings-UI secret path for OAuth/OIDC modes.
+
+    These modes are internet-facing, so the settings UI must never sit at the
+    guessable default MCP path, where FastMCP custom routes bypass the OAuth /
+    OIDC auth middleware (GHSA-mx64-982r-65vg). It gets its own secret path:
+
+    - ``HA_MCP_DISABLE_SETTINGS_UI`` truthy → ``None`` (do not mount at all).
+    - ``MCP_SETTINGS_SECRET_PATH`` set → that path (stable across restarts).
+    - neither → an auto-generated ``/private_<token>`` path (logged at startup).
+
+    Returns the path to mount the settings UI under, or ``None`` when disabled.
+    """
+    if _settings_ui_disabled():
+        return None
+    explicit = os.getenv("MCP_SETTINGS_SECRET_PATH", "").strip()
+    if explicit:
+        return explicit
+    return "/private_" + secrets.token_urlsafe(16)
+
+
+def _register_settings_ui_secret_path(
+    mcp: "FastMCP",
+    server: "HomeAssistantSmartMCPServer",
+    host: str,
+    port: int,
+    mcp_path: str,
+    base_url: str,
+) -> None:
+    """Register the settings UI behind a dedicated secret path (OAuth/OIDC modes).
+
+    Standard HTTP mode serves the settings UI under the MCP secret path itself,
+    but in OAuth/OIDC modes that path is known to clients and OAuth/OIDC — not
+    path secrecy — is the auth boundary. So the settings UI gets its own secret
+    path from :func:`_resolve_settings_secret_path`, mounted with
+    ``advertise_prefix=False`` so the path is never returned to MCP clients via
+    ``ha_get_overview``. The admin learns the URL from the startup log.
+
+    ``mcp_path`` is the MCP endpoint path. The settings path is validated against
+    it and rejected (fail closed — UI not mounted) if it is malformed or reuses
+    the MCP path, either of which would re-expose the unauthenticated routes
+    (GHSA-mx64-982r-65vg).
+    """
+    from ha_mcp.settings_ui import register_settings_routes
+
+    settings_path = _resolve_settings_secret_path()
+    if settings_path is None:
+        logger.info(
+            "Settings UI disabled (HA_MCP_DISABLE_SETTINGS_UI); routes not registered."
+        )
+        return
+
+    explicit = bool(os.getenv("MCP_SETTINGS_SECRET_PATH", "").strip())
+
+    # An explicit path may be malformed; the auto-generated /private_<token> is
+    # always well-formed. Starlette asserts routes start with "/", so a missing
+    # leading slash would crash startup — normalize it (and tell the admin).
+    if not settings_path.startswith("/"):
+        logger.warning(
+            "MCP_SETTINGS_SECRET_PATH=%r has no leading '/'; normalizing to %r.",
+            settings_path,
+            "/" + settings_path,
+        )
+        settings_path = "/" + settings_path
+    if "{" in settings_path or "}" in settings_path:
+        # Starlette compiles {name} into a wildcard capture, so a braced path
+        # (an unrendered /private_{token} template, or a literal paste of the
+        # docs' /private_<token> convention) would mount the settings routes as a
+        # publicly-matching wildcard — the exact exposure this guards against.
+        logger.error(
+            "MCP_SETTINGS_SECRET_PATH (%r) contains route-template characters "
+            "('{{'/'}}'), which Starlette would turn into a wildcard route, "
+            "re-exposing the settings UI (GHSA-mx64-982r-65vg). Use a literal path "
+            "or unset it to auto-generate; settings UI not registered.",
+            settings_path,
+        )
+        return
+    if not settings_path.rstrip("/"):
+        logger.error(
+            "MCP_SETTINGS_SECRET_PATH must be a non-empty absolute path like "
+            "'/private_xxx'; settings UI not registered."
+        )
+        return
+    if settings_path.rstrip("/") == mcp_path.rstrip("/"):
+        logger.error(
+            "MCP_SETTINGS_SECRET_PATH (%r) must not equal the MCP path (%r): the "
+            "settings routes bypass OAuth/OIDC auth, so reusing the client-known MCP "
+            "path would re-expose them (GHSA-mx64-982r-65vg). Set a distinct path or "
+            "unset it to auto-generate; settings UI not registered.",
+            settings_path,
+            mcp_path,
+        )
+        return
+
+    register_settings_routes(
+        mcp, server, secret_path=settings_path, advertise_prefix=False
+    )
+    # Auto-generated paths rotate each restart and are the only way the admin can
+    # find the UI, so log them at WARNING to survive LOG_LEVEL=WARNING; an
+    # explicit path the admin already knows stays at INFO. OAuth/OIDC are fronted
+    # by MCP_BASE_URL (a public HTTPS tunnel/proxy), so log that, not host:port.
+    _log_settings_url(
+        host,
+        port,
+        settings_path,
+        level=logging.INFO if explicit else logging.WARNING,
+        note_autogen=not explicit,
+        base_url=base_url,
+    )
 
 
 def _run_http_server(transport: str, default_port: int = 8086) -> None:
@@ -1089,8 +1270,13 @@ def _run_http_server(transport: str, default_port: int = 8086) -> None:
     register_browser_landing(_get_mcp(), path, quiet_probe_log=transport != "sse")
     if _healthz_enabled():
         _register_healthz_route(_get_mcp())
-    register_settings_routes(_get_mcp(), _get_server(), secret_path=path)
-    _log_settings_url(host, port, path)
+    if _settings_ui_disabled():
+        logger.info(
+            "Settings UI disabled (HA_MCP_DISABLE_SETTINGS_UI); routes not registered."
+        )
+    else:
+        register_settings_routes(_get_mcp(), _get_server(), secret_path=path)
+        _log_settings_url(host, port, path)
 
     _run_entrypoint(
         _run_http_with_graceful_shutdown(transport, host, port, path),
@@ -1107,6 +1293,8 @@ def main_web() -> None:
     - MCP_HOST (optional, default: "0.0.0.0"; set 127.0.0.1 to restrict to loopback)
     - MCP_PORT (optional, default: 8086)
     - MCP_SECRET_PATH (optional, default: "/mcp")
+    - HA_MCP_DISABLE_SETTINGS_UI (optional): set truthy to not serve the web
+      settings UI at all
     """
     _setup_standard_mode()
     _run_http_server("http", default_port=8086)
@@ -1121,6 +1309,8 @@ def main_sse() -> None:
     - MCP_HOST (optional, default: "0.0.0.0"; set 127.0.0.1 to restrict to loopback)
     - MCP_PORT (optional, default: 8087)
     - MCP_SECRET_PATH (optional, default: "/mcp")
+    - HA_MCP_DISABLE_SETTINGS_UI (optional): set truthy to not serve the web
+      settings UI at all
     """
     _setup_standard_mode()
     _run_http_server("sse", default_port=8087)
@@ -1138,7 +1328,12 @@ def main_oauth() -> None:
     - MCP_BASE_URL (required): Public URL where this server is accessible (e.g., https://your-tunnel.com)
     - MCP_HOST (optional, default: "0.0.0.0"; set 127.0.0.1 to restrict to loopback)
     - MCP_PORT (optional, default: 8086)
-    - MCP_SECRET_PATH (optional, default: "/mcp")
+    - MCP_SECRET_PATH (optional, default: "/mcp") — the MCP endpoint path only;
+      the settings UI uses its own secret path (below), not this one
+    - MCP_SETTINGS_SECRET_PATH (optional): dedicated secret path for the web
+      settings UI. Auto-generated and logged at startup when unset.
+    - HA_MCP_DISABLE_SETTINGS_UI (optional): set truthy to not serve the
+      settings UI at all
     - LOG_LEVEL (optional, default: INFO)
 
     Note: HOMEASSISTANT_TOKEN is NOT required in this mode.
@@ -1243,10 +1438,9 @@ async def _run_oauth_server(
     if _healthz_enabled():
         _register_healthz_route(mcp)
 
-    from ha_mcp.settings_ui import register_settings_routes
-
-    register_settings_routes(mcp, _server, secret_path=path)
-    _log_settings_url(host, port, path)
+    # The settings UI must not sit at the OAuth-known MCP path (custom routes
+    # bypass the OAuth auth middleware); mount it behind a dedicated secret path.
+    _register_settings_ui_secret_path(mcp, _server, host, port, path, base_url)
 
     tools = await mcp.list_tools()
     logger.info(
@@ -1294,7 +1488,12 @@ def main_oidc() -> None:
     - MCP_HOST (optional, default: "0.0.0.0"; set 127.0.0.1 to restrict to loopback
       behind a same-host reverse proxy)
     - MCP_PORT (optional, default: 8086)
-    - MCP_SECRET_PATH (optional, default: "/mcp")
+    - MCP_SECRET_PATH (optional, default: "/mcp") — the MCP endpoint path only;
+      the settings UI uses its own secret path (below), not this one
+    - MCP_SETTINGS_SECRET_PATH (optional): dedicated secret path for the web
+      settings UI. Auto-generated and logged at startup when unset.
+    - HA_MCP_DISABLE_SETTINGS_UI (optional): set truthy to not serve the
+      settings UI at all
     - LOG_LEVEL (optional, default: INFO)
     """
     # Configure logging for OIDC mode (force=True needed since logging may already be configured)
@@ -1432,10 +1631,12 @@ async def _run_oidc_server(
     mcp_instance.auth = auth
 
     logger.info("Server created with OIDC authentication")
-    # Unlike standard/OAuth HTTP modes, OIDC mode intentionally registers no
-    # browser landing page and no settings-UI sidecar: an unauthenticated
-    # browser GET gets a bare 405 rather than a friendly page, and there is
-    # no settings UI surface here.
+    # OIDC mode intentionally registers no browser landing page: an
+    # unauthenticated browser GET gets a bare 405 rather than a friendly page.
+    # The settings UI *is* served, but only behind a dedicated secret path
+    # (never the OIDC-known MCP path, whose custom routes bypass the auth
+    # middleware — GHSA-mx64-982r-65vg).
+    _register_settings_ui_secret_path(mcp_instance, _server, host, port, path, base_url)
     if _healthz_enabled():
         _register_healthz_route(mcp_instance)
     logger.info(f"Starting OIDC-enabled MCP server at {base_url}{path}")

{ha_mcp_dev-7.13.0.dev2002 → ha_mcp_dev-7.13.0.dev2005}/src/ha_mcp/settings_ui/__init__.py

@@ -520,16 +520,34 @@ def get_http_settings_prefix() -> str | None:
     """Return the settings-UI mount prefix for HTTP transports, or None.
 
     Set by :func:`register_settings_routes` when the page is mounted on a
-    long-lived HTTP server. ``ha_get_overview`` reads it to hint at the
-    settings page when there is no stdio sidecar URL to hand the user.
+    long-lived HTTP server *and* advertising is enabled. ``ha_get_overview``
+    reads it to hint at the settings page when there is no stdio sidecar URL to
+    hand the user. It is None when the mount is deliberately not advertised
+    (OAuth/OIDC dedicated-secret mode) — use :func:`is_http_settings_mounted`,
+    not this, to tell HTTP from the stdio sidecar.
     """
     return _http_settings_prefix
 
 
+# Whether the settings UI is served over HTTP (add-on / Docker / OAuth / OIDC)
+# as opposed to the stdio sidecar. Distinct from _http_settings_prefix, which is
+# the *advertised* URL and is None when a mount is deliberately hidden from MCP
+# clients (advertise_prefix=False). Consumers that only need "is this stdio?"
+# must read this, not the prefix (GHSA-mx64-982r-65vg fix left the prefix None
+# on a real HTTP mount).
+_http_settings_mounted: bool = False
+
+
+def is_http_settings_mounted() -> bool:
+    """Return True when the settings UI is HTTP-mounted (not the stdio sidecar)."""
+    return _http_settings_mounted
+
+
 def register_settings_routes(
     mcp: FastMCP,
     server: HomeAssistantSmartMCPServer,
     secret_path: str = "",
+    advertise_prefix: bool = True,
 ) -> None:
     """Register the settings UI HTTP routes on the FastMCP Starlette app.
 
@@ -550,9 +568,27 @@ def register_settings_routes(
             ``/mcp``). Required for non-add-on HTTP modes; if empty in
             non-add-on mode, the function logs a warning and registers
             nothing rather than expose the routes publicly.
+        advertise_prefix: When True (default), record the secret-path mount in
+            ``_http_settings_prefix`` so ``ha_get_overview`` can hint at the
+            settings URL. OAuth/OIDC modes pass False: there the settings UI
+            sits under a *dedicated* secret path that must never be handed to
+            MCP clients (GHSA-mx64-982r-65vg), so the mount happens but the
+            prefix is not recorded.
     """
     handlers = build_settings_handlers(server)
     secret_prefix = secret_path.rstrip("/") if secret_path else ""
+    if secret_prefix and ("{" in secret_prefix or "}" in secret_prefix):
+        # Starlette compiles {name} into a [^/]+ wildcard capture, so a braced
+        # secret path (e.g. an unrendered /private_{token} template) would mount
+        # these routes at a publicly-matching wildcard. Drop the secret mount
+        # rather than expose it (GHSA-mx64-982r-65vg); the add-on root mount below
+        # is unaffected.
+        logger.error(
+            "settings UI secret path %r contains route-template characters "
+            "('{{'/'}}'); not mounting under it (it would become a wildcard route).",
+            secret_prefix,
+        )
+        secret_prefix = ""
     is_addon = is_running_in_addon()
 
     if not is_addon and not secret_prefix:
@@ -563,6 +599,12 @@ def register_settings_routes(
         )
         return
 
+    # Past this point at least one HTTP mount happens (add-on root and/or the
+    # secret path). Record that so consumers can distinguish HTTP from the stdio
+    # sidecar even when the prefix itself is not advertised (advertise_prefix=False).
+    global _http_settings_mounted
+    _http_settings_mounted = True
+
     # Every route this function mounts except the add-on-only root mount is defined
     # once in this table and mounted under each active prefix below: at root
     # in add-on mode (so HA ingress can proxy localhost:9583/), and under the
@@ -636,7 +678,10 @@ def register_settings_routes(
         # need the same secret to reach the UI as they do for the MCP
         # endpoint.
         _mount(secret_prefix)
-        # Record the mount so ha_get_overview can point users at the settings
-        # page in HTTP transports that have no stdio sidecar URL file (#1458).
-        global _http_settings_prefix
-        _http_settings_prefix = secret_prefix
+        if advertise_prefix:
+            # Record the mount so ha_get_overview can point users at the
+            # settings page in HTTP transports that have no stdio sidecar URL
+            # file (#1458). Suppressed in OAuth/OIDC modes, where the dedicated
+            # secret path must not leak to MCP clients (GHSA-mx64-982r-65vg).
+            global _http_settings_prefix
+            _http_settings_prefix = secret_prefix

{ha_mcp_dev-7.13.0.dev2002 → ha_mcp_dev-7.13.0.dev2005}/src/ha_mcp/settings_ui/_handlers_advanced.py

@@ -136,7 +136,7 @@ async def _get_advanced_settings(
     and saves route through Supervisor so the add-on Configuration tab and
     the web UI share state.
     """
-    from ha_mcp.settings_ui import get_http_settings_prefix
+    from ha_mcp.settings_ui import is_http_settings_mounted
 
     from ..config import ADVANCED_SETTINGS_FIELDS, _read_feature_flag_override_file
 
@@ -172,7 +172,7 @@ async def _get_advanced_settings(
         {
             "fields": fields,
             "is_addon": is_running_in_addon(),
-            "is_stdio": get_http_settings_prefix() is None,
+            "is_stdio": not is_http_settings_mounted(),
         }
     )
 

{ha_mcp_dev-7.13.0.dev2002 → ha_mcp_dev-7.13.0.dev2005}/src/ha_mcp/stdio_settings_sidecar.py

@@ -61,6 +61,7 @@ logger = logging.getLogger(__name__)
 # importing from the tools subpackage because this module is loaded
 # during early stdio startup, before any tool code is touched.
 _TRUTHY = {"1", "true", "yes", "on"}
+_FALSY = {"0", "false", "no", "off", ""}
 
 
 def _sidecar_dir() -> Path:
@@ -109,7 +110,18 @@ def read_sidecar_url() -> str | None:
 
 def _is_disabled() -> bool:
     """Check whether the sidecar should be skipped."""
-    if os.environ.get("HA_MCP_DISABLE_SETTINGS_UI", "").strip().lower() in _TRUTHY:
+    val = os.environ.get("HA_MCP_DISABLE_SETTINGS_UI", "").strip().lower()
+    if val in _TRUTHY:
+        return True
+    if val and val not in _FALSY:
+        # Fail closed on an unrecognized value (same semantics as the HTTP
+        # transports' _settings_ui_disabled), and warn so the operator sees why
+        # the settings UI never came up.
+        logger.warning(
+            "HA_MCP_DISABLE_SETTINGS_UI=%r is not a recognized on/off value; "
+            "skipping the settings-UI sidecar (fail-closed).",
+            val,
+        )
         return True
     return _disabled_sentinel().exists()
 

{ha_mcp_dev-7.13.0.dev2002 → ha_mcp_dev-7.13.0.dev2005}/src/ha_mcp/tools/tools_bug_report.py

@@ -443,15 +443,24 @@ def _sanitize_log_text(text: str) -> str:
     # configured value (catches custom paths) and the generated
     # ``/private_<token>`` convention. Only bug-report output is scrubbed here;
     # the raw logs this text is copied from are left intact.
-    configured = os.getenv("MCP_SECRET_PATH", "").rstrip("/")
-    if configured and configured != "/mcp":
-        # Anchor on a path-segment boundary so a short/substring-prone configured
-        # value (e.g. "/ha") cannot corrupt unrelated text (e.g. "/happy").
-        text = re.sub(
-            re.escape(configured) + r"(?![A-Za-z0-9_-])",
-            "[REDACTED_SECRET_PATH]",
-            text,
-        )
+    # The dedicated settings-UI secret path (OAuth/OIDC) is a second secret whose
+    # leak grants the same unauthenticated settings access, so redact a custom
+    # value the same way. The auto-generated /private_<token> form is caught by
+    # the generic pattern below.
+    for env_name in ("MCP_SECRET_PATH", "MCP_SETTINGS_SECRET_PATH"):
+        # Strip before rstrip: the resolver strips MCP_SETTINGS_SECRET_PATH before
+        # mounting, so a whitespace-bearing value mounts at the stripped path — the
+        # redaction pattern must match that, not the raw value (GHSA-mx64-982r-65vg).
+        configured = os.getenv(env_name, "").strip().rstrip("/")
+        if configured and configured != "/mcp":
+            # Anchor on a path-segment boundary so a short/substring-prone
+            # configured value (e.g. "/ha") cannot corrupt unrelated text
+            # (e.g. "/happy").
+            text = re.sub(
+                re.escape(configured) + r"(?![A-Za-z0-9_-])",
+                "[REDACTED_SECRET_PATH]",
+                text,
+            )
     text = re.sub(r"/private_[A-Za-z0-9_-]+", "[REDACTED_SECRET_PATH]", text)
     return text
 

{ha_mcp_dev-7.13.0.dev2002 → ha_mcp_dev-7.13.0.dev2005}/src/ha_mcp/tools/tools_search.py

@@ -3449,7 +3449,11 @@ class SearchTools:
                 )
                 result["repair_count"] = len(visible_issues)
                 if not include_dismissed_repairs_bool:
-                    dismissed_count = len(all_issues) - len(visible_issues)
+                    # Baseline excludes inactive registry stubs so they are
+                    # not miscounted as dismissed.
+                    dismissed_count = len(
+                        filter_active_repairs(all_issues, include_dismissed=True)
+                    ) - len(visible_issues)
                     if dismissed_count:
                         result["dismissed_repair_count"] = dismissed_count
                 result["repairs"] = [project_repair_fields(r) for r in visible_issues]

{ha_mcp_dev-7.13.0.dev2002 → ha_mcp_dev-7.13.0.dev2005}/src/ha_mcp/tools/tools_system.py

@@ -1225,7 +1225,11 @@ class SystemTools:
                     "count": len(visible_issues),
                 }
                 if not include_dismissed:
-                    dismissed_count = len(all_issues) - len(visible_issues)
+                    # Baseline excludes inactive registry stubs so they are
+                    # not miscounted as dismissed.
+                    dismissed_count = len(
+                        filter_active_repairs(all_issues, include_dismissed=True)
+                    ) - len(visible_issues)
                     if dismissed_count:
                         repairs["dismissed_count"] = dismissed_count
             else:

{ha_mcp_dev-7.13.0.dev2002 → ha_mcp_dev-7.13.0.dev2005}/src/ha_mcp/tools/util_helpers.py

@@ -567,10 +567,15 @@ def filter_active_repairs(
     Repairs UI hides ignored ones by default). Mirror that UI default so
     overview / system-health responses don't surface repairs the user has
     already dismissed.
+
+    Entries with ``active=False`` are always dropped, regardless of
+    ``include_dismissed``: HA core's ``ws_list_issues`` never emits them
+    (the issue registry keeps inactive stubs for every non-persistent issue
+    it has ever stored), but the component's raw registry dump does.
     """
     if include_dismissed:
-        return list(issues)
-    return [r for r in issues if not r.get("ignored")]
+        return [r for r in issues if r.get("active") is not False]
+    return [r for r in issues if r.get("active") is not False and not r.get("ignored")]
 
 
 def project_repair_fields(issue: dict[str, Any]) -> dict[str, Any]:

{ha_mcp_dev-7.13.0.dev2002 → ha_mcp_dev-7.13.0.dev2005/src/ha_mcp_dev.egg-info}/PKG-INFO

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