ha-mcp-dev 7.4.1.dev439__tar.gz → 7.4.1.dev440__tar.gz

{ha_mcp_dev-7.4.1.dev439/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.4.1.dev440}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.4.1.dev439"
+version = "7.4.1.dev440"
 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.4.1.dev439 → ha_mcp_dev-7.4.1.dev440}/src/ha_mcp/client/rest_client.py

@@ -5,11 +5,13 @@ Home Assistant HTTP client with authentication and error handling.
 import asyncio
 import json
 import logging
+import os
 import ssl
 from typing import Any
 
 import httpx
 
+from .._version import is_running_in_addon
 from ..config import get_global_settings
 
 
@@ -26,6 +28,7 @@ def _is_ssl_error(exc: BaseException) -> bool:
         cur = cur.__cause__ or cur.__context__
     return False
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -33,17 +36,14 @@ class HomeAssistantError(Exception):
     """Base exception for Home Assistant API errors."""
 
 
-
 class HomeAssistantConnectionError(HomeAssistantError):
     """Connection error to Home Assistant."""
 
 
-
 class HomeAssistantAuthError(HomeAssistantError):
     """Authentication error with Home Assistant."""
 
 
-
 class HomeAssistantAPIError(HomeAssistantError):
     """API error from Home Assistant."""
 
@@ -125,7 +125,7 @@ class HomeAssistantClient:
 
         logger.info(f"Initialized Home Assistant client for {self.base_url}")
 
-    async def __aenter__(self) -> 'HomeAssistantClient':
+    async def __aenter__(self) -> "HomeAssistantClient":
         """Async context manager entry."""
         return self
 
@@ -192,7 +192,9 @@ class HomeAssistantClient:
         except httpx.HTTPError as e:
             raise HomeAssistantConnectionError(f"HTTP error: {e}") from e
 
-    async def _request(self, method: str, endpoint: str, **kwargs: Any) -> dict[str, Any]:
+    async def _request(
+        self, method: str, endpoint: str, **kwargs: Any
+    ) -> dict[str, Any]:
         """
         Make authenticated request to Home Assistant API and parse JSON body.
 
@@ -267,8 +269,11 @@ class HomeAssistantClient:
         return await self._request("POST", f"/states/{entity_id}", json=payload)
 
     async def call_service(
-        self, domain: str, service: str, data: dict[str, Any] | None = None,
-        return_response: bool = False
+        self,
+        domain: str,
+        service: str,
+        data: dict[str, Any] | None = None,
+        return_response: bool = False,
     ) -> list[dict[str, Any]] | dict[str, Any]:
         """
         Call Home Assistant service.
@@ -284,7 +289,9 @@ class HomeAssistantClient:
             Service response data - list of affected states normally, or dict with
             service response if return_response=True
         """
-        logger.debug(f"Calling service {domain}.{service} (return_response={return_response})")
+        logger.debug(
+            f"Calling service {domain}.{service} (return_response={return_response})"
+        )
 
         payload = data or {}
 
@@ -294,7 +301,10 @@ class HomeAssistantClient:
             params["return_response"] = "true"
 
         result = await self._request(
-            "POST", f"/services/{domain}/{service}", json=payload, params=params if params else None
+            "POST",
+            f"/services/{domain}/{service}",
+            json=payload,
+            params=params if params else None,
         )
 
         # When return_response is True, HA returns a dict with service_response key
@@ -366,7 +376,9 @@ class HomeAssistantClient:
         Returns:
             Logbook entries
         """
-        logger.debug(f"Fetching logbook entries for entity: {entity_id}, start: {start_time}, end: {end_time}")
+        logger.debug(
+            f"Fetching logbook entries for entity: {entity_id}, start: {start_time}, end: {end_time}"
+        )
 
         # Build endpoint - start_time goes in URL path if provided
         if start_time:
@@ -428,27 +440,66 @@ class HomeAssistantClient:
         return await self._request("POST", "/config/core/check_config")
 
     async def get_error_log(self) -> str:
-        """Get Home Assistant error log."""
-        logger.debug("Fetching error log")
+        """Get Home Assistant error log.
+
+        Branch on ``is_running_in_addon()``: inside the add-on container,
+        HA Core's ``bootstrap.py`` sets ``err_log_path = None`` when the
+        ``SUPERVISOR`` env var is present, so ``hass.data[DATA_LOGGING]``
+        is never populated and the ``APIErrorLog`` view is not registered
+        — ``/api/error_log`` returns 404 by-design on HA OS / Supervised.
+        Route to ``_supervisor_logs_get("core")`` on this branch: same
+        content (HA Core's container log) via a different transport
+        (Supervisor REST). On non-addon installs keep the
+        ``/api/error_log`` proxy path.
+
+        Same root cause and fix shape as ``get_addon_logs`` — see #1116.
+
+        Raises:
+            HomeAssistantAuthError: 401, or empty ``SUPERVISOR_TOKEN`` on
+                the addon branch.
+            HomeAssistantAPIError: 403 (role too low — addon needs
+                ``hassio_role: manager``), 404, other non-2xx.
+            HomeAssistantConnectionError: Network, timeout, or transport
+                error.
+        """
+        if is_running_in_addon():
+            logger.debug("Fetching error log via Supervisor direct (core service)")
+            return await self._supervisor_logs_get("core")
+
+        logger.debug("Fetching error log via HA Core proxy")
         response = await self._request("GET", "/error_log")
         return response if isinstance(response, str) else str(response)
 
     async def get_addon_logs(self, slug: str) -> str:
-        """Fetch an add-on's container logs via HA Core's Supervisor REST proxy.
+        """Fetch an add-on's container logs.
+
+        Branch on ``is_running_in_addon()`` (which keys off ``SUPERVISOR_TOKEN``
+        in env): inside the add-on container goes directly to the Supervisor
+        REST API at ``http://supervisor/addons/{slug}/logs`` with the
+        Supervisor token. The HA Core proxy at
+        ``/api/hassio/addons/{slug}/logs`` rejects this token+path combination
+        on current HA Core releases (see #1116) — the direct path bypasses
+        HA Core entirely and is the documented Supervisor contract.
 
-        Uses `/api/hassio/addons/{slug}/logs`, which HA Core proxies to
-        Supervisor and returns as `text/plain`. This avoids the
-        `supervisor/api` websocket path that tries to JSON-decode the text
-        body and always fails (see #950).
+        On non-addon installs (Docker, pyinstaller, pip pointing at a normal
+        HA URL), falls back to the HA Core proxy path. That path requires an
+        admin LLA but works fine when not invoked from the add-on container.
+
+        Both branches return ``text/plain`` log content.
 
         Raises:
-            HomeAssistantAuthError: 401 from HA Core.
-            HomeAssistantAPIError: Non-2xx response (e.g. 404 unknown slug,
-                400 addon not installed). `status_code` is set so callers
-                can map to specific suggestions.
+            HomeAssistantAuthError: 401 response, or ``SUPERVISOR_TOKEN`` empty
+                at call time on the addon branch.
+            HomeAssistantAPIError: 403 (role too low — addon needs hassio_role
+                ``manager``), 404 (unknown slug), or other non-2xx. The
+                ``status_code`` attribute lets callers map to specific
+                suggestions.
             HomeAssistantConnectionError: Network, timeout, or transport error.
         """
-        logger.debug(f"Fetching addon logs for slug={slug}")
+        if is_running_in_addon():
+            return await self._get_addon_logs_via_supervisor(slug)
+
+        logger.debug(f"Fetching addon logs for slug={slug} via HA Core proxy")
         response = await self._raw_request(
             "GET",
             f"/hassio/addons/{slug}/logs",
@@ -456,6 +507,146 @@ class HomeAssistantClient:
         )
         return response.text
 
+    async def _supervisor_logs_get(self, path: str) -> str:
+        """Fetch ``text/plain`` logs from a Supervisor REST endpoint.
+
+        ``path`` is everything between ``http://supervisor/`` and ``/logs``:
+
+        - ``"addons/<slug>"`` for add-on container logs
+        - ``"<service>"`` (where service ∈ {supervisor, host, core, dns, audio,
+          multicast, observer}) for system-service logs
+
+        Bypasses ``HomeAssistantClient.httpx_client`` because the Supervisor
+        endpoint uses a different base URL (``http://supervisor``) and a
+        different token (``SUPERVISOR_TOKEN``) than HA Core REST. Both
+        endpoints require the addon's ``hassio_role`` to be ``manager`` (not
+        ``default``); a ``default`` role gets a 403 here — see #1116.
+
+        Raises:
+            HomeAssistantAuthError: ``SUPERVISOR_TOKEN`` absent at call time,
+                or 401 from Supervisor.
+            HomeAssistantAPIError: 403 (role too low — distinct branch with
+                role hint), 404, other 4xx/5xx. Tries to parse Supervisor's
+                ``{"result":"error","message":"..."}`` JSON envelope before
+                falling back to text body / reason phrase / placeholder.
+            HomeAssistantConnectionError: Timeout or transport error, with
+                distinct messages so callers can tell them apart.
+        """
+        token = os.environ.get("SUPERVISOR_TOKEN", "")
+        if not token:
+            # The is_running_in_addon() gate already keys off SUPERVISOR_TOKEN
+            # being truthy, so a direct caller landing here without one is a
+            # detection/config mismatch — fail-fast with a distinct message
+            # so operators don't read it as "token rejected".
+            raise HomeAssistantAuthError(
+                f"Supervisor token absent at call time for /{path}/logs "
+                "(addon-mode gate fired but SUPERVISOR_TOKEN env var not set)"
+            )
+
+        url = f"http://supervisor/{path}/logs"
+        logger.debug("Fetching %s via Supervisor direct", url)
+
+        try:
+            async with httpx.AsyncClient(
+                timeout=httpx.Timeout(self.timeout),
+                # `verify` is a no-op for plain http://supervisor, but kept
+                # for symmetry with the other two direct-Supervisor httpx
+                # clients (#1128 establishes the 3-site convention).
+                verify=self.verify_ssl,
+            ) as client:
+                response = await client.get(
+                    url,
+                    headers={
+                        "Authorization": f"Bearer {token}",
+                        "Accept": "text/plain",
+                    },
+                )
+        except httpx.TimeoutException as e:
+            raise HomeAssistantConnectionError(
+                f"Timeout fetching /{path}/logs from Supervisor: {e}"
+            ) from e
+        except httpx.HTTPError as e:
+            raise HomeAssistantConnectionError(
+                f"Transport error fetching /{path}/logs from Supervisor: {e}"
+            ) from e
+
+        if response.status_code == 401:
+            raise HomeAssistantAuthError(f"Invalid Supervisor token for /{path}/logs")
+        if response.status_code == 403:
+            # Distinct from 401: token is valid but addon's hassio_role isn't
+            # high enough. Most-likely cause for this exact endpoint at the
+            # time #1116 surfaced (default → manager bump in addon config.yaml
+            # is the same-PR companion fix).
+            logger.warning(
+                "Supervisor returned 403 for /%s/logs — addon hassio_role may "
+                "be too low (need 'manager')",
+                path,
+            )
+            raise HomeAssistantAPIError(
+                f"Supervisor forbids /{path}/logs (403) — addon's hassio_role "
+                "may be 'default'; need 'manager' or higher",
+                status_code=403,
+                response_data={"path": path},
+            )
+        if response.status_code >= 400:
+            text_body = response.text
+            # Supervisor returns {"result":"error","message":"..."} JSON on
+            # some 4xx paths. Try parsing that first so the user sees the
+            # human message instead of a JSON blob; then fall back to the
+            # text body, then reason_phrase, then a placeholder.
+            message = ""
+            try:
+                envelope = json.loads(text_body) if text_body else None
+                if isinstance(envelope, dict):
+                    msg = envelope.get("message")
+                    if isinstance(msg, str) and msg:
+                        message = msg
+            except json.JSONDecodeError:
+                pass
+            if not message:
+                message = text_body.strip() or response.reason_phrase or "<empty body>"
+            logger.warning(
+                "Supervisor returned %s for /%s/logs: %s",
+                response.status_code,
+                path,
+                message,
+            )
+            raise HomeAssistantAPIError(
+                f"API error: {response.status_code} - {message}",
+                status_code=response.status_code,
+                response_data={"message": text_body, "path": path},
+            )
+        return response.text
+
+    async def _get_addon_logs_via_supervisor(self, slug: str) -> str:
+        """Fetch add-on container logs directly from Supervisor's REST API.
+
+        Distinct from ``tools_bug_report._fetch_addon_logs``: that helper is
+        hardcoded to ``/addons/self/logs`` and silently swallows failures
+        (it's an aux-data fetch for bug reports, fine to skip on error). This
+        helper takes arbitrary slugs and surfaces failures as exceptions
+        because callers (``ha_get_logs(source="supervisor", slug=...)``) need
+        them. Both endpoints require ``hassio_role: manager``.
+
+        Delegates to ``_supervisor_logs_get`` so error handling stays in
+        lockstep with ``_get_system_service_logs``.
+        """
+        return await self._supervisor_logs_get(f"addons/{slug}")
+
+    async def _get_system_service_logs(self, service: str) -> str:
+        """Fetch HA system-service logs directly from Supervisor's REST API.
+
+        Hits ``http://supervisor/{service}/logs``. ``service`` must be one of
+        the seven Supervisor-managed services: ``supervisor``, ``host``,
+        ``core``, ``dns``, ``audio``, ``multicast``, ``observer``. Caller is
+        responsible for validating ``service`` against the allowed set; this
+        helper does no validation and will raise ``HomeAssistantAPIError`` on
+        any unknown path (404 from Supervisor).
+
+        Requires ``hassio_role: manager`` like the addon-logs path.
+        """
+        return await self._supervisor_logs_get(service)
+
     async def test_connection(self) -> tuple[bool, str | None]:
         """
         Test connection to Home Assistant.
@@ -920,7 +1111,9 @@ class HomeAssistantClient:
                         await asyncio.sleep(retry_delay)
                         continue
                     else:
-                        logger.error(f"WebSocket 403 error after {max_retries} attempts: {error_str}")
+                        logger.error(
+                            f"WebSocket 403 error after {max_retries} attempts: {error_str}"
+                        )
                         return {
                             "success": False,
                             "error": f"WebSocket request blocked (403 Forbidden): {error_str}",
@@ -1018,7 +1211,7 @@ class HomeAssistantClient:
         except Exception:
             logger.debug(
                 f"Entity registry lookup failed for {entity_id}, using bare id: {bare_id}",
-                exc_info=True # Log full traceback for better debugging
+                exc_info=True,  # Log full traceback for better debugging
             )
         return bare_id
 

{ha_mcp_dev-7.4.1.dev439 → ha_mcp_dev-7.4.1.dev440}/src/ha_mcp/tools/tools_utility.py

@@ -26,7 +26,24 @@ logger = logging.getLogger(__name__)
 
 # Fields to keep in compact logbook mode (strips attribute dictionaries
 # and other bulky fields that can cause context exhaustion — see #683)
-COMPACT_LOGBOOK_FIELDS = {"when", "entity_id", "state", "name", "message", "domain", "context_id", "source"}
+COMPACT_LOGBOOK_FIELDS = {
+    "when",
+    "entity_id",
+    "state",
+    "name",
+    "message",
+    "domain",
+    "context_id",
+    "source",
+}
+
+
+# Supervisor-managed system services exposed via /<slug>/logs. Stable set
+# in HA Core; if Supervisor adds e.g. /cli/logs in a future release, extend
+# here. See #1116.
+SYSTEM_SERVICE_SLUGS = frozenset(
+    {"supervisor", "host", "core", "dns", "audio", "multicast", "observer"}
+)
 
 
 def _compact_logbook_entries(entries: list[Any]) -> list[dict[str, Any]]:
@@ -57,15 +74,24 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
     ) -> int:
         """Coerce and validate a limit parameter, raising a structured tool error on failure."""
         try:
-            return coerce_int_param(limit, param_name="limit", default=default, min_value=1, max_value=MAX_LIMIT)
+            return coerce_int_param(
+                limit,
+                param_name="limit",
+                default=default,
+                min_value=1,
+                max_value=MAX_LIMIT,
+            )
         except ValueError as e:
             raise_tool_error(
                 create_error_response(
                     ErrorCode.VALIDATION_INVALID_PARAMETER,
                     str(e),
-                    suggestions=[f"Provide limit as an integer (e.g., {suggestion_example})"],
+                    suggestions=[
+                        f"Provide limit as an integer (e.g., {suggestion_example})"
+                    ],
                 )
             )
+
     # Regex to match log level at the start of a log line
     _LOG_LEVEL_RE = re.compile(
         r"(?:^|\s)(DEBUG|INFO|WARNING|ERROR|CRITICAL)(?:\s|:|\])", re.IGNORECASE
@@ -80,11 +106,18 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
             "idempotentHint": True,
             "readOnlyHint": True,
             "title": "Get Logs",
-        }
+        },
     )
     @log_tool_usage
     async def ha_get_logs(
-        source: Literal["logbook", "system", "error_log", "supervisor", "logger"] = "logbook",
+        source: Literal[
+            "logbook",
+            "system",
+            "error_log",
+            "supervisor",
+            "system_service",
+            "logger",
+        ] = "logbook",
         # Shared parameters
         limit: int | str | None = None,
         search: str | None = None,
@@ -96,7 +129,7 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
         compact: bool | str = True,
         # System/error_log-specific
         level: str | None = None,
-        # Supervisor-specific
+        # Supervisor + system_service-specific (different namespaces — see below)
         slug: str | None = None,
     ) -> dict[str, Any]:
         """
@@ -106,13 +139,19 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
         - "logbook" (default): Entity state change history with pagination
         - "system": Structured system log entries (errors, warnings) via system_log/list
         - "error_log": Raw home-assistant.log text
-        - "supervisor": Add-on container logs (requires slug parameter)
+        - "supervisor": Add-on container logs (requires slug = add-on slug)
+        - "system_service": HA-Supervisor-managed system service logs (requires
+          slug ∈ {supervisor, host, core, dns, audio, multicast, observer})
         - "logger": Effective log level per integration via logger/log_info (confirms logger.set_level changes took effect)
 
         **Shared params:** limit, search (keyword filter on entries/lines; matches integration domain for source='logger')
         **Logbook params:** hours_back, entity_id, end_time, offset, compact (default True — strips attribute dicts to save context)
         **System/error_log params:** level (ERROR, WARNING, INFO, DEBUG)
-        **Supervisor params:** slug (add-on slug, e.g. "core_mosquitto")
+        **Supervisor params:** slug = add-on slug, e.g. "core_mosquitto" (use
+            ha_get_addon() to list installed slugs)
+        **System-service params:** slug = service name. The slug "supervisor"
+            here means the Supervisor service's own logs, NOT an add-on with
+            that name — the source param disambiguates.
         """
 
         # Validate level if provided
@@ -131,16 +170,28 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
         # Collect warnings about source-incompatible parameters
         warnings: list[str] = []
         if source != "logbook" and any(p is not None for p in [entity_id, end_time]):
-            ignored = [p for p, v in [("entity_id", entity_id), ("end_time", end_time)] if v is not None]
+            ignored = [
+                p
+                for p, v in [("entity_id", entity_id), ("end_time", end_time)]
+                if v is not None
+            ]
             warnings.append(
                 f"Parameters {', '.join(ignored)} only apply to source='logbook'; "
                 f"ignored for source='{source}'"
             )
-        if source in ("logbook", "logger", "supervisor") and level is not None:
+        if (
+            source in ("logbook", "logger", "supervisor", "system_service")
+            and level is not None
+        ):
             warnings.append(
                 "Parameter 'level' only applies to source='system' or 'error_log'; "
                 f"ignored for source='{source}'"
             )
+        if source not in ("supervisor", "system_service") and slug is not None:
+            warnings.append(
+                "Parameter 'slug' only applies to source='supervisor' or "
+                f"'system_service'; ignored for source='{source}'"
+            )
 
         # --- source="logbook" ---
         if source == "logbook":
@@ -186,6 +237,41 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 result["warnings"] = warnings
             return result
 
+        # --- source="system_service" ---
+        if source == "system_service":
+            if not slug:
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.VALIDATION_INVALID_PARAMETER,
+                        "The 'slug' parameter is required for source='system_service'",
+                        suggestions=[
+                            "Provide a service name, e.g. slug='supervisor' "
+                            f"(allowed: {', '.join(sorted(SYSTEM_SERVICE_SLUGS))})",
+                        ],
+                    )
+                )
+            if slug not in SYSTEM_SERVICE_SLUGS:
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.VALIDATION_INVALID_PARAMETER,
+                        f"Invalid system_service slug '{slug}'. Must be one of: "
+                        f"{', '.join(sorted(SYSTEM_SERVICE_SLUGS))}",
+                        suggestions=[
+                            "Pick a valid service name (e.g. 'supervisor', 'host')",
+                            "For add-on container logs use source='supervisor' with "
+                            "the add-on slug instead",
+                        ],
+                    )
+                )
+            result = await _get_system_service_log(
+                service=slug,
+                limit=limit,
+                search=search,
+            )
+            if warnings:
+                result["warnings"] = warnings
+            return result
+
         # --- source="supervisor" ---
         # source == "supervisor" (Literal type guarantees this)
         if not slug:
