ha-mcp-dev 7.4.1.dev414__tar.gz → 7.4.1.dev416__tar.gz

{ha_mcp_dev-7.4.1.dev414/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.4.1.dev416}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.4.1.dev414"
+version = "7.4.1.dev416"
 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.dev414 → ha_mcp_dev-7.4.1.dev416}/src/ha_mcp/tools/tools_addons.py

@@ -295,11 +295,50 @@ async def get_addon_info(client: HomeAssistantClient, slug: str) -> dict[str, An
 
     Returns:
         Dictionary with add-on details including ingress info, state, options, etc.
+        Top-level ``log_level`` is surfaced when the add-on exposes one via its
+        Supervisor options or schema (e.g., ``"debug"``, ``"info"``, etc.).
     """
     response = await _supervisor_api_call(client, f"/addons/{slug}/info")
     if not response.get("success"):
         return response  # TODO(tech-debt): should raise ToolError per AGENTS.md Pattern B
-    return {"success": True, "addon": response["result"]}
+
+    addon = response["result"] if isinstance(response["result"], dict) else {}
+    result: dict[str, Any] = {"success": True, "addon": addon}
+
+    log_level = _extract_addon_log_level(addon)
+    if log_level is not None:
+        result["log_level"] = log_level
+
+    return result
+
+
+def _extract_addon_log_level(addon: dict[str, Any]) -> str | None:
+    """Return the add-on's configured log level, if any.
+
+    Checks the add-on's current options first (``options.log_level`` — what the
+    user set), then falls back to the schema (Supervisor serializes ``schema``
+    as a list of ``{name, type, ...}`` field descriptors) so add-ons that ship a
+    log_level option without a value still surface ``"default"``. Returns
+    ``None`` when the add-on exposes no log_level option at all.
+
+    The lower-case ``"default"`` is the literal Supervisor sentinel; the
+    integration path uses ``"DEFAULT"`` (uppercase) — these are distinct values
+    by design and should not be cross-compared.
+    """
+    options = addon.get("options")
+    if isinstance(options, dict):
+        level = options.get("log_level")
+        if isinstance(level, str) and level.strip():
+            return level
+
+    schema = addon.get("schema")
+    if isinstance(schema, list) and any(
+        isinstance(item, dict) and item.get("name") == "log_level"
+        for item in schema
+    ):
+        return "default"
+
+    return None
 
 
 async def list_addons(
@@ -1153,7 +1192,9 @@ def register_addon_tools(mcp: Any, client: HomeAssistantClient, **kwargs: Any) -
         **Note:** This tool only works with Home Assistant OS or Supervised installations.
 
         **SINGLE ADD-ON (slug provided):**
-        Returns comprehensive details including ingress entry, ports, options, and state.
+        Returns comprehensive details including ingress entry, ports, options, state,
+        and (when the add-on exposes one) a top-level ``log_level`` reflecting the
+        current Supervisor option — useful for confirming ha_manage_addon log_level changes.
         Useful for discovering what APIs an add-on exposes before calling ha_manage_addon.
 
         **INSTALLED ADD-ONS (source='installed'):**

{ha_mcp_dev-7.4.1.dev414 → ha_mcp_dev-7.4.1.dev416}/src/ha_mcp/tools/tools_integrations.py

@@ -34,6 +34,7 @@ from .util_helpers import (
     build_pagination_metadata,
     coerce_bool_param,
     coerce_int_param,
+    get_logger_levels,
     wait_for_entity_removed,
 )
 
@@ -233,6 +234,19 @@ class IntegrationTools:
 
         STATES: 'loaded', 'setup_error', 'setup_retry', 'not_loaded',
         'failed_unload', 'migration_error'.
+
+        Each entry carries:
+
+        - ``log_level``: the canonical Python logger level name
+          (``DEBUG``/``INFO``/``WARNING``/``ERROR``/``CRITICAL``) when the
+          integration has a ``logger.set_level`` override, or ``"DEFAULT"``
+          (uppercase sentinel) when no override is set.
+        - ``log_level_raw``: the original numeric level (e.g. ``10`` for DEBUG)
+          when HA returned an int, ``None`` otherwise (no override set, or HA
+          provided a level name as a string).
+
+        This is distinct from the add-on side, where ``ha_get_addon`` returns
+        Supervisor's lowercase ``"default"`` literal — do not cross-compare.
         """
         try:
             include_opts = coerce_bool_param(
@@ -280,12 +294,21 @@ class IntegrationTools:
         """Fetch a single config entry by ID, optionally including its options schema."""
         try:
             result = await self._client.get_config_entry(entry_id)
+            entry_domain = result.get("domain") if isinstance(result, dict) else None
             resp: dict[str, Any] = {
                 "success": True,
                 "entry_id": entry_id,
                 "entry": result,
             }
 
+            # Surface the effective Python logger level for this integration
+            # so users can confirm logger.set_level changes took effect.
+            # Emit unconditionally for symmetry with the list path (_format_entry).
+            logger_levels = await get_logger_levels(self._client)
+            level_info = logger_levels.get(entry_domain or "")
+            resp["log_level"] = level_info["name"] if level_info else "DEFAULT"
+            resp["log_level_raw"] = level_info["raw"] if level_info else None
+
             # Optionally fetch options flow schema (logically read-only: start+abort)
             if include_schema and result.get("supports_options"):
                 await self._fetch_options_schema(entry_id, resp)
@@ -368,9 +391,12 @@ class IntegrationTools:
                 e for e in entries if e.get("domain", "").lower() == domain_lower
             ]
 
