refactor: use rpc

tests/integration_tests/box/test_box_integration.py

@@ -12,21 +12,22 @@ CI pipeline.  Run them locally with::
 
 from __future__ import annotations
 
+import asyncio
 import logging
 import shutil
 import socket
 import subprocess
 from types import SimpleNamespace
+from unittest.mock import Mock
 
 import pytest
-from aiohttp.test_utils import TestServer
 
 from langbot.pkg.box.backend import BaseSandboxBackend
-from langbot.pkg.box.client import RemoteBoxRuntimeClient
+from langbot.pkg.box.client import ActionRPCBoxClient
 from langbot.pkg.box.errors import BoxBackendUnavailableError, BoxRuntimeUnavailableError
 from langbot.pkg.box.models import BoxExecutionStatus, BoxNetworkMode, BoxSpec
 from langbot.pkg.box.runtime import BoxRuntime
-from langbot.pkg.box.server import create_app as create_server_app
+from langbot.pkg.box.server import BoxServerHandler
 from langbot.pkg.box.service import BoxService
 
 import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
@@ -77,23 +78,61 @@ requires_socket = pytest.mark.skipif(
 )
 
 
+# ── Helpers ──────────────────────────────────────────────────────────
+
+
+class _QueueConnection:
+    """In-process Connection backed by asyncio Queues — no real IO."""
+
+    def __init__(self, rx: asyncio.Queue[str], tx: asyncio.Queue[str]):
+        self._rx = rx
+        self._tx = tx
+
+    async def send(self, message: str) -> None:
+        await self._tx.put(message)
+
+    async def receive(self) -> str:
+        return await self._rx.get()
+
+    async def close(self) -> None:
+        pass
+
+
+async def _make_rpc_pair(runtime: BoxRuntime):
+    """Create an in-process (ActionRPCBoxClient, server_task, client_task) connected via queues."""
+    from langbot_plugin.runtime.io.handler import Handler
+
+    c2s: asyncio.Queue[str] = asyncio.Queue()
+    s2c: asyncio.Queue[str] = asyncio.Queue()
+    client_conn = _QueueConnection(rx=s2c, tx=c2s)
+    server_conn = _QueueConnection(rx=c2s, tx=s2c)
+
+    server_handler = BoxServerHandler(server_conn, runtime)
+    server_task = asyncio.create_task(server_handler.run())
+
+    client_handler = Handler.__new__(Handler)
+    Handler.__init__(client_handler, client_conn)
+    client_task = asyncio.create_task(client_handler.run())
+
+    client = ActionRPCBoxClient(logger=_logger)
+    client.set_handler(client_handler)
+
+    return client, server_task, client_task
+
+
 # ── Fixtures ──────────────────────────────────────────────────────────
 
 
 @pytest.fixture
 async def box_client():
-    """Yield a RemoteBoxRuntimeClient backed by a real BoxRuntime HTTP server."""
+    """Yield an ActionRPCBoxClient backed by a real BoxRuntime via in-process RPC."""
     runtime = BoxRuntime(logger=_logger)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
-    client = RemoteBoxRuntimeClient(
-        base_url=str(server.make_url('')),
-        logger=_logger,
-    )
+    await runtime.initialize()
+    client, server_task, client_task = await _make_rpc_pair(runtime)
     yield client
-    await client.shutdown()
-    await server.close()
+    server_task.cancel()
+    client_task.cancel()
+    await runtime.shutdown()
 
 
 # ── 1. Simple command execution ───────────────────────────────────────
@@ -102,7 +141,7 @@ async def box_client():
 @requires_container
 @requires_socket
 @pytest.mark.asyncio
