ha-mcp-dev 9.0.0.dev3114__tar.gz → 9.0.0.dev3117__tar.gz

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ha-mcp-dev
-Version: 9.0.0.dev3114
+Version: 9.0.0.dev3117
 Summary: Home Assistant MCP Server - Complete control of Home Assistant through MCP
 Keywords: mcp,home-assistant,ai,automation,smart-home
 Author: Julien

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.0.0.dev3114"
+version = "9.0.0.dev3117"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 requires-python = ">=3.13,<3.15"

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "ha-mcp-dev"
-version = "9.0.0.dev3114"
+version = "9.0.0.dev3117"
 description = "Home Assistant MCP Server - Complete control of Home Assistant through MCP"
 readme = "README.md"
 # Upper bound widened to <3.15 so the package installs on Home Assistant's

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/requirements.txt

@@ -5,7 +5,7 @@
 # scripts/vendor_fastmcp.py (fastmcp-slim, mcp, mcp-types) before committing
 # a bump; tests/src/unit/test_vendored_*.py reject stale or altered trees.
 # For a manual pin change, run the same generator and commit its outputs.
-websockets==17.1
+websockets==17.2
 fastmcp-slim==4.1.0
 mcp==2.3.0
 mcp-types==2.3.0

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/MANIFEST.sha256

@@ -1,13 +1,13 @@
 3d6a0c050d8bec52fabad502e45fb25bd02bcadbd70dea34d447b6a0ff4e6da8  LICENSE
-e7a0229f98e8331a0e109d2e5a05d98fe445782329e54e418d0312589687c5af  VENDORED
+a6c00001a575dfb862e0d167e507325c4639b0c87ee7a337b0c734422727a404  VENDORED
 ce6042263ec421ae99244403a787487739dfcc025403c756e35fa3ec49be4034  __init__.py
 c2ee4ddb093c9af060cafaf68219907f8a6b7b301ed3f8bea75db7555adec987  __main__.py
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  asyncio/__init__.py
-76cd6b1f39464325281925529b466d73640be5c2ce8942bdf79edb3b42baf8e6  asyncio/client.py
+581192ec6ae3781ac4968b6ec38e64502ff1acfe38f72ba2a7d4c2066d7216b1  asyncio/client.py
 f2eb6ad56371fab33839a7ad2694e4b5610bea839bf92ae1f76e6d0a63f1e346  asyncio/connection.py
 bc13ddf7722e2f72c4d0e4b179a202223cefca886de7792687efd9868f9b1b35  asyncio/messages.py
 2453543482e4001e4ff5fb7a3cba2035a66aea9f765b3d7dbc89717f1d434e58  asyncio/router.py
-df846da778379c058b0da052731b9ba1f73390da0320c33330f03074b14ac6fc  asyncio/server.py
+f5aab916ff9bf604c77c8635879e80e223489ba05eaf921002471d5421316373  asyncio/server.py
 53f2709a7e7d65143a11e7293af322cd0086fd96c0be051fd6293b85a6510b77  auth.py
 7d87f462aad6231fe224303e45675cce1e6f8cef69e99c59be613beb56d4420d  cli.py
 eaf4e66220a92297bc794adc98494e63ea0aae21fa394c72a7e846a535af3cc7  client.py
@@ -16,8 +16,8 @@ eaf4e66220a92297bc794adc98494e63ea0aae21fa394c72a7e846a535af3cc7  client.py
 b69d3f132a907ddec260d3879b102278e1fc11df4f49016dd7c7be0ae45e4ce6  exceptions.py
 42466cc5a255965552a75ba1743e6e3c689b75bc7fd3dd46ad555f4b92d7729c  extensions/__init__.py
 24d7f2939e370bb56e3c7d103a86e2a8aa06af38c920b8deeaccf920bbce3e5e  extensions/base.py