+        # Fetch current logger levels once; enrich each entry with its effective level.
+        logger_levels = await get_logger_levels(self._client)
+
         # Format entries for response
         formatted_entries = [
-            self._format_entry(entry, include_opts) for entry in entries
+            self._format_entry(entry, include_opts, logger_levels) for entry in entries
         ]
 
         # Apply search filter if query provided
@@ -403,7 +429,11 @@ class IntegrationTools:
         return result_data
 
     @staticmethod
-    def _format_entry(entry: dict[str, Any], include_opts: bool | None) -> dict[str, Any]:
+    def _format_entry(
+        entry: dict[str, Any],
+        include_opts: bool | None,
+        logger_levels: dict[str, dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
         """Format a raw config entry into the response shape."""
         formatted_entry: dict[str, Any] = {
             "entry_id": entry.get("entry_id"),
@@ -416,6 +446,16 @@ class IntegrationTools:
             "disabled_by": entry.get("disabled_by"),
         }
 
+        # Surface the effective Python logger level for this integration
+        # ("DEFAULT" = no override; falls back to the root logger level).
+        # `log_level_raw` is the original numeric level (None when no override
+        # exists or HA returned a string instead of an int).
+        if logger_levels is not None:
+            domain = entry.get("domain") or ""
+            level_info = logger_levels.get(domain)
+            formatted_entry["log_level"] = level_info["name"] if level_info else "DEFAULT"
+            formatted_entry["log_level_raw"] = level_info["raw"] if level_info else None
+
         # Include options when requested (for auditing template definitions, etc.)
         if include_opts:
             formatted_entry["options"] = entry.get("options", {})

{ha_mcp_dev-7.4.1.dev414 → ha_mcp_dev-7.4.1.dev416}/src/ha_mcp/tools/tools_search.py

@@ -666,6 +666,11 @@ def register_search_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                         "safe_mode": config.get("safe_mode", False),
                         "internal_url": config.get("internal_url"),
                         "external_url": config.get("external_url"),
+                        # No default: distinguish HA-not-exposing-the-key (None)
+                        # from empty-allowlist ([]) — security-relevant for agents.
+                        "allowlist_external_dirs": config.get(
+                            "allowlist_external_dirs"
+                        ),
                     }
                 )
             result["system_info"] = system_info

{ha_mcp_dev-7.4.1.dev414 → ha_mcp_dev-7.4.1.dev416}/src/ha_mcp/tools/tools_utility.py

