ha-mcp-dev 6.3.1.dev137__py3-none-any.whl

ha_mcp/server.py

@@ -0,0 +1,189 @@
+"""
+Core Smart MCP Server implementation.
+
+Implements lazy initialization pattern for improved startup time:
+- Settings and FastMCP server are created immediately (fast)
+- Smart tools and device tools are created lazily on first access
+- Tool modules are discovered at startup but imported on first use
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from fastmcp import FastMCP
+from mcp.types import Icon
+
+from .config import get_global_settings
+from .tools.enhanced import EnhancedToolsMixin
+
+if TYPE_CHECKING:
+    from .client.rest_client import HomeAssistantClient
+    from .tools.registry import ToolsRegistry
+
+logger = logging.getLogger(__name__)
+
+# Server icon configuration using GitHub-hosted images
+# These icons are bundled in packaging/mcpb/ and also available via GitHub raw URLs
+SERVER_ICONS = [
+    Icon(
+        src="https://raw.githubusercontent.com/homeassistant-ai/ha-mcp/master/packaging/mcpb/icon.svg",
+        mimeType="image/svg+xml",
+    ),
+    Icon(
+        src="https://raw.githubusercontent.com/homeassistant-ai/ha-mcp/master/packaging/mcpb/icon-128.png",
+        mimeType="image/png",
+        sizes=["128x128"],
+    ),
+]
+
+
+class HomeAssistantSmartMCPServer(EnhancedToolsMixin):
+    """Home Assistant MCP Server with smart tools and fuzzy search.
+
+    Uses lazy initialization to improve startup time:
+    - Client, smart_tools, device_tools are created on first access
+    - Tool modules are discovered at startup but imported when first called
+    """
+
+    def __init__(
+        self,
+        client: HomeAssistantClient | None = None,
+        server_name: str = "ha-mcp",
+        server_version: str = "0.1.0",
+    ):
+        """Initialize the smart MCP server with lazy loading support."""
+        # Load settings first (fast operation)
+        self.settings = get_global_settings()
+
+        # Store provided client or mark for lazy creation
+        self._client: HomeAssistantClient | None = client
+        self._client_provided = client is not None
+
+        # Lazy initialization placeholders
+        self._smart_tools: Any = None
+        self._device_tools: Any = None
+        self._tools_registry: ToolsRegistry | None = None
+
+        # Get server name/version from settings if no client provided
+        if not self._client_provided:
+            server_name = self.settings.mcp_server_name
+            server_version = self.settings.mcp_server_version
+
+        # Create FastMCP server with Home Assistant icons for client UI display
+        self.mcp = FastMCP(name=server_name, version=server_version, icons=SERVER_ICONS)
+
+        # Register all tools and expert prompts
+        self._initialize_server()
+
+    @property
+    def client(self) -> HomeAssistantClient:
+        """Lazily create and return the Home Assistant client."""
+        if self._client is None:
+            from .client.rest_client import HomeAssistantClient
+            self._client = HomeAssistantClient()
+            logger.debug("Lazily created HomeAssistantClient")
+        return self._client
+
+    @property
+    def smart_tools(self) -> Any:
+        """Lazily create and return the smart search tools."""
+        if self._smart_tools is None:
+            from .tools.smart_search import create_smart_search_tools
+            self._smart_tools = create_smart_search_tools(self.client)
+            logger.debug("Lazily created SmartSearchTools")
+        return self._smart_tools
+
+    @property
+    def device_tools(self) -> Any:
+        """Lazily create and return the device control tools."""
+        if self._device_tools is None:
+            from .tools.device_control import create_device_control_tools
+            self._device_tools = create_device_control_tools(self.client)
+            logger.debug("Lazily created DeviceControlTools")
+        return self._device_tools
+
+    @property
+    def tools_registry(self) -> ToolsRegistry:
+        """Lazily create and return the tools registry."""
+        if self._tools_registry is None:
+            from .tools.registry import ToolsRegistry
+            self._tools_registry = ToolsRegistry(
+                self, enabled_modules=self.settings.enabled_tool_modules
+            )
+            logger.debug("Lazily created ToolsRegistry")
+        return self._tools_registry
+
+    def _initialize_server(self) -> None:
+        """Initialize all server components."""
+        # Register tools
+        self.tools_registry.register_all_tools()
+
+        # Register enhanced tools for first/second interaction success
+        self.register_enhanced_tools()
+
+    # Helper methods required by EnhancedToolsMixin
+
+    async def smart_entity_search(
+        self, query: str, domain_filter: str | None = None, limit: int = 10
+    ) -> dict[str, Any]:
+        """Bridge method to existing smart search implementation."""
+        return await self.smart_tools.smart_entity_search(
+            query=query, limit=limit, include_attributes=False
+        )
+
+    async def get_entity_state(self, entity_id: str) -> dict[str, Any]:
+        """Bridge method to existing entity state implementation."""
+        return await self.client.get_entity_state(entity_id)
+
+    async def call_service(
+        self,
+        domain: str,
+        service: str,
+        entity_id: str | None = None,
+        data: dict | None = None,
+    ) -> list[dict[str, Any]]:
+        """Bridge method to existing service call implementation."""
+        service_data = data or {}
+        if entity_id:
+            service_data["entity_id"] = entity_id
+        return await self.client.call_service(domain, service, service_data)
+
+    async def get_entities_by_area(self, area_name: str) -> dict[str, Any]:
+        """Bridge method to existing area functionality."""
+        return await self.smart_tools.get_entities_by_area(
+            area_query=area_name, group_by_domain=True
+        )
+
+    async def start(self) -> None:
+        """Start the Smart MCP server with async compatibility."""
+        logger.info(
+            f"🚀 Starting Smart {self.settings.mcp_server_name} v{self.settings.mcp_server_version}"
+        )
+
+        # Test connection on startup
+        try:
+            success, error = await self.client.test_connection()
+            if success:
+                config = await self.client.get_config()
+                logger.info(
+                    f"✅ Successfully connected to Home Assistant: {config.get('location_name', 'Unknown')}"
+                )
+            else:
+                logger.warning(f"⚠️ Failed to connect to Home Assistant: {error}")
+        except Exception as e:
+            logger.error(f"❌ Error testing connection: {e}")
+
+        # Log available tools count
+        logger.info("🔧 Smart server with enhanced tools loaded")
+
+        # Run the MCP server with async compatibility
+        await self.mcp.run_async()
+
+    async def close(self) -> None:
+        """Close the MCP server and cleanup resources."""
+        # Only close client if it was actually created
+        if self._client is not None and hasattr(self._client, "close"):
+            await self._client.close()
+        logger.info("🔧 Home Assistant Smart MCP Server closed")

ha_mcp/smoke_test.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""Smoke test for ha-mcp binary - verifies all dependencies are bundled correctly."""
+
+import os
+import sys
+
+# Force UTF-8 encoding on Windows for Unicode output
+if sys.platform == "win32":
+    sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+
+# Set dummy credentials before any imports try to use them
+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)
+
+    errors = []
+
+    # Test 1: Critical library imports
+    print("\n[1/4] Testing critical library imports...")
+    critical_imports = [
+        ("fastmcp", "FastMCP framework"),
+        ("httpx", "HTTP client"),
+        ("pydantic", "Data validation"),
+        ("click", "CLI framework"),
+        ("websockets", "WebSocket support"),
+    ]
+
+    for module_name, description in critical_imports:
+        try:
+            __import__(module_name)
+            print(f"  ✓ {module_name} ({description})")
+        except ImportError as e:
+            errors.append(f"Failed to import {module_name}: {e}")
+            print(f"  ✗ {module_name} ({description}) - FAILED: {e}")
+
+    # Test 2: Server module import
+    print("\n[2/4] Testing server module import...")
+    try:
+        from ha_mcp.server import HomeAssistantSmartMCPServer
+        print("  ✓ Server module imported successfully")
+    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
+
+    # Test 3: Server instantiation
+    print("\n[3/4] Testing server instantiation...")
+    try:
+        server = HomeAssistantSmartMCPServer()
+        mcp = server.mcp
+        print(f"  ✓ Server created: {mcp.name}")
+    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
+
+    # Test 4: Tool discovery
+    print("\n[4/4] Testing tool discovery...")
+    try:
+        # Access the tools from the MCP instance
+        tool_count = len(mcp._tool_manager._tools)
+        print(f"  ✓ Discovered {tool_count} tools")
+
+        if tool_count < 50:
+            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 = list(mcp._tool_manager._tools.keys())[:5]
+            print(f"  ✓ Sample tools: {', '.join(tool_names)}...")
+    except Exception as e:
+        errors.append(f"Failed to discover tools: {e}")
+        print(f"  ✗ Tool discovery - FAILED: {e}")
+
+    # Summary
+    print("\n" + "=" * 60)
+    if errors:
+        print(f"SMOKE TEST FAILED: {len(errors)} error(s)")
+        for error in errors:
+            print(f"  - {error}")
+        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
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ha_mcp/tools/__init__.py

@@ -0,0 +1,11 @@
+"""Custom tools for the Home Assistant MCP server."""
+
+from .device_control import DeviceControlTools, create_device_control_tools
+from .smart_search import SmartSearchTools, create_smart_search_tools
+
+__all__ = [
+    "SmartSearchTools",
+    "create_smart_search_tools",
+    "DeviceControlTools",
+    "create_device_control_tools",
+]