-2005dd08663ad337dd8dab4a77a7c37d3322cce79062c9e1d3306d2fdbcfbb30  extensions/permessage_deflate.py
-4f08aa9ff6eebd089b94446e81c4fe3039a73d9ee4b7e14c5c449ed8384e4fda  frames.py
+d97d5fdd3e47b8e4176d89e61d7f8c937ab5b76d67f94fc585f8d2ea81c189bc  extensions/permessage_deflate.py
+62cb106e8c23dbadf19bb5e74006a18dc4650381ddcb5592058b61b1fc7c10fb  frames.py
 c909cf963559c15d7f57ea4e49128d2c6feef36ef0142d61ef671c8a88dc43c3  headers.py
 b4b56e36f3400f0b7c775ba2e4a305299099313b49e82a9766f7a880b68f6dfd  http11.py
 4ff07d4d4987a1c78a310f8f36985d410007d97771031c1240d790120a882e41  imports.py
@@ -27,29 +27,29 @@ e6826ead47333dd7578bc45d7b97c0da10f7578a67bfffd9eb8a514573fa1c1b  legacy/client.
 562123a684f4f5fcf1fd9a9fd1a3460d5b510cd8d768ec3481d0ad6b72e48c57  legacy/exceptions.py
 6f4c0cc7cdd74c85d56683bad299770226ca1db4250dbeeb040ca114491a3029  legacy/framing.py
 d8dcebe40376c6f0c2e4474d3fe901de539cac069436562e8fffa1aff8efee93  legacy/handshake.py
-70e0909835a120a4269bc5161973d6ec20d9834df08e8802b1bd0b3fda1eb4d4  legacy/http.py
+e51bb9a87d5dc09f440c0879f82089688eca021ae4e63edf554ffadf2e4a7de2  legacy/http.py
 dcc4e1d7ed24b564ad4425f4d252d5ebd80bcc5ffd8009fc60b144fdb664cd8c  legacy/protocol.py
 8529389c54ec23778c45bbb925c2388177a2f546f0d3b452ad28ed2f878cda07  legacy/server.py
 dc7b8204c2d324cc69f491dde49301aad4c5f384ac636f62b871f4cb39ee0ff4  protocol.py
-a05adb118b5ab185aff960dc9e239b0fd9c1479439aa41e9c8254b9e0c7b58c4  proxy.py
+83276f75aa0972dc7219166e91dd6f2a29aec65e046214f579ef5a3c7aa39193  proxy.py
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  py.typed
 ee41092f540414ef294c1f74c0fe1f51b9336060dc6e44daee34ef762499b509  server.py
 ac9ac33522fd872dc42587353c51e3631e2b75dd6f10b0ae6b40b074588737ff  streams.py
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  sync/__init__.py
-5b20fde3794aee3e0d40b23b3eaa3158411d77d98c2098e96b4344c71d3c3e3e  sync/client.py
-019a800cd64e13779c4e2a93ed636ad67b146eea23683169ccd89c10df702054  sync/connection.py
+0265d98a4c558359b7f727e5d4ebe6f4a637c5a4dfcd7797350dfacaf60c1ea4  sync/client.py
+dd9c4c859f4fcc8ccaccd168f02efc24b2567e39e1d10ccf78c93a87f94fe044  sync/connection.py
 abc2b5bf176ba959356ef9f7cd6d49c74f5395a908592c9870e1c2eee7854269  sync/messages.py
 c0e180bc66cac17caa98d1050425993f77da1efcbfd8c28deced977842fc9c62  sync/router.py
-5534fa4ec47e27e352596e657bc51531334d14dccfa7ac1b656b9541487e8d89  sync/server.py
+a316c9f5bb35f1264e636b9256b4e176d2cef06386c88279838c8541cabe5858  sync/server.py
 4ed5be9dc605bc99a2496da03bcea7804d8156c9e705d2fee07f3c91634361b8  sync/utils.py
 e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  trio/__init__.py