@@ -15,7 +15,12 @@ from fastmcp.exceptions import ToolError
 from ..client.rest_client import HomeAssistantAPIError, HomeAssistantConnectionError
 from ..errors import ErrorCode, create_error_response
 from .helpers import exception_to_structured_error, log_tool_usage, raise_tool_error
-from .util_helpers import add_timezone_metadata, coerce_bool_param, coerce_int_param
+from .util_helpers import (
+    add_timezone_metadata,
+    coerce_bool_param,
+    coerce_int_param,
+    normalize_log_level,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -79,7 +84,7 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
     )
     @log_tool_usage
     async def ha_get_logs(
-        source: Literal["logbook", "system", "error_log", "supervisor"] = "logbook",
+        source: Literal["logbook", "system", "error_log", "supervisor", "logger"] = "logbook",
         # Shared parameters
         limit: int | str | None = None,
         search: str | None = None,
@@ -102,8 +107,9 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
         - "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)
+        - "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)
+        **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")
@@ -130,10 +136,10 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 f"Parameters {', '.join(ignored)} only apply to source='logbook'; "
                 f"ignored for source='{source}'"
             )
-        if source == "logbook" and level is not None:
+        if source in ("logbook", "logger", "supervisor") and level is not None:
             warnings.append(
                 "Parameter 'level' only applies to source='system' or 'error_log'; "
-                "ignored for source='logbook'"
+                f"ignored for source='{source}'"
             )
 
         # --- source="logbook" ---
@@ -173,6 +179,13 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 result["warnings"] = warnings
             return result
 
+        # --- source="logger" ---
+        if source == "logger":
+            result = await _get_logger_info(limit=limit, search=search)
+            if warnings:
+                result["warnings"] = warnings
+            return result
+
         # --- source="supervisor" ---
         # source == "supervisor" (Literal type guarantees this)
         if not slug:
@@ -508,6 +521,97 @@ def register_utility_tools(mcp: Any, client: Any, **kwargs: Any) -> None:
                 ],
             )
 