-async def test_exec_simple_command(box_client: RemoteBoxRuntimeClient):
+async def test_exec_simple_command(box_client: ActionRPCBoxClient):
     """Box starts a simple command and returns stdout."""
     spec = BoxSpec(
         cmd='echo hello-box',
@@ -123,7 +162,7 @@ async def test_exec_simple_command(box_client: RemoteBoxRuntimeClient):
 @requires_container
 @requires_socket
 @pytest.mark.asyncio
-async def test_session_persists_files(box_client: RemoteBoxRuntimeClient):
+async def test_session_persists_files(box_client: ActionRPCBoxClient):
     """Write a file in one exec, read it back in a second exec on the same session."""
     sid = 'int-persist'
 
@@ -151,7 +190,7 @@ async def test_session_persists_files(box_client: RemoteBoxRuntimeClient):
 @requires_container
 @requires_socket
 @pytest.mark.asyncio
-async def test_timeout_kills_command(box_client: RemoteBoxRuntimeClient):
+async def test_timeout_kills_command(box_client: ActionRPCBoxClient):
     """A long-running command is killed after timeout_sec."""
     session_id = 'int-timeout'
     spec = BoxSpec(
@@ -176,7 +215,7 @@ async def test_timeout_kills_command(box_client: RemoteBoxRuntimeClient):
 @requires_container
 @requires_socket
 @pytest.mark.asyncio
-async def test_offline_cannot_reach_network(box_client: RemoteBoxRuntimeClient):
+async def test_offline_cannot_reach_network(box_client: ActionRPCBoxClient):
     """With network=OFF the sandbox cannot reach the internet."""
     spec = BoxSpec(
         cmd='wget -q -O /dev/null --timeout=3 http://1.1.1.1 2>&1; exit $?',
@@ -217,16 +256,11 @@ class _UnavailableBackend(BaseSandboxBackend):
 @requires_socket
 @pytest.mark.asyncio
 async def test_backend_unavailable_returns_error():
-    """When no backend is available the full HTTP path returns BoxBackendUnavailableError."""
+    """When no backend is available the full RPC path returns BoxBackendUnavailableError."""
     runtime = BoxRuntime(logger=_logger, backends=[_UnavailableBackend()])
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
+    await runtime.initialize()
+    client, server_task, client_task = await _make_rpc_pair(runtime)
     try:
-        client = RemoteBoxRuntimeClient(
-            base_url=str(server.make_url('')),
-            logger=_logger,
-        )
         spec = BoxSpec(
             cmd='echo hello',
             session_id='int-no-backend',
@@ -234,46 +268,24 @@ async def test_backend_unavailable_returns_error():
         )
         with pytest.raises(BoxBackendUnavailableError):
             await client.execute(spec)
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()
 
 
-# ── 6. Runtime unreachable ────────────────────────────────────────────
-
-
-@requires_socket
-@pytest.mark.asyncio
-async def test_runtime_unreachable_returns_error():
-    """Connecting to a non-existent runtime raises BoxRuntimeUnavailableError."""
-    client = RemoteBoxRuntimeClient(
-        base_url='http://127.0.0.1:19999',
-        logger=_logger,
-    )
-    try:
-        with pytest.raises(BoxRuntimeUnavailableError):
-            await client.initialize()
-    finally:
-        await client.shutdown()
-
-
-# ── 7. Full service-to-runtime path ──────────────────────────────────
+# ── 6. Full service-to-runtime path ──────────────────────────────────
 
 
 @requires_container
 @requires_socket
 @pytest.mark.asyncio
 async def test_full_service_to_remote_runtime(tmp_path):
-    """BoxService -> RemoteBoxRuntimeClient -> HTTP -> BoxRuntime -> real backend."""
+    """BoxService -> ActionRPCBoxClient -> RPC -> BoxRuntime -> real backend."""
     runtime = BoxRuntime(logger=_logger)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
+    await runtime.initialize()
+    client, server_task, client_task = await _make_rpc_pair(runtime)
     try:
-        client = RemoteBoxRuntimeClient(
-            base_url=str(server.make_url('')),
-            logger=_logger,
-        )
         host_dir = tmp_path / 'workspace'
         host_dir.mkdir()
 
@@ -303,6 +315,7 @@ async def test_full_service_to_remote_runtime(tmp_path):
         assert result['status'] == 'completed'
         assert 'service-path' in result['stdout']
         assert result['session_id'] == '42'
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()

tests/integration_tests/box/test_box_mcp_integration.py

@@ -20,13 +20,14 @@ import subprocess
 
 import aiohttp
 import pytest
+from aiohttp import web
 from aiohttp.test_utils import TestServer
 
-from langbot.pkg.box.client import RemoteBoxRuntimeClient
+from langbot.pkg.box.client import ActionRPCBoxClient
 from langbot.pkg.box.errors import BoxSessionNotFoundError
 from langbot.pkg.box.models import BoxManagedProcessSpec, BoxManagedProcessStatus, BoxSpec
 from langbot.pkg.box.runtime import BoxRuntime
-from langbot.pkg.box.server import create_app as create_server_app
+from langbot.pkg.box.server import BoxServerHandler, create_ws_relay_app
 
 _logger = logging.getLogger('test.box.mcp_integration')
 
@@ -69,23 +70,71 @@ requires_socket = pytest.mark.skipif(
 )
 
 
+# ── Helpers ──────────────────────────────────────────────────────────
+
+
+class _QueueConnection:
+    """In-process Connection backed by asyncio Queues — no real IO."""
+
+    def __init__(self, rx: asyncio.Queue[str], tx: asyncio.Queue[str]):
+        self._rx = rx
+        self._tx = tx
+
+    async def send(self, message: str) -> None:
+        await self._tx.put(message)
+
+    async def receive(self) -> str:
+        return await self._rx.get()
+
+    async def close(self) -> None:
+        pass
+
+
+async def _make_rpc_pair(runtime: BoxRuntime):
+    """Create an in-process RPC pair connected via queues."""
+    from langbot_plugin.runtime.io.handler import Handler
+
+    c2s: asyncio.Queue[str] = asyncio.Queue()
+    s2c: asyncio.Queue[str] = asyncio.Queue()
+    client_conn = _QueueConnection(rx=s2c, tx=c2s)
+    server_conn = _QueueConnection(rx=c2s, tx=s2c)
+
+    server_handler = BoxServerHandler(server_conn, runtime)
+    server_task = asyncio.create_task(server_handler.run())
+
+    client_handler = Handler.__new__(Handler)
+    Handler.__init__(client_handler, client_conn)
+    client_task = asyncio.create_task(client_handler.run())
+
+    client = ActionRPCBoxClient(logger=_logger)
+    client.set_handler(client_handler)
+
+    return client, server_task, client_task
+
+
 # ── Fixtures ──────────────────────────────────────────────────────────
 
 
 @pytest.fixture
 async def box_server():
-    """Yield a (TestServer, RemoteBoxRuntimeClient) backed by a real BoxRuntime."""
+    """Yield a (ws_relay_url, ActionRPCBoxClient) backed by a real BoxRuntime."""
     runtime = BoxRuntime(logger=_logger)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
-    client = RemoteBoxRuntimeClient(
-        base_url=str(server.make_url('')),
-        logger=_logger,
-    )
-    yield server, client
-    await client.shutdown()
-    await server.close()
+    await runtime.initialize()
+
+    # Start ws relay for managed process attach
+    ws_app = create_ws_relay_app(runtime)
+    ws_server = TestServer(ws_app)
+    await ws_server.start_server()
+
+    client, server_task, client_task = await _make_rpc_pair(runtime)
+
+    ws_relay_url = str(ws_server.make_url(''))
+    yield ws_relay_url, client
+
+    server_task.cancel()
+    client_task.cancel()
+    await runtime.shutdown()
+    await ws_server.close()
 
 
 # ── 1. Managed process lifecycle ─────────────────────────────────────
@@ -96,7 +145,7 @@ async def box_server():
 @pytest.mark.asyncio
 async def test_managed_process_start_and_query(box_server):
     """Start a managed process and query its status."""
-    server, client = box_server
+    ws_relay_url, client = box_server
 
     # Create session
     spec = BoxSpec(
@@ -133,7 +182,7 @@ async def test_managed_process_start_and_query(box_server):
 @pytest.mark.asyncio
 async def test_ws_stdio_attach_echo(box_server):
     """Attach to a managed process via WebSocket and verify bidirectional IO."""
-    server, client = box_server
+    ws_relay_url, client = box_server
 
     spec = BoxSpec(
         cmd='',
@@ -151,8 +200,8 @@ async def test_ws_stdio_attach_echo(box_server):
     )
     await client.start_managed_process('mcp-int-ws', proc_spec)
 
-    # Connect via WebSocket
-    ws_url = client.get_managed_process_websocket_url('mcp-int-ws')
+    # Connect via WebSocket (ws relay)
+    ws_url = client.get_managed_process_websocket_url('mcp-int-ws', ws_relay_url)
     session = aiohttp.ClientSession()
     try:
         async with session.ws_connect(ws_url) as ws:
@@ -177,7 +226,7 @@ async def test_ws_stdio_attach_echo(box_server):
 @pytest.mark.asyncio
 async def test_delete_session_cleans_up(box_server):
     """After deleting a session, it should no longer exist."""
-    server, client = box_server
+    ws_relay_url, client = box_server
 
     spec = BoxSpec(
         cmd='',
@@ -203,15 +252,15 @@ async def test_delete_session_cleans_up(box_server):
         await client.get_session('mcp-int-cleanup')
 
 
-# ── 4. GET /v1/sessions/{id} ────────────────────────────────────────
+# ── 4. GET session details ────────────────────────────────────────
 
 
 @requires_container
 @requires_socket
 @pytest.mark.asyncio
 async def test_get_session_returns_details(box_server):
-    """GET single session returns session details and managed process info."""
-    server, client = box_server
+    """Get single session returns session details and managed process info."""
+    ws_relay_url, client = box_server
 
     spec = BoxSpec(
         cmd='',
@@ -251,7 +300,7 @@ async def test_get_session_returns_details(box_server):
 @pytest.mark.asyncio
 async def test_process_exit_detected(box_server):
     """When a managed process exits, its status should reflect EXITED."""
-    server, client = box_server
+    ws_relay_url, client = box_server
 
     spec = BoxSpec(
         cmd='',
@@ -287,7 +336,7 @@ async def test_process_exit_detected(box_server):
 @pytest.mark.asyncio
 async def test_orphan_cleanup_preserves_own_containers(box_server):
     """Orphan cleanup should not remove containers belonging to the current instance."""
-    server, client = box_server
+    ws_relay_url, client = box_server
 
     # Create a session (container gets current instance ID label)
     spec = BoxSpec(

tests/unit_tests/box/test_box_connector.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
 from types import SimpleNamespace
-from unittest.mock import AsyncMock, Mock
+from unittest.mock import AsyncMock, Mock, patch
 
 import pytest
 
-from langbot.pkg.box.client import RemoteBoxRuntimeClient
+from langbot.pkg.box.client import ActionRPCBoxClient
 from langbot.pkg.box.connector import BoxRuntimeConnector
 from langbot.pkg.box.errors import BoxRuntimeUnavailableError
 
@@ -31,95 +31,57 @@ def patch_platform(monkeypatch: pytest.MonkeyPatch, value: str):
     monkeypatch.setattr('langbot.pkg.box.connector.platform.get_platform', lambda: value)
 
 
-def test_box_runtime_connector_uses_explicit_runtime_url():
+def test_box_runtime_connector_manages_local_when_no_url(monkeypatch: pytest.MonkeyPatch):
+    patch_platform(monkeypatch, 'linux')
+    connector = BoxRuntimeConnector(make_app(Mock()))
+
+    assert connector.manages_local_runtime is True
+    assert isinstance(connector.client, ActionRPCBoxClient)
+
+
+def test_box_runtime_connector_remote_when_url_configured():
     logger = Mock()
     connector = BoxRuntimeConnector(make_app(logger, runtime_url='http://box-runtime:5410'))
 
-    assert connector.runtime_url == 'http://box-runtime:5410'
     assert connector.manages_local_runtime is False
-    assert isinstance(connector.client, RemoteBoxRuntimeClient)
-    assert connector.client._base_url == 'http://box-runtime:5410'
+    assert isinstance(connector.client, ActionRPCBoxClient)
 
 
-def test_box_runtime_connector_uses_local_default_runtime_url(monkeypatch: pytest.MonkeyPatch):
-    patch_platform(monkeypatch, 'linux')
-
-    connector = BoxRuntimeConnector(make_app(Mock()))
-
-    assert connector.runtime_url == 'http://127.0.0.1:5410'
-    assert connector.manages_local_runtime is True
-    assert connector.client._base_url == 'http://127.0.0.1:5410'
-
-
-def test_box_runtime_connector_uses_docker_default_runtime_url(monkeypatch: pytest.MonkeyPatch):
+def test_box_runtime_connector_remote_when_docker(monkeypatch: pytest.MonkeyPatch):
     patch_platform(monkeypatch, 'docker')
-
     connector = BoxRuntimeConnector(make_app(Mock()))
 
-    assert connector.runtime_url == 'http://langbot_box_runtime:5410'
     assert connector.manages_local_runtime is False
-    assert connector.client._base_url == 'http://langbot_box_runtime:5410'
+    assert connector.ws_relay_base_url == 'http://langbot_box_runtime:5410'
 
 
-@pytest.mark.asyncio
-async def test_box_runtime_connector_initialize_delegates_to_client_when_runtime_is_healthy(
-    monkeypatch: pytest.MonkeyPatch,
-):
+def test_box_runtime_connector_ws_relay_url_default(monkeypatch: pytest.MonkeyPatch):
     patch_platform(monkeypatch, 'linux')
     connector = BoxRuntimeConnector(make_app(Mock()))
-    connector.client.initialize = AsyncMock()
-    connector._start_local_runtime_process = AsyncMock()
-    connector._wait_until_runtime_ready = AsyncMock()
 
-    await connector.initialize()
-
-    connector.client.initialize.assert_awaited_once()
-    connector._start_local_runtime_process.assert_not_awaited()
-    connector._wait_until_runtime_ready.assert_not_awaited()
+    assert connector.ws_relay_base_url == 'http://127.0.0.1:5410'
 
 
-@pytest.mark.asyncio
-async def test_box_runtime_connector_initialize_autostarts_local_runtime_when_unavailable(
-    monkeypatch: pytest.MonkeyPatch,
-):
-    patch_platform(monkeypatch, 'linux')
-    connector = BoxRuntimeConnector(make_app(Mock()))
-    connector.client.initialize = AsyncMock(side_effect=BoxRuntimeUnavailableError('down'))
-    connector._start_local_runtime_process = AsyncMock()
-    connector._wait_until_runtime_ready = AsyncMock()
-
-    await connector.initialize()
-
-    connector.client.initialize.assert_awaited_once()
-    connector._start_local_runtime_process.assert_awaited_once()
-    connector._wait_until_runtime_ready.assert_awaited_once()
-
-
-@pytest.mark.asyncio
-async def test_box_runtime_connector_initialize_remote_runtime_does_not_autostart():
+def test_box_runtime_connector_ws_relay_url_explicit():
     connector = BoxRuntimeConnector(make_app(Mock(), runtime_url='http://box-runtime:5410'))
-    connector.client.initialize = AsyncMock()
-    connector._start_local_runtime_process = AsyncMock()
-    connector._wait_until_runtime_ready = AsyncMock()
-
-    await connector.initialize()
-
-    connector.client.initialize.assert_awaited_once()
-    connector._start_local_runtime_process.assert_not_awaited()
-    connector._wait_until_runtime_ready.assert_not_awaited()
+    assert connector.ws_relay_base_url == 'http://box-runtime:5410'
 
 
-def test_box_runtime_connector_dispose_terminates_local_runtime_process():
+def test_box_runtime_connector_dispose_terminates_subprocess():
     logger = Mock()
     connector = BoxRuntimeConnector(make_app(logger))
-    runtime_process = Mock()
-    runtime_process.returncode = None
-    runtime_task = Mock()
-    connector.runtime_subprocess = runtime_process
-    connector.runtime_subprocess_task = runtime_task
+    subprocess = Mock()
+    subprocess.returncode = None
+    handler_task = Mock()
+    ctrl_task = Mock()
+    connector._subprocess = subprocess
+    connector._handler_task = handler_task
+    connector._ctrl_task = ctrl_task
 
     connector.dispose()
 
-    runtime_process.terminate.assert_called_once()
-    runtime_task.cancel.assert_called_once()
-    assert connector.runtime_subprocess_task is None
+    subprocess.terminate.assert_called_once()
+    handler_task.cancel.assert_called_once()
+    ctrl_task.cancel.assert_called_once()
+    assert connector._handler_task is None
+    assert connector._ctrl_task is None

tests/unit_tests/box/test_box_service.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 import datetime as dt
 import os
-import socket
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, Mock
 
@@ -12,7 +11,7 @@ import pytest
 import langbot_plugin.api.entities.builtin.pipeline.query as pipeline_query
 
 from langbot.pkg.box.backend import BaseSandboxBackend
-from langbot.pkg.box.client import BoxRuntimeClient, RemoteBoxRuntimeClient
+from langbot.pkg.box.client import BoxRuntimeClient, ActionRPCBoxClient
 from langbot.pkg.box.errors import BoxBackendUnavailableError, BoxSessionConflictError, BoxSessionNotFoundError, BoxValidationError
 from langbot.pkg.box.models import (
     BUILTIN_PROFILES,
@@ -71,20 +70,6 @@ class _InProcessBoxRuntimeClient(BoxRuntimeClient):
         return self._runtime.get_session(session_id)
 
 
-def _can_open_test_socket() -> bool:
-    try:
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-    except OSError:
-        return False
-    sock.close()
-    return True
-
-
-requires_socket = pytest.mark.skipif(
-    not _can_open_test_socket(),
-    reason='local test environment does not permit opening TCP sockets',
-)
-
 
 class FakeBackend(BaseSandboxBackend):
     def __init__(self, logger: Mock, available: bool = True):
@@ -787,27 +772,65 @@ async def test_service_get_status_aggregates_runtime_and_profile():
     assert status['recent_error_count'] == 0
 
 
-# ── RemoteBoxRuntimeClient tests ─────────────────────────────────────
+# ── In-process RPC client/server tests ─────────────────────────────────
+
+
+class _QueueConnection:
+    """In-process Connection backed by asyncio Queues — no real IO."""
+
+    def __init__(self, rx: asyncio.Queue[str], tx: asyncio.Queue[str]):
+        self._rx = rx
+        self._tx = tx
+
+    async def send(self, message: str) -> None:
+        await self._tx.put(message)
+
+    async def receive(self) -> str:
+        return await self._rx.get()
+
+    async def close(self) -> None:
+        pass
+
+
+def _make_queue_connection_pair():
+    """Return (client_conn, server_conn) linked by queues."""
+    c2s: asyncio.Queue[str] = asyncio.Queue()
+    s2c: asyncio.Queue[str] = asyncio.Queue()
+    client_conn = _QueueConnection(rx=s2c, tx=c2s)
+    server_conn = _QueueConnection(rx=c2s, tx=s2c)
+    return client_conn, server_conn
+
+
+async def _make_rpc_pair(runtime: BoxRuntime):
+    """Create an in-process (ActionRPCBoxClient, server_task, client_task) connected via queues."""
+    from langbot.pkg.box.server import BoxServerHandler
+    from langbot_plugin.runtime.io.handler import Handler
+
+    client_conn, server_conn = _make_queue_connection_pair()
+
+    server_handler = BoxServerHandler(server_conn, runtime)
+    server_task = asyncio.create_task(server_handler.run())
+
+    client_handler = Handler.__new__(Handler)
+    Handler.__init__(client_handler, client_conn)
+    client_task = asyncio.create_task(client_handler.run())
+
+    client = ActionRPCBoxClient(logger=Mock())
+    client.set_handler(client_handler)
+
+    return client, server_task, client_task
 
 
-@requires_socket
 @pytest.mark.asyncio
-async def test_remote_client_execute():
-    """RemoteBoxRuntimeClient correctly posts to server and parses result."""
-    from aiohttp.test_utils import TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
+async def test_rpc_client_execute():
+    """ActionRPCBoxClient correctly calls server and parses result."""
     logger = Mock()
     backend = FakeBackend(logger)
     runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
-    try:
-        client = RemoteBoxRuntimeClient(base_url=str(server.make_url('')), logger=logger)
-        await client.initialize()
+    await runtime.initialize()
 
+    client, server_task, client_task = await _make_rpc_pair(runtime)
+    try:
         spec = BoxSpec.model_validate({'cmd': 'echo remote', 'session_id': 'r-1'})
         result = await client.execute(spec)
 
@@ -815,353 +838,122 @@ async def test_remote_client_execute():
         assert result.status == BoxExecutionStatus.COMPLETED
         assert result.exit_code == 0
         assert result.stdout == 'executed: echo remote'
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()
 
 
-@requires_socket
 @pytest.mark.asyncio
-async def test_remote_client_get_sessions():
-    from aiohttp.test_utils import TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
+async def test_rpc_client_get_sessions():
     logger = Mock()
     backend = FakeBackend(logger)
     runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
-    try:
-        client = RemoteBoxRuntimeClient(base_url=str(server.make_url('')), logger=logger)
+    await runtime.initialize()
 
+    client, server_task, client_task = await _make_rpc_pair(runtime)
+    try:
         spec = BoxSpec.model_validate({'cmd': 'echo hi', 'session_id': 'r-2'})
         await client.execute(spec)
 
         sessions = await client.get_sessions()
         assert len(sessions) == 1
         assert sessions[0]['session_id'] == 'r-2'
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()
 
 
-@requires_socket
 @pytest.mark.asyncio
-async def test_remote_client_get_status():
-    from aiohttp.test_utils import TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
+async def test_rpc_client_get_status():
     logger = Mock()
     backend = FakeBackend(logger)
     runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
+    await runtime.initialize()
+
+    client, server_task, client_task = await _make_rpc_pair(runtime)
     try:
-        client = RemoteBoxRuntimeClient(base_url=str(server.make_url('')), logger=logger)
         status = await client.get_status()
 
         assert 'backend' in status
         assert 'active_sessions' in status
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()
 
 
-@requires_socket
 @pytest.mark.asyncio
-async def test_remote_client_get_backend_info():
-    from aiohttp.test_utils import TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
+async def test_rpc_client_get_backend_info():
     logger = Mock()
     backend = FakeBackend(logger)
     runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
+    await runtime.initialize()
+
+    client, server_task, client_task = await _make_rpc_pair(runtime)
     try:
-        client = RemoteBoxRuntimeClient(base_url=str(server.make_url('')), logger=logger)
         info = await client.get_backend_info()
 
         assert info['name'] == 'fake'
         assert info['available'] is True
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()
 
 
-# ── Server endpoint tests ────────────────────────────────────────────
-
-
-@requires_socket
-@pytest.mark.asyncio
-async def test_server_delete_session():
-    from aiohttp.test_utils import TestClient, TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
-    logger = Mock()
-    backend = FakeBackend(logger)
-    runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    test_client = TestClient(server)
-    await test_client.start_server()
-    try:
-        # Create a session via exec
-        resp = await test_client.post('/v1/sessions/del-1/exec', json={'cmd': 'echo hi'})
-        assert resp.status == 200
-
-        # Delete it
-        resp = await test_client.delete('/v1/sessions/del-1')
-        assert resp.status == 200
-        data = await resp.json()
-        assert data['deleted'] == 'del-1'
-
-        # Verify session is gone
-        resp = await test_client.get('/v1/sessions')
-        sessions = await resp.json()
-        assert len(sessions) == 0
-    finally:
-        await test_client.close()
-
-
-# ── Runtime delete_session / create_session tests ────────────────────
+# ── RPC-based delete/create/conflict tests ────────────────────────────
 
 
 @pytest.mark.asyncio
-async def test_runtime_delete_session():
+async def test_rpc_client_delete_session():
     logger = Mock()
     backend = FakeBackend(logger)
     runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
     await runtime.initialize()
 
-    await runtime.execute(BoxSpec.model_validate({'cmd': 'echo', 'session_id': 'del-test'}))
-    assert len(runtime.get_sessions()) == 1
-
-    await runtime.delete_session('del-test')
-    assert len(runtime.get_sessions()) == 0
-    assert backend.stop_calls == ['del-test']
-
-
-@pytest.mark.asyncio
-async def test_runtime_delete_session_not_found():
-    logger = Mock()
-    backend = FakeBackend(logger)
-    runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    await runtime.initialize()
-
-    with pytest.raises(BoxSessionNotFoundError):
-        await runtime.delete_session('nonexistent')
-
-
-@pytest.mark.asyncio
-async def test_runtime_create_session():
-    logger = Mock()
-    backend = FakeBackend(logger)
-    runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    await runtime.initialize()
-
-    spec = BoxSpec.model_validate({'cmd': 'placeholder', 'session_id': 'create-1'})
-    info = await runtime.create_session(spec)
-    assert info['session_id'] == 'create-1'
-    assert info['backend_name'] == 'fake'
-
-    sessions = runtime.get_sessions()
-    assert len(sessions) == 1
-    assert sessions[0]['session_id'] == 'create-1'
-
-
-# ── Server structured error tests ────────────────────────────────────
-
-
-@requires_socket
-@pytest.mark.asyncio
-async def test_server_delete_nonexistent_session():
-    from aiohttp.test_utils import TestClient, TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
-    logger = Mock()
-    backend = FakeBackend(logger)
-    runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    test_client = TestClient(server)
-    await test_client.start_server()
+    client, server_task, client_task = await _make_rpc_pair(runtime)
     try:
-        resp = await test_client.delete('/v1/sessions/nonexistent')
-        assert resp.status == 404
-        data = await resp.json()
-        assert data['error']['code'] == 'session_not_found'
-    finally:
-        await test_client.close()
-
-
-@requires_socket
-@pytest.mark.asyncio
-async def test_server_exec_returns_structured_error_on_conflict():
-    from aiohttp.test_utils import TestClient, TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
-    logger = Mock()
-    backend = FakeBackend(logger)
-    runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    test_client = TestClient(server)
-    await test_client.start_server()
-    try:
-        # Create session with network=off
-        resp = await test_client.post('/v1/sessions/conflict-1/exec', json={'cmd': 'echo hi', 'network': 'off'})
-        assert resp.status == 200
-
-        # Try to use same session with network=on -> conflict
-        resp = await test_client.post('/v1/sessions/conflict-1/exec', json={'cmd': 'echo hi', 'network': 'on'})
-        assert resp.status == 409
-        data = await resp.json()
-        assert data['error']['code'] == 'session_conflict'
-    finally:
-        await test_client.close()
-
-
-@requires_socket
-@pytest.mark.asyncio
-async def test_server_create_session():
-    from aiohttp.test_utils import TestClient, TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
-    logger = Mock()
-    backend = FakeBackend(logger)
-    runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    test_client = TestClient(server)
-    await test_client.start_server()
-    try:
-        resp = await test_client.post('/v1/sessions/new-1', json={'image': 'python:3.11-slim'})
-        assert resp.status == 201
-        data = await resp.json()
-        assert data['session_id'] == 'new-1'
-        assert data['backend_name'] == 'fake'
-        assert 'created_at' in data
-
-        # Session should appear in list
-        resp = await test_client.get('/v1/sessions')
-        sessions = await resp.json()
-        assert len(sessions) == 1
-        assert sessions[0]['session_id'] == 'new-1'
-    finally:
-        await test_client.close()
-
-
-@requires_socket
-@pytest.mark.asyncio
-async def test_server_create_session_conflict():
-    from aiohttp.test_utils import TestClient, TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
-    logger = Mock()
-    backend = FakeBackend(logger)
-    runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    test_client = TestClient(server)
-    await test_client.start_server()
-    try:
-        resp = await test_client.post('/v1/sessions/dup-1', json={'network': 'off'})
-        assert resp.status == 201
-
-        # Conflicting create with different network
-        resp = await test_client.post('/v1/sessions/dup-1', json={'network': 'on'})
-        assert resp.status == 409
-        data = await resp.json()
-        assert data['error']['code'] == 'session_conflict'
-    finally:
-        await test_client.close()
-
-
-# ── Remote client error translation tests ─────────────────────────────
-
-
-@requires_socket
-@pytest.mark.asyncio
-async def test_remote_client_delete_session():
-    from aiohttp.test_utils import TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
-    logger = Mock()
-    backend = FakeBackend(logger)
-    runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
-    try:
-        client = RemoteBoxRuntimeClient(base_url=str(server.make_url('')), logger=logger)
-
-        # Create session via exec
         spec = BoxSpec.model_validate({'cmd': 'echo hi', 'session_id': 'r-del-1'})
         await client.execute(spec)
 
-        # Delete it
         await client.delete_session('r-del-1')
 
-        # Verify empty
         sessions = await client.get_sessions()
         assert len(sessions) == 0
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()
 
 
-@requires_socket
 @pytest.mark.asyncio
-async def test_remote_client_delete_session_raises_not_found():
-    from aiohttp.test_utils import TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
+async def test_rpc_client_delete_session_raises_not_found():
     logger = Mock()
     backend = FakeBackend(logger)
     runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
-    try:
-        client = RemoteBoxRuntimeClient(base_url=str(server.make_url('')), logger=logger)
+    await runtime.initialize()
 
+    client, server_task, client_task = await _make_rpc_pair(runtime)
+    try:
         with pytest.raises(BoxSessionNotFoundError):
             await client.delete_session('nonexistent')
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()
 
 
-@requires_socket
 @pytest.mark.asyncio
-async def test_remote_client_create_session():
-    from aiohttp.test_utils import TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
+async def test_rpc_client_create_session():
     logger = Mock()
     backend = FakeBackend(logger)
     runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
-    try:
-        client = RemoteBoxRuntimeClient(base_url=str(server.make_url('')), logger=logger)
+    await runtime.initialize()
 
+    client, server_task, client_task = await _make_rpc_pair(runtime)
+    try:
         spec = BoxSpec.model_validate({'cmd': 'placeholder', 'session_id': 'r-create-1'})
         info = await client.create_session(spec)
         assert info['session_id'] == 'r-create-1'
@@ -1169,38 +961,31 @@ async def test_remote_client_create_session():
 
         sessions = await client.get_sessions()
         assert len(sessions) == 1
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()
 
 
-@requires_socket
 @pytest.mark.asyncio
-async def test_remote_client_exec_raises_conflict_error():
-    from aiohttp.test_utils import TestServer
-
-    from langbot.pkg.box.server import create_app as create_server_app
-
+async def test_rpc_client_exec_raises_conflict_error():
     logger = Mock()
     backend = FakeBackend(logger)
     runtime = BoxRuntime(logger=logger, backends=[backend], session_ttl_sec=300)
-    app = create_server_app(runtime)
-    server = TestServer(app)
-    await server.start_server()
-    try:
-        client = RemoteBoxRuntimeClient(base_url=str(server.make_url('')), logger=logger)
+    await runtime.initialize()
 
-        # Create session with network=off
+    client, server_task, client_task = await _make_rpc_pair(runtime)
+    try:
         spec1 = BoxSpec.model_validate({'cmd': 'echo first', 'session_id': 'r-conflict-1', 'network': 'off'})
         await client.execute(spec1)
 
-        # Conflicting exec with network=on
         spec2 = BoxSpec.model_validate({'cmd': 'echo second', 'session_id': 'r-conflict-1', 'network': 'on'})
         with pytest.raises(BoxSessionConflictError):
             await client.execute(spec2)
-        await client.shutdown()
     finally:
-        await server.close()
+        server_task.cancel()
+        client_task.cancel()
+        await runtime.shutdown()
 
 
 # ── BoxHostMountMode.NONE tests ─────────────────────────────────────