-9b637921a141acf61c52da755423d4a3cb49d94162d9f4381bef793382423b15  trio/client.py
+951e2e225679024d6027c09b720f371b7a773db90ed3400c2500ae9f9d8505b6  trio/client.py
 d571c39156caddefccf75a4e186798793d286b350ce4d8ea1cea30d0590dae06  trio/connection.py
 4a66c0d64fe58c41ae10764d2741cf0def3ea231ed313897191db41eb3c9b8a9  trio/messages.py
 a992fdfb8e268bd48e393194dc22c13ee68237369f406a99f9f265f61569bfeb  trio/router.py
-8d1b6b7d97f7847a75690a3a7df34c37bb22696cef65586a0b58aad7f3e3d2c0  trio/server.py
+0275d2a1425c780c854caa937060db6a3ac406ddaf9033289305af5925d4bb7f  trio/server.py
 035d8d6143ce8d06a21aeb1a938de85b33c8702c618a429390024b5ed649bdc6  trio/utils.py
 72ef3d9ff5d05e7a3f83da8fa459a12db6f39c4f8c2956b3500a30b36bb926a5  typing.py
-d9f14cc3e01b289e47547342bb0d51c7532790290d591a688315a184cdf4114e  uri.py
+4cd1600ef343a207c44b0fbbf17f140e487da49174dda7be76e8eda7113c04eb  uri.py
 59db6c876a908872eb5d40449e9dcb6ad30b253663076084adb78e16fadd5ef1  utils.py
-fa82d6b7f153a88ea409283331194af48235ef365eece9cbc359d6d99bea5c4b  version.py
+15757e2221681ad967e40fe2e5a612a46bdb4c11a25948114aca2ba4dbfcde1a  version.py

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/VENDORED

@@ -1,2 +1,2 @@
-websockets==17.1
+websockets==17.2
 Vendored by scripts/vendor_websockets.py — do not edit by hand.

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/asyncio/client.py

@@ -574,7 +574,7 @@ class connect:
         if hasattr(self, "connection"):
             raise RuntimeError("connect() isn't reentrant")
         self.connection = await self
-        return self.connection
+        return await self.connection.__aenter__()
 
     async def __aexit__(
         self,
@@ -583,7 +583,7 @@ class connect:
         traceback: TracebackType | None,
     ) -> None:
         try:
-            await self.connection.close()
+            return await self.connection.__aexit__(exc_type, exc_value, traceback)
         finally:
             del self.connection
 
@@ -734,6 +734,8 @@ class HTTPProxyConnection(asyncio.Protocol):
         self.response: asyncio.Future[Response] = loop.create_future()
 
     def run_parser(self) -> None:
+        if self.response.done():
+            return
         try:
             next(self.parser)
         except StopIteration as exc:

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/asyncio/server.py

