Enable real guest networking and make demos network-first

tests/test_runtime.py

@@ -85,9 +85,9 @@ def test_doctor_report_has_runtime_fields() -> None:
     assert "tun_available" in networking
 
 
-def test_runtime_capabilities_reports_shim_bundle() -> None:
+def test_runtime_capabilities_reports_real_bundle_flags() -> None:
     paths = resolve_runtime_paths()
     capabilities = runtime_capabilities(paths)
-    assert capabilities.supports_vm_boot is False
-    assert capabilities.supports_guest_exec is False
-    assert capabilities.supports_guest_network is False
+    assert capabilities.supports_vm_boot is True
+    assert capabilities.supports_guest_exec is True
+    assert capabilities.supports_guest_network is True

tests/test_runtime_network_check.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import pytest
+
+import pyro_mcp.runtime_network_check as runtime_network_check
+from pyro_mcp.vm_network import TapNetworkManager
+
+
+def test_network_check_uses_network_enabled_manager(monkeypatch: pytest.MonkeyPatch) -> None:
+    observed: dict[str, object] = {}
+
+    class StubManager:
+        def __init__(self, **kwargs: object) -> None:
+            observed.update(kwargs)
+
+        def create_vm(self, **kwargs: object) -> dict[str, object]:
+            observed["create_kwargs"] = kwargs
+            return {"vm_id": "vm123"}
+
+        def start_vm(self, vm_id: str) -> dict[str, object]:
+            observed["started_vm_id"] = vm_id
+            return {"state": "started"}
+
+        def status_vm(self, vm_id: str) -> dict[str, object]:
+            observed["status_vm_id"] = vm_id
+            return {"network_enabled": True}
+
+        def exec_vm(self, vm_id: str, *, command: str, timeout_seconds: int) -> dict[str, object]:
+            observed["exec_vm_id"] = vm_id
+            observed["command"] = command
+            observed["timeout_seconds"] = timeout_seconds
+            return {
+                "execution_mode": "guest_vsock",
+                "exit_code": 0,
+                "stdout": "true\n",
+                "stderr": "",
+                "cleanup": {"deleted": True, "vm_id": vm_id, "reason": "post_exec_cleanup"},
+            }
+
+    monkeypatch.setattr(runtime_network_check, "VmManager", StubManager)
+    result = runtime_network_check.run_network_check()
+
+    network_manager = observed["network_manager"]
+    assert isinstance(network_manager, TapNetworkManager)
+    assert network_manager.enabled is True
+    assert observed["command"] == runtime_network_check.NETWORK_CHECK_COMMAND
+    assert observed["timeout_seconds"] == 120
+    assert result.execution_mode == "guest_vsock"
+    assert result.network_enabled is True
+    assert result.exit_code == 0
+
+
+def test_network_check_main_fails_on_unsuccessful_command(
+    monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]
+) -> None:
+    monkeypatch.setattr(
+        runtime_network_check,
+        "run_network_check",
+        lambda **kwargs: runtime_network_check.NetworkCheckResult(
+            vm_id="vm123",
+            execution_mode="guest_vsock",
+            network_enabled=True,
+            exit_code=1,
+            stdout="",
+            stderr="curl failed",
+            cleanup={"deleted": True},
+        ),
+    )
+    with pytest.raises(SystemExit, match="1"):
+        runtime_network_check.main()
+    output = capsys.readouterr().out
+    assert "[network] result=failure" in output
+    assert "[network] stderr=curl failed" in output

tests/test_vm_guest.py

@@ -8,9 +8,13 @@ from pyro_mcp.vm_guest import VsockExecClient
 
 
 class StubSocket:
-    def __init__(self, response: bytes) -> None:
-        self.response = response
-        self.connected: tuple[int, int] | None = None
+    def __init__(self, responses: list[bytes] | bytes) -> None:
+        if isinstance(responses, bytes):
+            self.responses = [responses]
+        else:
+            self.responses = responses
+        self._buffer = b""
+        self.connected: object | None = None
         self.sent = b""
         self.timeout: int | None = None
         self.closed = False
@@ -25,10 +29,12 @@ class StubSocket:
         self.sent += data
 
     def recv(self, size: int) -> bytes:
-        del size
-        if self.response == b"":
+        if not self._buffer and self.responses:
+            self._buffer = self.responses.pop(0)
+        if not self._buffer:
             return b""
-        data, self.response = self.response, b""
+        data = self._buffer[:size]
+        self._buffer = self._buffer[size:]
         return data
 
     def close(self) -> None:
@@ -62,3 +68,36 @@ def test_vsock_exec_client_rejects_bad_json(monkeypatch: pytest.MonkeyPatch) ->
     client = VsockExecClient(socket_factory=lambda family, sock_type: stub)
     with pytest.raises(RuntimeError, match="JSON object"):
         client.exec(1234, 5005, "echo ok", 30)
+
+
+def test_vsock_exec_client_uses_unix_bridge_when_vsock_is_unavailable(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delattr(socket, "AF_VSOCK", raising=False)
+    stub = StubSocket(
+        [
+            b"OK 1073746829\n",
+            b'{"stdout":"ready\\n","stderr":"","exit_code":0,"duration_ms":5}',
+        ]
+    )
+
+    def socket_factory(family: int, sock_type: int) -> StubSocket:
+        assert family == socket.AF_UNIX
+        assert sock_type == socket.SOCK_STREAM
+        return stub
+
+    client = VsockExecClient(socket_factory=socket_factory)
+    response = client.exec(1234, 5005, "echo ready", 30, uds_path="/tmp/vsock.sock")
+
+    assert response.stdout == "ready\n"
+    assert stub.connected == "/tmp/vsock.sock"
+    assert stub.sent.startswith(b"CONNECT 5005\n")
+
+
+def test_vsock_exec_client_requires_transport_when_vsock_is_unavailable(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.delattr(socket, "AF_VSOCK", raising=False)
+    client = VsockExecClient(socket_factory=lambda family, sock_type: StubSocket(b""))
+    with pytest.raises(RuntimeError, match="not supported"):
+        client.exec(1234, 5005, "echo ok", 30)