ha-mcp-dev 7.4.1.dev484__tar.gz → 7.4.1.dev486__tar.gz

{ha_mcp_dev-7.4.1.dev484/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.4.1.dev486}/PKG-INFO

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

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

@@ -52,6 +52,67 @@ def _get_backup_hint_text() -> str:
     return hints.get(hint, hints["normal"])
 
 
+async def _get_local_backup_agent_id(
+    ws_client: HomeAssistantWebSocketClient,
+) -> str:
+    """Discover the local backup agent_id at call time.
+
+    HA Supervised registers ``hassio.local`` and HA Core registers
+    ``backup.local`` — both have ``name: "local"``. Hardcoding either breaks
+    the other deployment. We probe ``backup/agents/info`` and pick the agent
+    whose name is exactly ``"local"``, preferring ``hassio.local`` if both
+    happen to be registered.
+
+    Raises ToolError if no local agent is available.
+    """
+    response = await ws_client.send_command("backup/agents/info")
+    if not response.get("success"):
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.SERVICE_CALL_FAILED,
+                "Failed to enumerate backup agents",
+                context={"details": response},
+            )
+        )
+
+    agents = response.get("result", {}).get("agents", [])
+    if not agents:
+        raise_tool_error(
+            create_error_response(
+                ErrorCode.SERVICE_CALL_FAILED,
+                "No backup agents registered with Home Assistant",
+                suggestions=[
+                    "The HA backup integration may not be fully set up; "
+                    "check the backup panel in Home Assistant",
+                ],
+            )
+        )
+
+    local_agents: list[str] = [
+        a["agent_id"]
+        for a in agents
+        if a.get("name") == "local" and a.get("agent_id")
+    ]
+    # Prefer hassio.local (Supervisor) over backup.local (Core) when both exist
+    for preferred in ("hassio.local", "backup.local"):
+        if preferred in local_agents:
+            return preferred
+    if local_agents:
+        return local_agents[0]
+
+    raise_tool_error(
+        create_error_response(
+            ErrorCode.SERVICE_CALL_FAILED,
+            "No local backup agent found",
+            context={"available_agents": [a.get("agent_id") for a in agents if a.get("agent_id")]},
+            suggestions=[
+                "Backup creation requires a local agent (hassio.local on "
+                "Supervised, backup.local on Core); none is registered",
+            ],
+        )
+    )
+
+
 async def _get_backup_password(
     ws_client: HomeAssistantWebSocketClient,
 ) -> str:
@@ -94,9 +155,14 @@ async def _poll_backup_completion(
     backup_job_id: str,
     max_wait_seconds: int,
     poll_interval: int,
+    agent_id: str,
 ) -> dict[str, Any]:
     """Poll backup/info until the named backup completes, fails, or times out.
 
+    ``agent_id`` is the local agent that owns this backup (e.g.
+    ``hassio.local`` on Supervised, ``backup.local`` on Core); used to look
+    up the per-agent size in the backup-info payload.
+
     Raises ToolError on backup failure or timeout.
     """
     waited = 0
