ha-mcp-dev 7.2.0.dev343__tar.gz → 7.2.0.dev345__tar.gz

{ha_mcp_dev-7.2.0.dev343/src/ha_mcp_dev.egg-info → ha_mcp_dev-7.2.0.dev345}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "7.2.0.dev343"
+version = "7.2.0.dev345"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"
@@ -114,7 +114,6 @@ select = [
 ignore = [
     "E501",    # line too long — formatter handles this
     "B008",    # function calls in defaults — FastMCP pattern
-    "C901",    # complexity — too many to fix now
     "SIM102",  # collapsible-if — sometimes less readable
     "SIM108",  # ternary — sometimes less readable
     "SIM105",  # contextlib.suppress — style preference
@@ -134,6 +133,7 @@ ignore = [
 [tool.ruff.lint.per-file-ignores]
 "__init__.py" = ["F401"]
 "tests/**/*" = ["E501", "B011"]
+"src/ha_mcp/tools/**" = ["C901"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

{ha_mcp_dev-7.2.0.dev343 → ha_mcp_dev-7.2.0.dev345}/src/ha_mcp/client/rest_client.py

@@ -504,37 +504,9 @@ class HomeAssistantClient:
             actual_entity_id = None
             entity_not_verified = False
             if operation == "created":
-                try:
-                    # Poll with retries — slower hardware may need more time
-                    for attempt in range(3):
-                        await asyncio.sleep(1 * (attempt + 1))
-
-                        states = await self.get_states()
-                        for state in states:
-                            if state.get("entity_id", "").startswith(
-                                "automation."
-                            ):
-                                attributes = state.get("attributes", {})
-                                if attributes.get("id") == unique_id:
-                                    actual_entity_id = state.get("entity_id")
-                                    logger.debug(
-                                        f"Found actual entity_id for unique_id {unique_id}: {actual_entity_id}"
-                                    )
-                                    break
-                        if actual_entity_id:
-                            break
-
-                    if not actual_entity_id:
-                        entity_not_verified = True
-                        logger.warning(
-                            f"Automation with unique_id {unique_id} was not found in HA state after creation"
-                        )
-
-                except Exception as e:
+                actual_entity_id = await self._poll_for_automation_entity(unique_id)
+                if not actual_entity_id:
                     entity_not_verified = True
-                    logger.warning(
-                        f"Failed to query actual entity_id for unique_id {unique_id}: {e}"
-                    )
 
             result: dict[str, Any] = {
                 "unique_id": unique_id,
@@ -552,6 +524,32 @@ class HomeAssistantClient:
                 ) from e
             raise
 
+    async def _poll_for_automation_entity(self, unique_id: str) -> str | None:
+        """Poll HA state to find the entity_id assigned to a newly created automation."""
+        try:
+            for attempt in range(3):
+                await asyncio.sleep(1 * (attempt + 1))
+                states = await self.get_states()
+                for state in states:
+                    if not state.get("entity_id", "").startswith("automation."):
+                        continue
+                    if state.get("attributes", {}).get("id") == unique_id:
+                        entity_id = state.get("entity_id")
+                        logger.debug(
+                            f"Found actual entity_id for unique_id {unique_id}: {entity_id}"
+                        )
+                        return entity_id
+        except Exception as e:
+            logger.warning(
+                f"Failed to query actual entity_id for unique_id {unique_id}: {e}"
+            )
+            return None
+
+        logger.warning(
+            f"Automation with unique_id {unique_id} was not found in HA state after creation"
+        )
+        return None
+
     async def delete_automation_config(self, identifier: str) -> dict[str, Any]:
         """
         Delete automation configuration by entity_id or unique_id.

{ha_mcp_dev-7.2.0.dev343 → ha_mcp_dev-7.2.0.dev345}/src/ha_mcp/client/websocket_client.py

@@ -324,20 +324,26 @@ class HomeAssistantWebSocketClient:
 
         # Handle events
         if message_type == "event":
-            if message_id is not None:
-                render_future = self._state.resolve_event_response(message_id)
-                if render_future:
-                    if not render_future.cancelled():
-                        render_future.set_result(data)
-                    return
-
-            event_type = data.get("event", {}).get("event_type")
-            if event_type:
-                for handler in self._state.get_event_handlers(event_type):
-                    try:
-                        await handler(data["event"])
-                    except Exception as e:
-                        logger.error(f"Error in event handler: {e}")
+            await self._handle_event_message(data, message_id)
+
+    async def _handle_event_message(
+        self, data: dict[str, Any], message_id: int | None
+    ) -> None:
+        """Handle an incoming event message."""
+        if message_id is not None:
+            render_future = self._state.resolve_event_response(message_id)
+            if render_future:
+                if not render_future.cancelled():
+                    render_future.set_result(data)
+                return
+
+        event_type = data.get("event", {}).get("event_type")
+        if event_type:
+            for handler in self._state.get_event_handlers(event_type):
+                try:
+                    await handler(data["event"])
+                except Exception as e:
+                    logger.error(f"Error in event handler: {e}")
 
     def _ensure_send_lock(self) -> None:
         """Ensure the send lock belongs to the current event loop."""
@@ -712,8 +718,13 @@ class WebSocketManager:
                 for client in self._clients.values():
                     try:
                         await client.disconnect()
-                    except Exception:
-                        pass
+                    except (OSError, asyncio.CancelledError):
+                        # Best-effort cleanup — failure is expected when the
+                        # event loop changed and connections are stale.
+                        logger.debug(
+                            "Ignoring error disconnecting stale WebSocket client",
+                            exc_info=True,
+                        )
                 self._clients.clear()
                 self._last_used.clear()
 
@@ -751,22 +762,26 @@ class WebSocketManager:
             self._clients[key] = client
             self._last_used[key] = time.monotonic()
 
-            # Evict least-recently-used connection if over limit
-            if len(self._clients) > MAX_POOL_SIZE:
-                oldest_key = min(self._last_used, key=lambda k: self._last_used[k])
-                stale = self._clients.pop(oldest_key, None)
-                self._last_used.pop(oldest_key, None)
-                if stale:
-                    try:
-                        await stale.disconnect()
-                    except Exception:
-                        logger.warning(
-                            "Error disconnecting evicted WebSocket client",
-                            exc_info=True,
-                        )
+            await self._evict_lru_if_needed()
 
             return client
 
+    async def _evict_lru_if_needed(self) -> None:
+        """Evict the least-recently-used connection if pool exceeds limit."""
+        if len(self._clients) <= MAX_POOL_SIZE:
+            return
+        oldest_key = min(self._last_used, key=lambda k: self._last_used[k])
+        stale = self._clients.pop(oldest_key, None)
+        self._last_used.pop(oldest_key, None)
+        if stale:
+            try:
+                await stale.disconnect()
+            except (OSError, asyncio.CancelledError):
+                logger.warning(
+                    "Error disconnecting evicted WebSocket client",
+                    exc_info=True,
+                )
+
     async def disconnect(self) -> None:
         """Disconnect all WebSocket clients."""
         self._ensure_lock()
@@ -777,7 +792,7 @@ class WebSocketManager:
             for client in self._clients.values():
                 try:
                     await client.disconnect()
-                except Exception:
+                except (OSError, asyncio.CancelledError):
                     logger.warning(
                         "Error disconnecting WebSocket client", exc_info=True
                     )

{ha_mcp_dev-7.2.0.dev343 → ha_mcp_dev-7.2.0.dev345}/src/ha_mcp/server.py

@@ -570,23 +570,7 @@ class HomeAssistantSmartMCPServer(EnhancedToolsMixin):
                 f"the file URI to load specific guides as needed."
             )
 
-            # Collect available reference files for the listing.
-            # Filter out symlinks and verify path containment to prevent
-            # traversal via symlinked directories.
-            ref_files = []
-            resolved_root = skill_dir.resolve()
-            try:
-                for f in sorted(skill_dir.rglob("*")):
-                    if not f.is_file() or f.is_symlink():
-                        continue
-                    # Ensure resolved path stays within the skill directory
-                    if not f.resolve().is_relative_to(resolved_root):
-                        continue
-                    rel = f.relative_to(skill_dir)
-                    ref_uri = f"skill://{skill_name}/{rel}"
-                    ref_files.append({"name": str(rel), "uri": ref_uri})
-            except OSError:
-                logger.warning("Error reading skill files in %s", skill_dir)
+            ref_files = self._collect_skill_ref_files(skill_dir, skill_name)
 
             # Use factory to capture ref_files in closure
             def _make_skill_handler(
@@ -621,6 +605,25 @@ class HomeAssistantSmartMCPServer(EnhancedToolsMixin):
                 len(ref_files),
             )
 
+    @staticmethod
+    def _collect_skill_ref_files(
+        skill_dir: Path, skill_name: str
+    ) -> list[dict[str, str]]:
+        """Collect reference files for a skill, filtering symlinks and path traversal."""
+        ref_files: list[dict[str, str]] = []
+        resolved_root = skill_dir.resolve()
+        try:
+            for f in sorted(skill_dir.rglob("*")):
+                if not f.is_file() or f.is_symlink():
+                    continue
+                if not f.resolve().is_relative_to(resolved_root):
+                    continue
+                rel = f.relative_to(skill_dir)
+                ref_files.append({"name": str(rel), "uri": f"skill://{skill_name}/{rel}"})
+        except OSError:
+            logger.warning("Error reading skill files in %s", skill_dir)
+        return ref_files
+
     # Helper methods required by EnhancedToolsMixin
 
     async def smart_entity_search(

{ha_mcp_dev-7.2.0.dev343 → ha_mcp_dev-7.2.0.dev345}/src/ha_mcp/smoke_test.py

@@ -1,8 +1,10 @@
 #!/usr/bin/env python3
 """Smoke test for ha-mcp binary - verifies all dependencies are bundled correctly."""
 
+import asyncio
 import os
 import sys
+from typing import Any
 
 # Force UTF-8 encoding on Windows for Unicode output
 if sys.platform == "win32":
@@ -14,15 +16,14 @@ os.environ.setdefault("HOMEASSISTANT_URL", "http://smoke-test:8123")
 os.environ.setdefault("HOMEASSISTANT_TOKEN", "smoke-test-token")
 
 
-def main() -> int:
-    """Run smoke tests and return exit code."""
-    print("=" * 60)
-    print("Home Assistant MCP Server - Smoke Test")
-    print("=" * 60)
+def _print_errors(errors: list[str]) -> None:
+    print("\n" + "=" * 60)
+    print(f"SMOKE TEST FAILED: {len(errors)} error(s)")
+    for error in errors:
+        print(f"  - {error}")
 
-    errors = []
 
-    # Test 1: Critical library imports
+def _test_critical_imports(errors: list[str]) -> int:
     print("\n[1/4] Testing critical library imports...")
     critical_imports = [
         ("fastmcp", "FastMCP framework"),
@@ -31,7 +32,6 @@ def main() -> int:
         ("click", "CLI framework"),
         ("websockets", "WebSocket support"),
     ]
-
     for module_name, description in critical_imports:
         try:
             __import__(module_name)
@@ -39,43 +39,37 @@ def main() -> int:
         except ImportError as e:
             errors.append(f"Failed to import {module_name}: {e}")
             print(f"  ✗ {module_name} ({description}) - FAILED: {e}")
+    return len(critical_imports)
+
 
-    # Test 2: Server module import
+def _test_server_import(errors: list[str]) -> type | None:
     print("\n[2/4] Testing server module import...")
     try:
         from ha_mcp.server import HomeAssistantSmartMCPServer
         print("  ✓ Server module imported successfully")
+        return HomeAssistantSmartMCPServer
     except Exception as e:
         errors.append(f"Failed to import server module: {e}")
         print(f"  ✗ Server module import - FAILED: {e}")
-        # Can't continue if server module fails
-        print("\n" + "=" * 60)
-        print(f"SMOKE TEST FAILED: {len(errors)} error(s)")
-        for error in errors:
-            print(f"  - {error}")
-        return 1
+        return None
+
 
-    # Test 3: Server instantiation
+def _test_server_instantiation(errors: list[str], server_cls: type) -> Any | None:
     print("\n[3/4] Testing server instantiation...")
     try:
-        server = HomeAssistantSmartMCPServer()
+        server = server_cls()
         mcp = server.mcp
         print(f"  ✓ Server created: {mcp.name}")
+        return mcp
     except Exception as e:
         errors.append(f"Failed to create server: {e}")
         print(f"  ✗ Server instantiation - FAILED: {e}")
-        # Can't continue if server creation fails
-        print("\n" + "=" * 60)
-        print(f"SMOKE TEST FAILED: {len(errors)} error(s)")
-        for error in errors:
-            print(f"  - {error}")
-        return 1
+        return None
+
 
-    # Test 4: Tool discovery
+def _test_tool_discovery(errors: list[str], mcp: Any) -> int:
     print("\n[4/4] Testing tool discovery...")
     try:
-        import asyncio
-
         tools = asyncio.run(mcp.list_tools())
         tool_count = len(tools)
         print(f"  ✓ Discovered {tool_count} tools")
@@ -84,26 +78,47 @@ def main() -> int:
             errors.append(f"Too few tools discovered: {tool_count} (expected 50+)")
             print("  ✗ Tool count too low (expected 50+)")
         else:
-            # List a few tool names as examples
             tool_names = [t.name for t in tools[:5]]
             print(f"  ✓ Sample tools: {', '.join(tool_names)}...")
+        return tool_count
     except Exception as e:
         errors.append(f"Failed to discover tools: {e}")
         print(f"  ✗ Tool discovery - FAILED: {e}")
+        return 0
+
+
+def main() -> int:
+    """Run smoke tests and return exit code."""
+    print("=" * 60)
+    print("Home Assistant MCP Server - Smoke Test")
+    print("=" * 60)
+
+    errors: list[str] = []
+
+    import_count = _test_critical_imports(errors)
+
+    server_cls = _test_server_import(errors)
+    if server_cls is None:
+        _print_errors(errors)
+        return 1
+
+    mcp = _test_server_instantiation(errors, server_cls)
+    if mcp is None:
+        _print_errors(errors)
+        return 1
+
+    tool_count = _test_tool_discovery(errors, mcp)
 
-    # Summary
-    print("\n" + "=" * 60)
     if errors:
-        print(f"SMOKE TEST FAILED: {len(errors)} error(s)")
-        for error in errors:
-            print(f"  - {error}")
+        _print_errors(errors)
         return 1
-    else:
-        print("SMOKE TEST PASSED: All checks successful!")
-        print(f"  - All {len(critical_imports)} critical libraries imported")
-        print("  - Server instantiated successfully")
-        print(f"  - {tool_count} tools discovered")
-        return 0
+
+    print("\n" + "=" * 60)
+    print("SMOKE TEST PASSED: All checks successful!")
+    print(f"  - All {import_count} critical libraries imported")
+    print("  - Server instantiated successfully")
+    print(f"  - {tool_count} tools discovered")
+    return 0
 
 
 if __name__ == "__main__":

{ha_mcp_dev-7.2.0.dev343 → ha_mcp_dev-7.2.0.dev345}/src/ha_mcp/utils/python_sandbox.py

@@ -158,58 +158,56 @@ def validate_expression(expr: str) -> tuple[bool, str]:
 
     # Validate all nodes
     for node in ast.walk(tree):
-        # Check if node type is whitelisted
-        if type(node) not in SAFE_NODES:
-            return False, f"Forbidden node type: {type(node).__name__}"
-
-        # Block imports
-        if isinstance(node, (ast.Import, ast.ImportFrom)):
-            return False, "Forbidden: imports not allowed"
-
-        # Block dunder attribute access
-        if isinstance(node, ast.Attribute):
-            if node.attr.startswith("__") and node.attr.endswith("__"):
-                return False, f"Forbidden: dunder attribute access ({node.attr})"
-
-        # Validate function calls
-        if isinstance(node, ast.Call):
-            # Direct function calls (e.g., eval(), open())
-            if isinstance(node.func, ast.Name):
-                func_name = node.func.id
-                if func_name in BLOCKED_FUNCTIONS:
-                    return False, f"Forbidden function: {func_name}"
-
-            # Method calls (e.g., config.append())
-            elif isinstance(node.func, ast.Attribute):
-                method_name = node.func.attr
-                if method_name.startswith("__") and method_name.endswith("__"):
-                    return False, f"Forbidden: dunder method call ({method_name})"
-                if method_name not in SAFE_METHODS:
-                    return (
-                        False,
-                        f"Forbidden method: {method_name} (allowed: {', '.join(sorted(SAFE_METHODS))})",
-                    )
-
-            # Reject subscript calls, chained calls, and all other non-standard targets
-            # e.g., config['fn']() or config.get('fn')() would bypass Name/Attribute checks
-            else:
-                return False, f"Forbidden call target type: {type(node.func).__name__}"
-
-        # Block function definitions (could be used for obfuscation)
-        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
-            return False, "Forbidden: function/class definitions not allowed"
-
-        # Block with statements (context managers)
-        if isinstance(node, (ast.With, ast.AsyncWith)):
-            return False, "Forbidden: with statements not allowed"
-
-        # Block try/except (could hide errors)
-        if isinstance(node, (ast.Try, ast.ExceptHandler)):
-            return False, "Forbidden: try/except not allowed"
+        error = _validate_node(node)
+        if error:
+            return False, error
 
     return True, ""
 
 
+def _validate_node(node: ast.AST) -> str | None:
+    """Validate a single AST node. Returns error message or None if safe."""
+    if type(node) not in SAFE_NODES:
+        return f"Forbidden node type: {type(node).__name__}"
+
+    if isinstance(node, (ast.Import, ast.ImportFrom)):
+        return "Forbidden: imports not allowed"
+
+    if isinstance(node, ast.Attribute):
+        if node.attr.startswith("__") and node.attr.endswith("__"):
+            return f"Forbidden: dunder attribute access ({node.attr})"
+
+    if isinstance(node, ast.Call):
+        return _validate_call_node(node)
+
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+        return "Forbidden: function/class definitions not allowed"
+
+    if isinstance(node, (ast.With, ast.AsyncWith)):
+        return "Forbidden: with statements not allowed"
+
+    if isinstance(node, (ast.Try, ast.ExceptHandler)):
+        return "Forbidden: try/except not allowed"
+
+    return None
+
+
+def _validate_call_node(node: ast.Call) -> str | None:
+    """Validate a function/method call node. Returns error message or None."""
+    if isinstance(node.func, ast.Name):
+        if node.func.id in BLOCKED_FUNCTIONS:
+            return f"Forbidden function: {node.func.id}"
+    elif isinstance(node.func, ast.Attribute):
+        method_name = node.func.attr
+        if method_name.startswith("__") and method_name.endswith("__"):
+            return f"Forbidden: dunder method call ({method_name})"
+        if method_name not in SAFE_METHODS:
+            return f"Forbidden method: {method_name} (allowed: {', '.join(sorted(SAFE_METHODS))})"
+    else:
+        return f"Forbidden call target type: {type(node.func).__name__}"
+    return None
+
+
 def safe_execute(expr: str, config: dict[str, Any]) -> dict[str, Any]:
     """
     Execute validated Python expression in restricted environment.

{ha_mcp_dev-7.2.0.dev343 → ha_mcp_dev-7.2.0.dev345/src/ha_mcp_dev.egg-info}/PKG-INFO

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