fix(ws): send binary frames so QWebSocket clients receive them

The Python desktop client (FAForever/client, PyQt6 QWebSocket) listens
on binaryMessageReceived only, so server-to-client traffic was silently
dropped on the floor after the WS handshake. The Kotlin client reads
the raw byte stream as UTF-8 regardless of frame type, so binary works
for both clients.

Switch write_raw from send_str to send_bytes. Tests follow.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Brutus5000

server/protocol/websocket.py

@@ -1,4 +1,4 @@
-"""WebSocket wire protocol: one JSON message per text frame, no extra framing."""
+"""WebSocket wire protocol: newline-terminated JSON inside binary WS frames."""
 
 import asyncio
 import contextlib
@@ -48,8 +48,13 @@ def write_raw(self, data: bytes) -> None:
         if not self.is_connected():
             raise DisconnectedError("Protocol is not connected!")
 
-        text = data.decode() if isinstance(data, (bytes, bytearray)) else data
-        task = asyncio.create_task(self.ws.send_str(text))
+        # Send as a binary frame: the legacy Python desktop client (PyQt6
+        # QWebSocket) only listens on binaryMessageReceived, and the Kotlin
+        # client reads the raw byte stream as UTF-8 regardless of frame type,
+        # so binary is the lowest common denominator.
+        if isinstance(data, str):
+            data = data.encode()
+        task = asyncio.create_task(self.ws.send_bytes(data))
         self._pending.add(task)
         task.add_done_callback(self._pending.discard)
 

tests/integration_tests/test_servercontext.py

@@ -93,7 +93,7 @@ async def test_serverside_abort(
     ctx = mock_context
     async with aiohttp.ClientSession() as session:
         async with session.ws_connect(ws_url(ctx)) as ws:
-            await ws.send_str('{"some_junk": true}')
+            await ws.send_bytes(b'{"some_junk": true}\n')
             await exhaust_callbacks()
 
     # Allow server-side disconnect handler to run.

tests/unit_tests/test_websocket_protocol.py

@@ -71,15 +71,15 @@ async def test_write_raw_when_disconnected_raises():
         proto.write_raw(b'{"command":"ping"}')
 
 
-async def test_send_message_routes_through_send_str():
+async def test_send_message_routes_through_send_bytes():
     ws = mock.MagicMock()
     ws.closed = False
-    ws.send_str = mock.AsyncMock()
+    ws.send_bytes = mock.AsyncMock()
 
     proto = WebSocketProtocol(ws)
     await proto.send_message({"command": "ping"})
 
-    ws.send_str.assert_awaited_once_with('{"command":"ping"}\n')
+    ws.send_bytes.assert_awaited_once_with(b'{"command":"ping"}\n')
 
 
 async def test_write_message_when_disconnected_raises():
@@ -91,28 +91,28 @@ async def test_write_message_when_disconnected_raises():
         proto.write_message({"command": "ping"})
 
 
-async def test_write_message_routes_through_send_str():
+async def test_write_message_routes_through_send_bytes():
     ws = mock.MagicMock()
     ws.closed = False
-    ws.send_str = mock.AsyncMock()
+    ws.send_bytes = mock.AsyncMock()
 
     proto = WebSocketProtocol(ws)
     proto.write_message({"command": "ping"})
     await proto.drain()
 
-    ws.send_str.assert_awaited_once_with('{"command":"ping"}\n')
+    ws.send_bytes.assert_awaited_once_with(b'{"command":"ping"}\n')
 
 
 async def test_write_messages_sends_each():
     ws = mock.MagicMock()
     ws.closed = False
-    ws.send_str = mock.AsyncMock()
+    ws.send_bytes = mock.AsyncMock()
 
     proto = WebSocketProtocol(ws)
     proto.write_messages([{"command": "ping"}, {"command": "pong"}])
     await proto.drain()
 
-    assert ws.send_str.await_count == 2
+    assert ws.send_bytes.await_count == 2
 
 
 async def test_write_messages_when_disconnected_raises():
@@ -135,7 +135,7 @@ async def test_drain_no_pending_returns_immediately():
 async def test_drain_propagates_failure_as_disconnected():
     ws = mock.MagicMock()
     ws.closed = False
-    ws.send_str = mock.AsyncMock(side_effect=RuntimeError("boom"))
+    ws.send_bytes = mock.AsyncMock(side_effect=RuntimeError("boom"))
     ws.close = mock.AsyncMock()
 
     proto = WebSocketProtocol(ws)
@@ -153,7 +153,7 @@ async def test_abort_cancels_pending_and_closes_ws():
     async def slow_send(*_args, **_kwargs):
         await asyncio.sleep(10)
 
-    ws.send_str = mock.AsyncMock(side_effect=slow_send)
+    ws.send_bytes = mock.AsyncMock(side_effect=slow_send)
     ws.close = mock.AsyncMock()
 
     proto = WebSocketProtocol(ws)
@@ -219,9 +219,9 @@ async def handler(request: web.Request) -> web.WebSocketResponse:
         import aiohttp
         async with aiohttp.ClientSession() as session:
             async with session.ws_connect(f"http://127.0.0.1:{port}/ws") as ws:
-                await ws.send_str('{"command":"ping"}')
+                await ws.send_bytes(b'{"command":"ping"}\n')
                 reply = await ws.receive()
-                assert reply.type == WSMsgType.TEXT
+                assert reply.type == WSMsgType.BINARY
                 assert json.loads(reply.data) == {"command": "pong"}
     finally:
         await runner.cleanup()