@@ -134,7 +200,7 @@ async def _poll_backup_completion(
                         "name": name,
                         "date": created_backup.get("date"),
                         "size_bytes": created_backup.get("agents", {})
-                        .get("hassio.local", {})
+                        .get(agent_id, {})
                         .get("size"),
                         "status": "Backup completed successfully",
                         "duration_seconds": waited,
@@ -192,19 +258,31 @@ async def create_backup(
         # Get backup password (raises ToolError on failure)
         password = await _get_backup_password(ws_client)
 
+        # Discover the local backup agent at call time. HA Core registers
+        # `backup.local`; HA Supervised registers `hassio.local`. Hardcoding
+        # either breaks the other deployment.
+        local_agent = await _get_local_backup_agent_id(ws_client)
+
         # Generate backup name if not provided
         if not name:
             now = datetime.now()
             name = f"MCP_Backup_{now.strftime('%Y-%m-%d_%H:%M:%S')}"
 
-        # Create backup request
+        # Addons + addon folders are Supervisor concepts — HA Core errors
+        # with "Addons and folders are not supported by core backup" if we
+        # ask for them. Toggle off when we detect the Core local agent.
+        is_supervised = local_agent == "hassio.local"
+        logger.info(
+            f"Detected {'Supervised' if is_supervised else 'Core'} install "
+            f"via backup agent '{local_agent}'"
+        )
         backup_params = {
             "name": name,
             "password": password,
-            "agent_ids": ["hassio.local"],  # Local only
+            "agent_ids": [local_agent],
             "include_homeassistant": True,
             "include_database": False,  # Fast backup
-            "include_all_addons": True,
+            "include_all_addons": is_supervised,
         }
 
         # Send backup request
@@ -225,6 +303,7 @@ async def create_backup(
             backup_job_id,
             max_wait_seconds=_BACKUP_MAX_WAIT_S,
             poll_interval=_BACKUP_POLL_INTERVAL_S,
+            agent_id=local_agent,
         )
 
     except ToolError:
@@ -248,9 +327,13 @@ async def create_backup(
 async def _create_safety_backup(
     ws_client: HomeAssistantWebSocketClient,
     password: str | None,
+    agent_id: str,
 ) -> str | None:
     """Create a pre-restore safety backup.
 
+    ``agent_id`` is the local backup agent (Supervisor's ``hassio.local`` or
+    Core's ``backup.local``) discovered by the caller.
+
     Returns the safety backup ID, or None when password is None (backup intentionally
     skipped). Raises ToolError if backup creation fails.
     """
@@ -260,14 +343,16 @@ async def _create_safety_backup(
     now = datetime.now()
     safety_backup_name = f"PreRestore_Safety_{now.strftime('%Y-%m-%d_%H:%M:%S')}"
 
+    # include_all_addons is a Supervisor concept; HA Core rejects it.
+    is_supervised = agent_id == "hassio.local"
     safety_backup = await ws_client.send_command(
         "backup/generate",
         name=safety_backup_name,
         password=password,
-        agent_ids=["hassio.local"],
+        agent_ids=[agent_id],
         include_homeassistant=True,
         include_database=True,
-        include_all_addons=True,
+        include_all_addons=is_supervised,
     )
 
     if not safety_backup.get("success"):
@@ -330,6 +415,11 @@ async def restore_backup(
                 suggestions=["Use ha_backup_list() to see available backups"],
             ))
 
+        # Discover the local backup agent (Supervisor's hassio.local on
+        # Supervised, backup.local on Core). Used for both the safety backup
+        # and the restore call below.
+        local_agent = await _get_local_backup_agent_id(ws_client)
+
         # Create safety backup BEFORE restoring
         logger.info("Creating safety backup before restore...")
         try:
@@ -339,12 +429,12 @@ async def restore_backup(
             logger.warning("No default password - proceeding without safety backup")
             password = None
 
-        safety_backup_id = await _create_safety_backup(ws_client, password)
+        safety_backup_id = await _create_safety_backup(ws_client, password, local_agent)
 
         # Perform restore
         restore_params = {
             "backup_id": backup_id,
-            "agent_id": "hassio.local",
+            "agent_id": local_agent,
             "restore_database": restore_database,
             "restore_homeassistant": True,
             "restore_addons": [],  # Restore all addons from backup
@@ -409,7 +499,7 @@ def register_backup_tools(mcp: "FastMCP", client: HomeAssistantClient, **kwargs:
 
 **Password:** Uses Home Assistant's default backup password (if configured)
 
-**Storage:** Local only (hassio.local agent)
+**Storage:** Local only (the local backup agent — `hassio.local` on HA Supervised, `backup.local` on HA Core)
 
 **Duration:** Typically takes several seconds to complete (without database)
 

{ha_mcp_dev-7.4.1.dev484 → ha_mcp_dev-7.4.1.dev486}/src/ha_mcp/tools/tools_integrations.py

@@ -295,6 +295,17 @@ class IntegrationTools:
         try:
             result = await self._client.get_config_entry(entry_id)
             entry_domain = result.get("domain") if isinstance(result, dict) else None
+
+            # Surface `options` on every per-entry response (HA's REST endpoint
+            # omits the field). For entries with supports_options=True we probe
+            # via OptionsFlow — see `_fetch_entry_options`. When include_schema
+            # is also requested, `_fetch_options_schema` below populates options
+            # from the same flow init so we don't pay for two round-trips.
+            if isinstance(result, dict):
+                result.setdefault("options", {})
+                if result.get("supports_options") and not include_schema:
+                    result["options"] = await self._fetch_entry_options(entry_id)
+
             resp: dict[str, Any] = {
                 "success": True,
                 "entry_id": entry_id,
@@ -326,21 +337,95 @@ class IntegrationTools:
                 ],
             )
 
+    @staticmethod
+    def _options_from_form_flow(flow: dict[str, Any]) -> dict[str, Any]:
+        """Extract ``{field_name: current_value}`` from a form-type OptionsFlow.
+
+        Reads each ``data_schema`` entry's ``default`` key, falling back to
+        ``value`` only when the ``default`` key is absent (constant-type
+        fields ship ``value`` instead of ``default``). Fields with a missing
+        or ``None`` value are skipped.
+        """
+        out: dict[str, Any] = {}
+        for field in flow.get("data_schema") or []:
+            name = field.get("name")
+            if name is None:
+                continue
+            value = field.get("default", field.get("value"))
+            if value is not None:
+                out[name] = value
+        return out
+
+    async def _fetch_entry_options(self, entry_id: str) -> dict[str, Any]:
+        """Read the current ``options`` for a config entry via its OptionsFlow.
+
+        Home Assistant does not expose ``ConfigEntry.options`` through any
+        read-only REST or WebSocket endpoint — ``/api/config/config_entries/entry``
+        deliberately omits the field. The closest approximation that the HA UI
+        itself uses is the ``default`` values populated into the OptionsFlow's
+        first-step ``data_schema``: integrations build that schema from the
+        existing options dict, so the defaults match the persisted state.
+
+        Starts the flow, harvests ``{name: default}`` from the first step,
+        and aborts the flow in ``finally`` so it doesn't sit half-open.
+
+        Returns ``{}`` on any failure (unsupported entry, non-form first step
+        such as a menu, init/abort errors) so callers can treat the return as
+        the canonical "options" field without further checks. Unexpected
+        exception types are logged at ``warning`` so probe breakage is
+        discoverable.
+        """
+        flow_id: str | None = None
+        try:
+            flow = await self._client.start_options_flow(entry_id)
+            flow_id = flow.get("flow_id")
+            flow_type = flow.get("type")
+            if flow_type != "form":
+                logger.debug(
+                    f"OptionsFlow for {entry_id} returned type={flow_type!r}, "
+                    f"not a form — cannot extract option defaults"
+                )
+                return {}
+            return self._options_from_form_flow(flow)
+        except Exception as exc:
+            logger.warning(
+                f"Failed to fetch options for {entry_id}: "
+                f"{type(exc).__name__}: {exc}"
+            )
+            return {}
+        finally:
+            if flow_id:
+                try:
+                    await self._client.abort_options_flow(flow_id)
+                except Exception as abort_err:
+                    logger.warning(
+                        f"Failed to abort options flow {flow_id}: "
+                        f"{type(abort_err).__name__}: {abort_err}"
+                    )
+
     async def _fetch_options_schema(
         self, entry_id: str, resp: dict[str, Any]
     ) -> None:
-        """Start an options flow to read the schema, then abort it."""
+        """Start an options flow to read the schema, then abort it.
+
+        Also populates ``resp["entry"]["options"]`` for form-type flows from
+        the same flow result so callers requesting both schema and options
+        don't pay for two round-trips.
+        """
         flow_id = None
         try:
             flow_result = await self._client.start_options_flow(entry_id)
             flow_id = flow_result.get("flow_id")
             flow_type = flow_result.get("type")
+            entry = resp.get("entry") if isinstance(resp.get("entry"), dict) else None
             if flow_type == "form":
                 resp["options_schema"] = {
                     "flow_type": "form",
                     "step_id": flow_result.get("step_id"),
                     "data_schema": flow_result.get("data_schema", []),
                 }
+                if entry is not None:
+                    entry["options"] = self._options_from_form_flow(flow_result)
             elif flow_type == "menu":
                 resp["options_schema"] = {
                     "flow_type": "menu",
@@ -348,16 +433,18 @@ class IntegrationTools:
                     "menu_options": flow_result.get("menu_options", []),
                 }
         except Exception as schema_err:
-            logger.debug(
-                f"Failed to fetch options schema for {entry_id}: {schema_err}"
+            logger.warning(
+                f"Failed to fetch options schema for {entry_id}: "
+                f"{type(schema_err).__name__}: {schema_err}"
             )
         finally:
             if flow_id:
                 try:
                     await self._client.abort_options_flow(flow_id)
                 except Exception as abort_err:
-                    logger.debug(
-                        f"Failed to abort options flow {flow_id}: {abort_err}"
+                    logger.warning(
+                        f"Failed to abort options flow {flow_id}: "
+                        f"{type(abort_err).__name__}: {abort_err}"
                     )
 
     async def _list_entries(
@@ -394,11 +481,28 @@ class IntegrationTools:
         # Fetch current logger levels once; enrich each entry with its effective level.
         logger_levels = await get_logger_levels(self._client)
 
-        # Format entries for response
+        # `_format_entry` is sync and cannot probe the OptionsFlow; options
+        # are filled in by a second async pass below for entries that
+        # advertise supports_options=True. See `_fetch_entry_options`.
         formatted_entries = [
             self._format_entry(entry, include_opts, logger_levels) for entry in entries
         ]
 
+        if include_opts:
+            options_targets = [
+                e for e in formatted_entries if e.get("supports_options")
+            ]
+            if options_targets:
+                fetched = await asyncio.gather(
+                    *(
+                        self._fetch_entry_options(e["entry_id"])
+                        for e in options_targets
+                    ),
+                    return_exceptions=False,
+                )
+                for entry, opts in zip(options_targets, fetched, strict=True):
+                    entry["options"] = opts
+
         # Apply search filter if query provided
         if query and query.strip():
             formatted_entries = self._filter_by_query(

{ha_mcp_dev-7.4.1.dev484 → ha_mcp_dev-7.4.1.dev486/src/ha_mcp_dev.egg-info}/PKG-INFO

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