@@ -552,16 +552,31 @@ def serve(
             await stop.wait()
 
     Alternatively, await it and call :meth:`~Server.serve_forever` to serve
-    requests, then cancel it or call :meth:`~Server.close` to stop the server::
+    requests, then cancel it to stop the server::
 
         server = await serve(handler, host, port)
         await server.serve_forever()
 
-    The following pattern is functional but redundant: by the time the context
+    Combining these two patterns works, but is unnecessary: when the context
     manager exits, :meth:`~Server.serve_forever` has already closed the server::
 
-        async with serve(handler, host, port) as server:
-            await server.serve_forever()
+        async with serve(handler, host, port) as server:  # don't do this!
+            await server.serve_forever()                  # it's redundant
+
+    You can also stop the server gracefully by calling its
+    :meth:`~Server.close` method::
+
+        server = await serve(handler, host, port)
+        try:
+            await stop.wait()
+        finally:
+            server.close()
+            await server.wait_closed()
+
+    By default, closing the server closes connections with code 1001 (going
+    away). You can keep connections alive and wait for clients to disconnect::
+
+        server.close(close_connections=False)
 
     Args:
         handler: Connection handler. It receives the WebSocket connection,
@@ -668,8 +683,7 @@ def serve(
         if kwargs.pop("unix", False):
             return await loop.create_unix_server(protocol_factory, **kwargs)
         else:
-            # mypy cannot tell that kwargs must provide sock when port is None.
-            return await loop.create_server(protocol_factory, host, port, **kwargs)  # type: ignore[arg-type]
+            return await loop.create_server(protocol_factory, host, port, **kwargs)
 
     def protocol_factory() -> ServerConnection:
         """
@@ -744,12 +758,10 @@ def serve(
             server.all_connections.add(connection)
             connection.start_keepalive()
             try:
-                await handler(connection)
+                async with connection:
+                    await handler(connection)
             except Exception:
                 connection.logger.error("connection handler failed", exc_info=True)
-                await connection.close(CloseCode.INTERNAL_ERROR)
-            else:
-                await connection.close()
             finally:
                 server.all_connections.discard(connection)
 

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/extensions/permessage_deflate.py

@@ -56,7 +56,10 @@ class PerMessageDeflate(Extension):
         assert remote_no_context_takeover in [False, True]
         assert local_no_context_takeover in [False, True]
         assert 8 <= remote_max_window_bits <= 15
-        assert 8 <= local_max_window_bits <= 15
+        # Due to https://github.com/madler/zlib/issues/171, zlib.compressobj
+        # rejects wbits=-8 with ValueError: Invalid initialization option.
+        # This makes it impossible to support local_max_window_bits = 8.
+        assert 9 <= local_max_window_bits <= 15
         assert "wbits" not in compress_settings
 
         self.remote_no_context_takeover = remote_no_context_takeover
@@ -314,11 +317,13 @@ class ClientPerMessageDeflateFactory(ClientExtensionFactory):
         server_max_window_bits: Maximum size of the server's LZ77 sliding window
             in bits, between 8 and 15.
         client_max_window_bits: Maximum size of the client's LZ77 sliding window
-            in bits, between 8 and 15, or :obj:`True` to indicate support without
-            setting a limit.
+            in bits, between 9 and 15, or :obj:`True` to indicate support without
+            setting a limit. 8 isn't supported due to a `limitation of zlib`_.
         compress_settings: Additional keyword arguments for :func:`zlib.compressobj`,
             excluding ``wbits``.
 
+    .. _limitation of zlib: https://github.com/madler/zlib/issues/171
+
     """
 
     name = ExtensionName("permessage-deflate")
@@ -340,9 +345,9 @@ class ClientPerMessageDeflateFactory(ClientExtensionFactory):
         if not (
             client_max_window_bits is None
             or client_max_window_bits is True
-            or 8 <= client_max_window_bits <= 15
+            or 9 <= client_max_window_bits <= 15
         ):
-            raise ValueError("client_max_window_bits must be between 8 and 15")
+            raise ValueError("client_max_window_bits must be between 9 and 15")
         if compress_settings is not None and "wbits" in compress_settings:
             raise ValueError(
                 "compress_settings must not include wbits, "
@@ -464,6 +469,9 @@ class ClientPerMessageDeflateFactory(ClientExtensionFactory):
             elif client_max_window_bits > self.client_max_window_bits:
                 raise NegotiationError("unsupported client_max_window_bits")
 
+        if client_max_window_bits == 8:
+            raise NegotiationError("unsupported client_max_window_bits = 8, use 9")
+
         return PerMessageDeflate(
             server_no_context_takeover,  # remote_no_context_takeover
             client_no_context_takeover,  # local_no_context_takeover
@@ -512,7 +520,8 @@ class ServerPerMessageDeflateFactory(ServerExtensionFactory):
         server_no_context_takeover: Prevent server from using context takeover.
         client_no_context_takeover: Prevent client from using context takeover.
         server_max_window_bits: Maximum size of the server's LZ77 sliding window
-            in bits, between 8 and 15.
+            in bits, between 9 and 15. 8 isn't supported due to a `limitation of
+            zlib`_.
         client_max_window_bits: Maximum size of the client's LZ77 sliding window
             in bits, between 8 and 15.
         compress_settings: Additional keyword arguments for :func:`zlib.compressobj`,
@@ -522,6 +531,8 @@ class ServerPerMessageDeflateFactory(ServerExtensionFactory):
             the default behavior is to enable compression without enforcing
             ``client_max_window_bits``.
 
+    .. _limitation of zlib: https://github.com/madler/zlib/issues/171
+
     """
 
     name = ExtensionName("permessage-deflate")
@@ -539,8 +550,8 @@ class ServerPerMessageDeflateFactory(ServerExtensionFactory):
         Configure the Per-Message Deflate extension factory.
 
         """
-        if not (server_max_window_bits is None or 8 <= server_max_window_bits <= 15):
-            raise ValueError("server_max_window_bits must be between 8 and 15")
+        if not (server_max_window_bits is None or 9 <= server_max_window_bits <= 15):
+            raise ValueError("server_max_window_bits must be between 9 and 15")
         if not (client_max_window_bits is None or 8 <= client_max_window_bits <= 15):
             raise ValueError("client_max_window_bits must be between 8 and 15")
         if compress_settings is not None and "wbits" in compress_settings:
@@ -633,6 +644,9 @@ class ServerPerMessageDeflateFactory(ServerExtensionFactory):
             elif server_max_window_bits > self.server_max_window_bits:
                 server_max_window_bits = self.server_max_window_bits
 
+        if server_max_window_bits == 8:
+            raise NegotiationError("unsupported server_max_window_bits = 8, use 9")
+
         # client_max_window_bits
 
         #   Config  Req.    Resp.

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/frames.py

@@ -4,6 +4,7 @@ import dataclasses
 import enum
 import io
 import os
+import re
 import secrets
 import struct
 from collections.abc import Generator, Sequence
@@ -26,6 +27,8 @@ __all__ = [
     "Close",
 ]
 
+is_space_or_printable_ascii = re.compile(rb"[\x09-\x0D\x20-\x7E]*").fullmatch
+
 
 class Opcode(enum.IntEnum):
     """Opcode values for WebSocket frames."""
@@ -150,10 +153,8 @@ class Frame:
         conveniently. Instead, it shows the beginning and the end. It's robust
         to incorrect data.
 
-        It attempts to decode UTF-8 payloads whenever possible, even for binary
-        frames and control frames, because those frequently contain UTF-8 data.
-        It applies the same logic to continuation frames, because we don't know
-        if they continue a text frame or a binary frame.
+        It attempts to decode UTF-8 in data frames, even in binary frames,
+        because those frequently contain UTF-8 data.
 
         """
         expect_text = self.DEFAULT_IS_TEXT.get(self.opcode)
@@ -177,58 +178,76 @@ class Frame:
         This is a helper for the __str__ method.
 
         """
+        data_repr: str = ""
+        is_text: bool | None = None
+
         if not self.data:
             return "''", self.DEFAULT_IS_TEXT.get(self.opcode)
 
-        # Special case for close frames: parse close code and reason.
-        # Fall back to the standard case if the payload is malformed.
+        # Close frames: parse close code and reason and display them as text.
+        # Fall back to binary when the payload is malformed.
 
         if self.opcode is CLOSE:
             try:
-                return str(Close.parse(self.data)), True
+                data_repr = str(Close.parse(self.data))
+                is_text = True
             except (ProtocolError, UnicodeDecodeError):
-                pass
-
-        # Guess whether the payload is UTF-8 or binary, regardless of opcode, to
-        # display UTF-8 text in binary frames nicely and generally to be helpful
-        # and robust. Also support frames fragmented within UTF-8 sequences.
-
-        if len(self.data) > 4 * self.MAX_LOG_SIZE:
-            # Process only the start and the end, as the middle will be elided.
-            # Cast to bytes because self.data could be a memoryview.
-            data_start = bytes(self.data[: 8 * self.MAX_LOG_SIZE // 3])
-            data_end = bytes(self.data[-4 * self.MAX_LOG_SIZE // 3 :])
-            is_text = is_utf8_fragment(
-                data_start,
-                must_start_clean=self.opcode != CONT,
-            ) and is_utf8_fragment(
-                data_end,
-                must_end_clean=self.fin,
-            )
-            if is_text:
-                data_repr = repr((data_start + data_end).decode(errors="replace"))
+                data_repr = " ".join(f"{byte:02x}" for byte in self.data)
+                is_text = False
+
+        # Control frames: display printable ASCII payloads as text, else binary.
+        # We could decode UTF-8 payloads, but this causes confusion when random
+        # 4-bytes binary payloads are accidentally valid UTF-8 sequences.
+
+        elif self.opcode in CTRL_OPCODES:
+            if is_space_or_printable_ascii(self.data):
+                data_repr = repr(bytes(self.data).decode("ascii"))
+                is_text = True
+            else:
+                data_repr = " ".join(f"{byte:02x}" for byte in self.data)
+                is_text = False
+
+        # Data frames: check whether the payload is UTF-8, regardless of opcode,
+        # in order to display nicely UTF-8 text in binary frames, and be robust.
+        # Also support frames fragmented within UTF-8 sequences.
 
         else:
-            # Cast to bytes because self.data could be a memoryview.
-            data = bytes(self.data)
-            is_text = is_utf8_fragment(
-                data,
-                must_start_clean=self.opcode != CONT,
-                must_end_clean=self.fin,
-            )
-            if is_text:
-                data_repr = repr(data.decode(errors="replace"))
-
-        # When the payload is text (except perhaps for boundaries), we decoded
-        # enough in ``data_repr``. Now, do the same when the payload is binary.
-
-        if not is_text:
-            binary = self.data
-            if len(binary) > self.MAX_LOG_SIZE // 3:
-                cut = (self.MAX_LOG_SIZE // 3 - 1) // 3  # by default cut = 8
-                # Encode two dummy bytes to force eliding and adding an ellipsis.
-                binary = b"".join([binary[: 2 * cut], b"\x00\x00", binary[-cut:]])
-            data_repr = " ".join(f"{byte:02x}" for byte in binary)
+            if len(self.data) > 4 * self.MAX_LOG_SIZE:
+                # Process only the start and end, as the middle will be elided.
+                # Cast to bytes because self.data could be a memoryview.
+                data_start = bytes(self.data[: 8 * self.MAX_LOG_SIZE // 3])
+                data_end = bytes(self.data[-4 * self.MAX_LOG_SIZE // 3 :])
+                is_text = is_utf8_fragment(
+                    data_start,
+                    must_start_clean=self.opcode != CONT,
+                ) and is_utf8_fragment(
+                    data_end,
+                    must_end_clean=self.fin,
+                )
+                if is_text:
+                    data_repr = repr((data_start + data_end).decode(errors="replace"))
+
+            else:
+                # Cast to bytes because self.data could be a memoryview.
+                data = bytes(self.data)
+                is_text = is_utf8_fragment(
+                    data,
+                    must_start_clean=self.opcode != CONT,
+                    must_end_clean=self.fin,
+                )
+                if is_text:
+                    data_repr = repr(data.decode(errors="replace"))
+
+            # When the payload is text (except perhaps for boundaries), we have
+            # enough in ``data_repr``. Do the same when the payload is binary.
+
+            if not is_text:
+                binary = self.data
+                if len(binary) > self.MAX_LOG_SIZE // 3:
+                    cut = (self.MAX_LOG_SIZE // 3 - 1) // 3  # by default cut = 8
+                    # Encode two dummy bytes to force eliding and adding an ellipsis.
+                    binary = b"".join([binary[: 2 * cut], b"\x00\x00", binary[-cut:]])
+                data_repr = " ".join(f"{byte:02x}" for byte in binary)
 
         # Elide the middle of the representation to fit the maximum log size.
 

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/legacy/http.py

@@ -175,7 +175,9 @@ async def read_headers(stream: asyncio.StreamReader) -> Headers:
 
         name = raw_name.decode("ascii")  # guaranteed to be ASCII at this point
         value = raw_value.decode("ascii", "surrogateescape")
-        headers[name] = value
+
+        # Since we just validated raw_value, we don't need to revalidate it.
+        headers.set_insecure(name, value)
 
     else:
         raise SecurityError("too many HTTP headers")

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/proxy.py

@@ -8,7 +8,7 @@ from .datastructures import Headers
 from .exceptions import InvalidProxy
 from .headers import build_authorization_basic, build_host
 from .http11 import USER_AGENT
-from .uri import DELIMS, WebSocketURI
+from .uri import WebSocketURI
 
 
 __all__ = ["get_proxy", "parse_proxy", "Proxy"]
@@ -78,8 +78,11 @@ def parse_proxy(proxy: str) -> Proxy:
     password = parsed.password
     # urllib.parse.urlparse accepts URLs with a username but without a
     # password. This doesn't make sense for HTTP Basic Auth credentials.
-    if username is not None and password is None:
-        raise InvalidProxy(proxy, "username provided without password")
+    if username is not None:
+        if password is None:
+            raise InvalidProxy(proxy, "username provided without password")
+        username = urllib.parse.unquote(username, errors="strict")
+        password = urllib.parse.unquote(password, errors="strict")
 
     try:
         proxy.encode("ascii")
@@ -87,10 +90,6 @@ def parse_proxy(proxy: str) -> Proxy:
         # Input contains non-ASCII characters.
         # It must be an IRI. Convert it to a URI.
         host = host.encode("idna").decode()
-        if username is not None:
-            assert password is not None
-            username = urllib.parse.quote(username, safe=DELIMS)
-            password = urllib.parse.quote(password, safe=DELIMS)
 
     return Proxy(scheme, host, port, username, password)
 

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/sync/client.py

@@ -521,7 +521,7 @@ class reconnect:
             raise RuntimeError("connect() isn't reentrant")
         self.connection = self.connect()
         self.connection.pending_legacy_warning = False
-        return self.connection
+        return self.connection.__enter__()
 
     def __exit__(
         self,
@@ -530,7 +530,7 @@ class reconnect:
         exc_traceback: TracebackType | None,
     ) -> None:
         try:
-            self.connection.close()
+            return self.connection.__exit__(exc_type, exc_value, exc_traceback)
         finally:
             del self.connection
 

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/sync/connection.py

@@ -612,6 +612,26 @@ class Connection:
             # They mean that the connection is closed, which was the goal.
             pass
 
+    def wait_closed(self, timeout: float | None = None) -> bool:
+        """
+        Wait until the connection is closed.
+
+        :meth:`wait_closed` waits for the closing handshake to complete and for
+        the TCP connection to terminate.
+
+        If a timeout is provided and elapses before the connection is closed,
+        :meth:`wait_closed` returns :obj:`False`. Else, it returns :obj:`True`.
+
+        Args:
+            timeout: Optional timeout in seconds.
+
+        Returns:
+            Whether the connection is closed.
+
+        """
+        self.recv_events_thread.join(timeout)
+        return not self.recv_events_thread.is_alive()
+
     def ping(
         self,
         data: DataLike | None = None,

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/sync/server.py

@@ -314,16 +314,20 @@ class Server:
 
         try:
             try:
+                # Capture the socket name to prevent a race condition in case
+                # the socket is closed between registering it with the poller
+                # and logging the "server listening on ..." message.
+                socket_name = get_socket_name(self.socket)
                 poller.register(self.socket, selectors.EVENT_READ)
             except (OSError, ValueError):  # pragma: no cover
-                # shutdown() was called before poller.register().
+                # shutdown() ran before get_socket_name() or poller.register().
                 # This may result in:
                 # * OSError: [Errno 9] Bad file descriptor
-                #   (only observed on free-threaded Python)
+                #   (only seen on free-threaded Python for poller.register())
                 # * ValueError: Invalid file descriptor: -1
                 return
 
-            self.logger.info("server listening on %s", get_socket_name(self.socket))
+            self.logger.info("server listening on %s", socket_name)
 
             while True:
                 poller.select()
@@ -540,8 +544,15 @@ def serve(
         with serve(handler, ...) as server:
             server.serve_forever()
 
-        To stop the server gracefully, call its :meth:`~Server.shutdown` method
-        from another thread.
+    You can stop the server gracefully by calling its :meth:`~Server.shutdown`
+    method from another thread::
+
+        server.shutdown()
+
+    By default, closing the server closes connections with code 1001 (going
+    away). You can keep connections alive and wait for clients to disconnect::
+
+        server.shutdown(close_connections=False)
 
     Args:
         handler: Connection handler. It receives the WebSocket connection,
@@ -766,12 +777,10 @@ def serve(
                 server.all_connections.add(connection)
             connection.start_keepalive()
             try:
-                handler(connection)
+                with connection:
+                    handler(connection)
             except Exception:
                 connection.logger.error("connection handler failed", exc_info=True)
-                connection.close(CloseCode.INTERNAL_ERROR)
-            else:
-                connection.close()
             finally:
                 with server.lock:
                     server.all_connections.discard(connection)

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/trio/client.py

@@ -549,7 +549,7 @@ class connect:
         await self.__aenter_nursery__()
         try:
             self.connection = await self.connect(self.nursery)
-            return self.connection
+            return await self.connection.__aenter__()
         except BaseException as exc:
             await self.__aexit_nursery__(type(exc), exc, exc.__traceback__)
             raise AssertionError("expected __aexit_nursery__ to re-raise the exception")
@@ -562,7 +562,7 @@ class connect:
     ) -> None:
         try:
             try:
-                await self.connection.aclose()
+                return await self.connection.__aexit__(exc_type, exc_value, traceback)
             finally:
                 del self.connection
         finally:

{ha_mcp_dev-9.0.0.dev3114 → ha_mcp_dev-9.0.0.dev3117}/src/ha_mcp/_vendor/websockets/trio/server.py

@@ -439,7 +439,7 @@ async def serve(
             async with server:
                 await stop.wait()
 
-    Alternatively, to stop the server gracefully, call its
+    Alternatively, you can stop the server gracefully by calling its
     :meth:`~Server.aclose` method::
 
         with trio.open_nursery() as nursery:
@@ -449,6 +449,11 @@ async def serve(
             finally:
                 await server.aclose()
 
+    By default, closing the server closes connections with code 1001 (going
+    away). You can keep connections alive and wait for clients to disconnect::
+
+        await server.aclose(close_connections=False)
+
     Args:
         handler: Connection handler. It receives the WebSocket connection,
             which is a :class:`ServerConnection`, in argument.
@@ -639,12 +644,10 @@ async def serve(
                 server.all_connections.add(connection)
                 connection.start_keepalive()
                 try:
-                    await handler(connection)
+                    async with connection:
+                        await handler(connection)
                 except Exception:
                     connection.logger.error("connection handler failed", exc_info=True)
-                    await connection.aclose(CloseCode.INTERNAL_ERROR)
-                else:
-                    await connection.aclose()
                 finally:
                     server.all_connections.discard(connection)