ha-mcp-dev 6.7.2.dev251__tar.gz → 6.7.2.dev253__tar.gz

{ha_mcp_dev-6.7.2.dev251/src/ha_mcp_dev.egg-info → ha_mcp_dev-6.7.2.dev253}/PKG-INFO

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

{ha_mcp_dev-6.7.2.dev251 → ha_mcp_dev-6.7.2.dev253}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ha-mcp-dev"
-version = "6.7.2.dev251"
+version = "6.7.2.dev253"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.14"

{ha_mcp_dev-6.7.2.dev251 → ha_mcp_dev-6.7.2.dev253}/src/ha_mcp/client/rest_client.py

@@ -684,8 +684,10 @@ class HomeAssistantClient:
     async def send_websocket_message(self, message: dict[str, Any]) -> dict[str, Any]:
         """Send message via WebSocket and wait for response.
 
-        Uses the global WebSocket singleton to avoid race conditions from
-        parallel tool calls creating multiple simultaneous connections.
+        Uses a per-client WebSocket connection keyed to the client's own
+        credentials (base_url + token). This ensures OAuth mode uses the
+        real HA credentials from the token claims, not the global sentinel
+        settings.
         """
         from .websocket_client import get_websocket_client
 
@@ -694,8 +696,10 @@ class HomeAssistantClient:
 
         for attempt in range(max_retries):
             try:
-                # Use singleton WebSocket client (shared, reused connection)
-                ws_client = await get_websocket_client()
+                # Use per-client WebSocket keyed to this client's credentials
+                ws_client = await get_websocket_client(
+                    url=self.base_url, token=self.token
+                )
 
                 # Special handling for render_template which returns an event with the actual result
                 if message.get("type") == "render_template":

{ha_mcp_dev-6.7.2.dev251 → ha_mcp_dev-6.7.2.dev253}/src/ha_mcp/client/websocket_client.py