+    # ---- Logger info source ----
+
+    async def _get_logger_info(
+        limit: int | str | None = None,
+        search: str | None = None,
+    ) -> dict[str, Any]:
+        """Fetch per-integration log levels via the ``logger/log_info`` WS command."""
+        effective_limit = _coerce_limit(limit)
+
+        try:
+            result = await client.send_websocket_message({"type": "logger/log_info"})
+
+            if not result.get("success"):
+                raise_tool_error(
+                    create_error_response(
+                        ErrorCode.SERVICE_CALL_FAILED,
+                        result.get("error", "Failed to retrieve logger info"),
+                        suggestions=[
+                            "Verify the 'logger' integration is enabled in Home Assistant",
+                            "Check Home Assistant WebSocket connection",
+                        ],
+                    )
+                )
+
+            raw_entries = result.get("result", [])
+            if not isinstance(raw_entries, list):
+                raw_entries = []
+
+            loggers: list[dict[str, Any]] = []
+            for entry in raw_entries:
+                if not isinstance(entry, dict):
+                    continue
+                domain = entry.get("domain")
+                if not isinstance(domain, str) or not domain:
+                    continue
+                raw_level = entry.get("level")
+                level_name = normalize_log_level(raw_level)
+                if level_name is None:
+                    continue
+                loggers.append(
+                    {
+                        "domain": domain,
+                        "level": level_name,
+                        "level_raw": raw_level if isinstance(raw_level, int) else None,
+                    }
+                )
+
+            filters_applied: dict[str, str] = {}
+            if search:
+                search_lower = search.lower()
+                loggers = [
+                    entry for entry in loggers
+                    if search_lower in entry["domain"].lower()
+                ]
+                filters_applied["search"] = search
+
+            loggers.sort(key=lambda entry: entry["domain"])
+
+            total_entries = len(loggers)
+            loggers = loggers[:effective_limit]
+
+            data: dict[str, Any] = {
+                "success": True,
+                "source": "logger",
+                "loggers": loggers,
+                "total_entries": total_entries,
+                "returned_entries": len(loggers),
+                "limit": effective_limit,
+            }
+            if filters_applied:
+                data["filters_applied"] = filters_applied
+
+            return data
+
+        except ToolError:
+            raise
+        except (
+            HomeAssistantConnectionError,
+            HomeAssistantAPIError,
+            TimeoutError,
+            OSError,
+        ) as e:
+            exception_to_structured_error(
+                e,
+                context={"source": "logger"},
+                suggestions=[
+                    "Check Home Assistant WebSocket connection",
+                    "Verify the 'logger' integration is enabled",
+                ],
+            )
+
     # ---- Supervisor log source ----
 
     async def _get_supervisor_log(

{ha_mcp_dev-7.4.1.dev414 → ha_mcp_dev-7.4.1.dev416}/src/ha_mcp/tools/util_helpers.py

@@ -268,6 +268,87 @@ def unwrap_service_response(result: dict[str, Any]) -> dict[str, Any]:
     return sr if isinstance(sr, dict) else result
 
 
+# Python logging numeric-level → canonical level name.
+# Mirrors the values in HA's LOGSEVERITY constant (components/logger/const.py).
+_LOG_LEVEL_NAMES: dict[int, str] = {
+    0: "NOTSET",
+    10: "DEBUG",
+    20: "INFO",
+    30: "WARNING",
+    40: "ERROR",
+    50: "CRITICAL",
+}
+
+
+def normalize_log_level(level: Any) -> str | None:
+    """Normalize a numeric or string log level to its canonical uppercase name.
+
+    Returns None if the value can't be recognized as a log level.
+    """
+    if isinstance(level, bool):  # bool is an int subclass — reject explicitly
+        return None
+    if isinstance(level, int):
+        return _LOG_LEVEL_NAMES.get(level, f"LEVEL_{level}")
+    if isinstance(level, str):
+        stripped = level.strip().upper()
+        if not stripped:
+            return None
+        return stripped
+    return None
+
+
+async def get_logger_levels(client: Any) -> dict[str, dict[str, Any]]:
+    """Fetch current HA integration log levels via the ``logger/log_info`` WS command.
+
+    Returns a mapping of integration domain (e.g. ``"mqtt"``) to a dict with:
+
+    - ``name``: canonical level name (``"DEBUG"``, ``"INFO"``, ``"WARNING"``,
+      ``"ERROR"``, ``"CRITICAL"``, ``"NOTSET"``, or ``"LEVEL_<n>"`` for
+      non-standard ints).
+    - ``raw``: the original numeric level (``int``) when HA returned an int,
+      otherwise ``None`` (e.g. when the level was already provided as a string).
+
+    Best-effort enrichment: returns an empty dict on connection/IO failures so
+    callers can treat it as "no custom levels". Programming errors are not
+    suppressed — they surface as bugs during development/CI.
+    """
+    try:
+        result = await client.send_websocket_message({"type": "logger/log_info"})
+    except (
+        HomeAssistantConnectionError,
+        HomeAssistantAPIError,
+        HomeAssistantAuthError,
+        TimeoutError,
+        OSError,
+    ) as exc:
+        logger.debug("logger/log_info fetch failed: %s", exc)
+        return {}
+
+    if not isinstance(result, dict) or not result.get("success"):
+        return {}
+
+    entries = result.get("result", [])
+    if not isinstance(entries, list):
+        return {}
+
+    levels: dict[str, dict[str, Any]] = {}
+    for entry in entries:
+        if not isinstance(entry, dict):
+            continue
+        domain = entry.get("domain")
+        if not isinstance(domain, str) or not domain:
+            continue
+        raw_level = entry.get("level")
+        name = normalize_log_level(raw_level)
+        if name is None:
+            continue
+        levels[domain] = {
+            "name": name,
+            "raw": raw_level if isinstance(raw_level, int) and not isinstance(raw_level, bool) else None,
+        }
+    return levels
+
+
 async def add_timezone_metadata(client: Any, data: dict[str, Any]) -> dict[str, Any]:
     """Add Home Assistant timezone to tool responses for local time context."""
     try:

{ha_mcp_dev-7.4.1.dev414 → ha_mcp_dev-7.4.1.dev416/src/ha_mcp_dev.egg-info}/PKG-INFO

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