@@ -462,7 +548,9 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
         level: str | None = None,
     ) -> dict[str, Any]:
         """Fetch raw error log text from home-assistant.log."""
-        effective_limit = _coerce_limit(limit, default=DEFAULT_LOG_LIMIT, suggestion_example="100")
+        effective_limit = _coerce_limit(
+            limit, default=DEFAULT_LOG_LIMIT, suggestion_example="100"
+        )
 
         try:
             raw_log = await client.get_error_log()
@@ -572,7 +660,8 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
             if search:
                 search_lower = search.lower()
                 loggers = [
-                    entry for entry in loggers
+                    entry
+                    for entry in loggers
                     if search_lower in entry["domain"].lower()
                 ]
                 filters_applied["search"] = search
@@ -619,14 +708,18 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
         limit: int | str | None = None,
         search: str | None = None,
     ) -> dict[str, Any]:
-        """Fetch add-on container logs via HA Core's Supervisor REST proxy.
-
-        Routes through `/api/hassio/addons/{slug}/logs` (returned as
-        text/plain) instead of the `supervisor/api` websocket path, which
-        always fails because HA Core's proxy tries to JSON-decode the
-        text body. See #950.
+        """Fetch add-on container logs.
+
+        Delegates to ``HomeAssistantClient.get_addon_logs`` which branches on
+        ``is_running_in_addon()``: inside the add-on container hits Supervisor
+        directly at ``http://supervisor/addons/<slug>/logs`` (the HA-Core
+        proxy at ``/api/hassio/addons/<slug>/logs`` rejects the Supervisor
+        token there — see #1116); on non-addon installs falls back to the
+        HA-Core proxy. Both paths return ``text/plain``.
         """
-        effective_limit = _coerce_limit(limit, default=DEFAULT_LOG_LIMIT, suggestion_example="100")
+        effective_limit = _coerce_limit(
+            limit, default=DEFAULT_LOG_LIMIT, suggestion_example="100"
+        )
 
         try:
             log_text = await client.get_addon_logs(slug)
@@ -713,13 +806,111 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 ],
             )
 
+    # ---- System-service log source ----
+
+    async def _get_system_service_log(
+        service: str,
+        limit: int | str | None = None,
+        search: str | None = None,
+    ) -> dict[str, Any]:
+        """Fetch HA system-service logs from Supervisor's per-service endpoint.
+
+        ``service`` ∈ {supervisor, host, core, dns, audio, multicast, observer}.
+        Caller (``ha_get_logs(source='system_service')``) validates against
+        ``SYSTEM_SERVICE_SLUGS`` before dispatch. Hits
+        ``http://supervisor/<service>/logs`` directly via
+        ``HomeAssistantClient._get_system_service_logs`` — same direct-Supervisor
+        path #1116's add-on fix uses, just with a different URL prefix.
+        Requires ``hassio_role: manager`` in the addon manifest.
+        """
+        effective_limit = _coerce_limit(
+            limit, default=DEFAULT_LOG_LIMIT, suggestion_example="100"
+        )
+
+        try:
+            log_text = await client._get_system_service_logs(service)
+
+            lines = log_text.splitlines() if log_text else []
+
+            filters_applied: dict[str, str] = {}
+            if search:
+                search_lower = search.lower()
+                lines = [ln for ln in lines if search_lower in ln.lower()]
+                filters_applied["search"] = search
+
+            total_lines = len(lines)
+            lines = lines[-effective_limit:]
+
+            data: dict[str, Any] = {
+                "success": True,
+                "source": "system_service",
+                "slug": service,
+                "log": "\n".join(lines),
+                "total_lines": total_lines,
+                "returned_lines": len(lines),
+                "limit": effective_limit,
+            }
+            if filters_applied:
+                data["filters_applied"] = filters_applied
+
+            return data
+
+        except ToolError:
+            raise
+        except HomeAssistantAPIError as e:
+            status = getattr(e, "status_code", None)
+            if status == 403:
+                # Same role-too-low cause as the addon-logs branch.
+                exception_to_structured_error(
+                    e,
+                    context={"source": "system_service", "slug": service},
+                    suggestions=[
+                        "Addon's hassio_role must be 'manager' or higher to "
+                        "read /<service>/logs",
+                        "Verify the addon was reinstalled after the role bump "
+                        "took effect",
+                    ],
+                )
+            if status == 404:
+                exception_to_structured_error(
+                    e,
+                    context={"source": "system_service", "slug": service},
+                    suggestions=[
+                        f"Service '{service}' not found at "
+                        f"http://supervisor/{service}/logs — Supervisor may "
+                        "not expose it on this HA OS version",
+                        f"Allowed services: {', '.join(sorted(SYSTEM_SERVICE_SLUGS))}",
+                    ],
+                )
+            exception_to_structured_error(
+                e,
+                context={"source": "system_service", "slug": service},
+                suggestions=[
+                    f"Supervisor returned an error for /{service}/logs",
+                    "Ensure Supervisor is available (HA OS or Supervised install)",
+                ],
+            )
+        except (
+            HomeAssistantConnectionError,
+            TimeoutError,
+            OSError,
+        ) as e:
+            exception_to_structured_error(
+                e,
+                context={"source": "system_service", "slug": service},
+                suggestions=[
+                    "Check Home Assistant connection",
+                    "Ensure Supervisor is available (HA OS or Supervised install)",
+                ],
+            )
+
     @mcp.tool(
         tags={"Utilities"},
         annotations={
             "idempotentHint": True,
             "readOnlyHint": True,
-            "title": "Evaluate Template"
-        }
+            "title": "Evaluate Template",
+        },
     )
     @log_tool_usage
     async def ha_eval_template(
@@ -901,18 +1092,22 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                     }
             else:
                 error_info = result.get("error", "Unknown error occurred")
-                raise_tool_error(create_error_response(
-                    ErrorCode.SERVICE_CALL_FAILED,
-                    str(error_info) if not isinstance(error_info, str) else error_info,
-                    context={"template": template, "request_id": request_id},
-                    suggestions=[
-                        "Check template syntax - ensure proper Jinja2 formatting",
-                        "Verify entity_ids exist using ha_get_state()",
-                        "Use default values: {{ states('sensor.temp') | float(0) }}",
-                        "Check for typos in function names and entity references",
-                        "Test simpler templates first to isolate issues",
-                    ],
-                ))
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.SERVICE_CALL_FAILED,
+                        str(error_info)
+                        if not isinstance(error_info, str)
+                        else error_info,
+                        context={"template": template, "request_id": request_id},
+                        suggestions=[
+                            "Check template syntax - ensure proper Jinja2 formatting",
+                            "Verify entity_ids exist using ha_get_state()",
+                            "Use default values: {{ states('sensor.temp') | float(0) }}",
+                            "Check for typos in function names and entity references",
+                            "Test simpler templates first to isolate issues",
+                        ],
+                    )
+                )
 
         except ToolError:
             raise

{ha_mcp_dev-7.4.1.dev439 → ha_mcp_dev-7.4.1.dev440/src/ha_mcp_dev.egg-info}/PKG-INFO

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