@@ -8,6 +8,7 @@ This module handles WebSocket connections to Home Assistant for:
 """
 
 import asyncio
+import hashlib
 import json
 import logging
 import time
@@ -553,11 +554,21 @@ class HomeAssistantWebSocketClient:
 
 
 
+MAX_POOL_SIZE = 50
+
+
 class WebSocketManager:
-    """Singleton manager for Home Assistant WebSocket connections."""
+    """Singleton manager for Home Assistant WebSocket connections.
+
+    Maintains a pool of WebSocket connections keyed by (url, token) so that
+    multiple OAuth users can have concurrent connections without interfering
+    with each other.  The pool is bounded to ``MAX_POOL_SIZE`` entries; when
+    this limit is exceeded the least-recently-used connection is evicted.
+    """
 
     _instance = None
-    _client = None
+    _clients: dict[str, HomeAssistantWebSocketClient]
+    _last_used: dict[str, float]
     _current_loop: asyncio.AbstractEventLoop | None = None
     _lock: asyncio.Lock | None = None
     _lock_loop: asyncio.AbstractEventLoop | None = None
@@ -566,6 +577,8 @@ class WebSocketManager:
     def __new__(cls) -> "WebSocketManager":
         if cls._instance is None:
             cls._instance = super().__new__(cls)
+            cls._instance._clients = {}
+            cls._instance._last_used = {}
             cls._instance._lock = None
             cls._instance._lock_loop = None
             cls._instance._client_factory = HomeAssistantWebSocketClient
@@ -600,8 +613,28 @@ class WebSocketManager:
             self._lock_loop = current_loop
             logger.debug("Created new WebSocketManager lock for current event loop")
 
-    async def get_client(self) -> HomeAssistantWebSocketClient:
-        """Get WebSocket client, creating connection if needed."""
+    @staticmethod
+    def _client_key(url: str, token: str) -> str:
+        """Create a cache key from credentials."""
+        return hashlib.sha256(f"{url.rstrip('/')}:{token}".encode()).hexdigest()
+
+    async def get_client(
+        self,
+        url: str | None = None,
+        token: str | None = None,
+    ) -> HomeAssistantWebSocketClient:
+        """Get WebSocket client, creating connection if needed.
+
+        Maintains a pool of connections keyed by credentials. In OAuth mode,
+        each user gets their own connection. In non-OAuth mode, the global
+        settings are used as the key.
+
+        Args:
+            url: Optional HA URL. If provided with token, uses these
+                 credentials instead of global settings. This is required
+                 for OAuth mode where each request has its own credentials.
+            token: Optional HA token. Must be provided with url.
+        """
         current_loop = asyncio.get_event_loop()
 
         self._ensure_lock()
@@ -610,47 +643,96 @@ class WebSocketManager:
             raise Exception("Lock not initialized")
         async with self._lock:
             if self._current_loop is not None and self._current_loop != current_loop:
-                if self._client:
+                # Event loop changed — disconnect all clients
+                for client in self._clients.values():
                     try:
-                        await self._client.disconnect()
+                        await client.disconnect()
                     except Exception:
                         pass
-                    self._client = None
+                self._clients.clear()
+                self._last_used.clear()
 
             self._current_loop = current_loop
 
-            if self._client and self._client.is_connected:
-                return self._client
+            # Determine credentials to use
+            if url and token:
+                ws_url = url
+                ws_token = token
+            else:
+                settings = get_global_settings()
+                ws_url = settings.homeassistant_url
+                ws_token = settings.homeassistant_token
+
+            key = self._client_key(ws_url, ws_token)
+
+            # Return existing connected client for these credentials
+            existing = self._clients.get(key)
+            if existing and existing.is_connected:
+                self._last_used[key] = time.monotonic()
+                return existing
+
+            # Remove stale client if present
+            if existing:
+                self._clients.pop(key, None)
+                self._last_used.pop(key, None)
 
-            settings = get_global_settings()
             factory = self._client_factory or HomeAssistantWebSocketClient
-            self._client = factory(
-                settings.homeassistant_url, settings.homeassistant_token
-            )
+            client = factory(ws_url, ws_token)
 
-            connected = await self._client.connect()
+            connected = await client.connect()
             if not connected:
                 raise Exception("Failed to connect to Home Assistant WebSocket")
 
-            return self._client
+            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=self._last_used.get)
+                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,
+                        )
+
+            return client
 
     async def disconnect(self) -> None:
-        """Disconnect WebSocket client."""
+        """Disconnect all WebSocket clients."""
         self._ensure_lock()
 
         if not self._lock:
             raise Exception("Lock not initialized")
         async with self._lock:
-            if self._client:
-                await self._client.disconnect()
-                self._client = None
-                self._current_loop = None
+            for client in self._clients.values():
+                try:
+                    await client.disconnect()
+                except Exception:
+                    logger.warning(
+                        "Error disconnecting WebSocket client", exc_info=True
+                    )
+            self._clients.clear()
+            self._last_used.clear()
+            self._current_loop = None
 
 
 # Global WebSocket manager instance
 websocket_manager = WebSocketManager()
 
 
-async def get_websocket_client() -> HomeAssistantWebSocketClient:
-    """Get the global WebSocket client instance."""
-    return await websocket_manager.get_client()
+async def get_websocket_client(
+    url: str | None = None,
+    token: str | None = None,
+) -> HomeAssistantWebSocketClient:
+    """Get the global WebSocket client instance.
+
+    Args:
+        url: Optional HA URL for per-client credentials (OAuth mode).
+        token: Optional HA token for per-client credentials (OAuth mode).
+    """
+    return await websocket_manager.get_client(url=url, token=token)

{ha_mcp_dev-6.7.2.dev251 → ha_mcp_dev-6.7.2.dev253/src/ha_mcp_dev.egg-info}/PKG-INFO

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