remotedesktop 0.7.0__tar.gz → 0.8.0__tar.gz

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/CLAUDE.md

@@ -49,6 +49,7 @@ Managed with `uv` (hatchling build backend, src layout):
 - **Input forwarding**: `ViewerWidget` captures mouse/keyboard events and emits `inputEvent` dicts with coordinates normalized 0..1 over the *displayed* frame rect (letterboxing is reversed via `_display_rect()`; events outside the frame are dropped). Keys carry the client's `nativeVirtualKey()` — since both ends are Windows, the server injects that VK directly with no key-translation table. The client sends these as `{"type": "input", ...}`; `ShareServer` only injects input from streams that completed the hello/approval handshake.
 - **Injection is isolated behind `InputInjector`** (`input_injection.py`, Windows `SendInput` via ctypes; inert stub off-Windows). ShareServer takes an `injector=` param so tests pass a recording fake — **never let tests construct a real `InputInjector`, or they will move the host's actual mouse/keyboard.** Normalized 0..1 coords map directly to SendInput's 0..65535 absolute range over the primary monitor.
 - **Transport is TLS + a token handshake** (`tls.py`, `sharing.py`, `config.py`). The Qt SSL backend here is Windows **schannel** (no OpenSSL); it does complete server-side TLS with a `cryptography`-generated self-signed cert loaded from PEM (verified), but be wary of schannel-specific quirks if you change the config. The server persists a self-signed cert/key under the config dir (`tls.load_or_create_credentials`; `ShareServer(credentials=...)`, or ephemeral if omitted). The client connects with `connectToHostEncrypted`, ignores the expected self-signed cert errors (`PeerVerifyMode.VerifyNone`), and pins the cert fingerprint **softly** — a change is logged but does *not* block the connection (robustness over strict security, per the trusted-LAN intent). Authentication: on first connect the server user approves and the server issues a random token (`PairedClients.pair`, stored server-side by client-id; client stores it in `KnownServers` keyed by `host:port` with the fingerprint). On reconnect the client sends the token in its hello and is admitted with no prompt; a missing/invalid token just falls back to re-approval (never hard-fails). **Do not reintroduce hard cert-pinning or challenge-response** — the user explicitly wanted robust connections over maximum security.
+- **Performance monitoring** (`performance.py` + `preferences.py`): `PerformanceMonitor` is an opt-in collaborator (`performance=` on `ShareServer`/`ShareClient`, the `clipboard=` pattern — plain sharing tests leave it off). While admitted streams are attached, a 1 s QTimer samples `MessageStream.bytes_sent/bytes_received` counters into rolling `MetricSeries` (bandwidth, aggregated across streams via per-stream baselines) and pings the most recently admitted stream: `{"type": "ping", "id", "rtt"}` / `{"type": "pong", "id"}` — each side measures its own RTT and piggybacks it on its next ping so both ends graph both directions; peers without the feature ignore pings harmlessly (RTT graphs show "no data"). Ping/pong is admitted-streams-only on the server, like input/clipboard. Both windows have a "Performance" tab (`PerformanceTab`, custom QPainter graphs) that schedules **no paint work while hidden** (gated on `isVisible()`, repaint on `showEvent`) and a "Preferences" tab whose history-window setting persists via the `Settings` store (`performance_window_seconds`, default 120). The monitor's timer runs only while streams are attached; all timing is `time.monotonic()` with an injectable `clock=` for tests — never monkeypatch `time.monotonic` (the test `pump()` helper depends on it).
 - **Clipboard sync is bidirectional** (`clipboard.py` `ClipboardSync`): client copy → server and server copy → all clients, as `{"type": "clipboard", "text"/"image_png"}` messages. It's opt-in — `ShareServer`/`ShareClient` take a `clipboard=` param and do nothing with clipboard if it's None, so only the GUIs (and clipboard tests) enable it; **plain sharing/input tests must leave it off to avoid touching the real OS clipboard.** Echo/loop prevention is by *content signature*, not just a guard flag, because Windows fires `QClipboard.dataChanged` asynchronously (after a flag would be cleared); image signatures hash canonical RGBA pixels so a re-encoded PNG round trip doesn't loop. Server only accepts clipboard from streams past the approval handshake. Tests use a `FakeClipboard(QObject)` with a `changed` signal and recording `apply()` so two independent clipboards exist in one process.
 - The package version lives only in `src/remotedesktop/__init__.py` (`__version__`); hatchling reads it from there (`[tool.hatch.version]`), so bump it in that one place.
 - Widget tests need a `QApplication`; use the session-scoped `qapp` fixture in `tests/conftest.py`.

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.7.0
+Version: 0.8.0
 Summary: Remote desktop client/server for Windows computers on the same LAN, with autodiscovery. Provides screen, keyboard, mouse, and clipboard sharing without RDP or Microsoft authentication.
 Author-email: James Abel <j@abel.co>
 License-Expression: MIT
@@ -30,7 +30,11 @@ computers on the same LAN, with autodiscovery of servers.
 
 The server can optionally start automatically when you log in to Windows —
 a checkbox on its Status tab registers it under the per-user Run key (no
-administrator rights needed).
+administrator rights needed). The Status tab also has a *Restart server*
+button that relaunches the app in a fresh process; since the server's
+screen can be controlled remotely, this lets you update the software from
+a remote desktop session and restart into the new version without visiting
+the machine (approved clients reconnect without a new permission prompt).
 
 Connections are made to the desktop screen, keyboard, mouse, and clipboard.
 Other connections are not provided, such as shared drives, devices, or

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/readme.md

@@ -11,7 +11,11 @@ computers on the same LAN, with autodiscovery of servers.
 
 The server can optionally start automatically when you log in to Windows —
 a checkbox on its Status tab registers it under the per-user Run key (no
-administrator rights needed).
+administrator rights needed). The Status tab also has a *Restart server*
+button that relaunches the app in a fresh process; since the server's
+screen can be controlled remotely, this lets you update the software from
+a remote desktop session and restart into the new version without visiting
+the machine (approved clients reconnect without a new permission prompt).
 
 Connections are made to the desktop screen, keyboard, mouse, and clipboard.
 Other connections are not provided, such as shared drives, devices, or

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/src/remotedesktop/__init__.py

@@ -1,3 +1,3 @@
 """Remote desktop client/server for Windows computers on the same LAN."""
 
-__version__ = "0.7.0"
+__version__ = "0.8.0"

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/src/remotedesktop/client.py

@@ -28,6 +28,8 @@ from remotedesktop.clipboard import ClipboardSync
 from remotedesktop.config import KnownServers, Settings, default_db_path, load_client_identity
 from remotedesktop.discovery import DISCOVERY_PORT, ServerInfo, discover_servers
 from remotedesktop.inventory import ConnectionInventory, InventoryTab
+from remotedesktop.performance import PerformanceMonitor, PerformanceTab
+from remotedesktop.preferences import PreferencesTab, load_performance_window_seconds
 from remotedesktop.sharing import ShareClient
 from remotedesktop.viewer import ViewerWidget
 
@@ -93,6 +95,11 @@ class ClientWindow(QMainWindow):
         self.setWindowTitle("Remote Desktop Client")
         # Tests inject a connection to a temp database; the app uses the default.
         self._db = connection if connection is not None else db.connect(default_db_path())
+        self._settings = Settings(self._db)
+        self.performance = PerformanceMonitor(
+            window_seconds=float(load_performance_window_seconds(self._settings)),
+            parent=self,
+        )
         self.viewer = ViewerWidget(self)
         self.inventory = ConnectionInventory(self._db, "client_peers", self)
         tabs = QTabWidget()
@@ -101,6 +108,7 @@ class ClientWindow(QMainWindow):
             InventoryTab(self.inventory, "Forget server", self._forget_server),
             "Servers on LAN",
         )
+        tabs.addTab(PerformanceTab(self.performance), "Performance")
         self.setCentralWidget(tabs)
 
         self.discovery_panel = DiscoveryPanel(self)
@@ -112,6 +120,7 @@ class ClientWindow(QMainWindow):
         self.connection_log.setReadOnly(True)
         self.connection_log.setMaximumBlockCount(1000)
         tabs.addTab(self.connection_log, "Connection log")
+        tabs.addTab(PreferencesTab(self._settings, self.performance), "Preferences")
 
         self.discovery_panel.serverActivated.connect(self._on_server_activated)
         self.discovery_panel.serversFound.connect(self._record_discovered)
@@ -128,7 +137,6 @@ class ClientWindow(QMainWindow):
         self._server_key = ""
         self._frame_count = 0
         self.statusBar().showMessage("Not connected")
-        self._settings = Settings(self._db)
         window_state.restore_geometry(self, self._settings, window_state.CLIENT_GEOMETRY_KEY)
         self.log("Client started")
         # Tests pass auto_scan=False so window tests never broadcast on the LAN.
@@ -180,10 +188,12 @@ class ClientWindow(QMainWindow):
             self._server_key, "attempt", name=server.name,
             address=self._server_key, detail=self._server_key,
         )
+        self.performance.reset()  # graphs show only the current connection
         client = ShareClient(
             identity=self._identity,
             known_servers=self._known_servers,
             clipboard=self._clipboard,
+            performance=self.performance,
             parent=self,
         )
         self._client = client

remotedesktop-0.8.0/src/remotedesktop/performance.py

@@ -0,0 +1,342 @@
+"""Connection performance monitoring: bandwidth and round-trip time.
+
+`PerformanceMonitor` is an opt-in collaborator for `ShareServer`/`ShareClient`
+(the `clipboard=` pattern): while at least one admitted stream is attached, a
+1 s timer samples the streams' framed byte counters into rolling bandwidth
+series and pings the peer. Each side measures its own round-trip time and
+piggybacks the latest measurement on its next ping (`"rtt"`), so both ends can
+graph both directions. Peers that predate this feature simply never answer
+pings — the RTT series stay empty and nothing else is affected.
+
+Wire messages (JSON, admitted streams only):
+    {"type": "ping", "id": <int>, "rtt": <ms, omitted before first measurement>}
+    {"type": "pong", "id": <int>}   # pure echo
+
+`PerformanceTab` shows the graphs. It schedules no paint work while hidden
+(background pages of a QTabWidget are hidden widgets): sampling continues in
+the monitor, and the tab repaints on show with the accrued history.
+
+All timing uses time.monotonic(), injectable as `clock=` for tests.
+"""
+
+import itertools
+import logging
+import time
+from collections import deque
+from collections.abc import Callable
+from typing import Protocol
+
+from PySide6.QtCore import QObject, QPointF, QTimer, Qt, Signal
+from PySide6.QtGui import QColor, QPainter, QPaintEvent, QPolygonF, QShowEvent
+from PySide6.QtWidgets import QVBoxLayout, QWidget
+
+_log = logging.getLogger("remotedesktop.performance")
+
+
+class StreamLike(Protocol):
+    """What the monitor needs from a stream: `protocol.MessageStream`
+    satisfies this, and tests substitute a plain fake with a recording
+    send_json."""
+
+    bytes_sent: int
+    bytes_received: int
+
+    def send_json(self, message: dict) -> None: ...
+
+
+DEFAULT_WINDOW_SECONDS = 120.0
+DEFAULT_INTERVAL_MS = 1000
+_PING_PRUNE_SECONDS = 30.0
+_HEARTBEAT_TICKS = 10  # one debug-log line per this many samples
+
+
+class MetricSeries:
+    """(monotonic time, value) samples kept for a rolling time window."""
+
+    def __init__(self, window_seconds: float, *, clock: Callable[[], float] = time.monotonic) -> None:
+        self._window = window_seconds
+        self._clock = clock
+        self._samples: deque[tuple[float, float]] = deque()
+
+    def add(self, value: float) -> None:
+        self._samples.append((self._clock(), value))
+        self._trim()
+
+    def samples(self) -> list[tuple[float, float]]:
+        self._trim()
+        return list(self._samples)
+
+    def latest(self) -> float | None:
+        return self._samples[-1][1] if self._samples else None
+
+    def clear(self) -> None:
+        self._samples.clear()
+
+    def set_window(self, window_seconds: float) -> None:
+        self._window = window_seconds
+        self._trim()
+
+    def _trim(self) -> None:
+        cutoff = self._clock() - self._window
+        while self._samples and self._samples[0][0] < cutoff:
+            self._samples.popleft()
+
+
+class PerformanceMonitor(QObject):
+    """Samples bandwidth and measures RTT for the attached streams.
+
+    The timer runs only while streams are attached (the ShareServer._timer
+    discipline), so an idle app schedules no periodic work. Bandwidth
+    aggregates all attached streams; pings go to the most recently attached
+    stream only, which keeps the RTT series a single coherent line when a
+    server has several viewers.
+    """
+
+    updated = Signal()  # one emit per sample tick
+
+    def __init__(
+        self,
+        *,
+        window_seconds: float = DEFAULT_WINDOW_SECONDS,
+        interval_ms: int = DEFAULT_INTERVAL_MS,
+        clock: Callable[[], float] = time.monotonic,
+        parent: QObject | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self._clock = clock
+        self._window = window_seconds
+        self.send_bps = MetricSeries(window_seconds, clock=clock)
+        self.recv_bps = MetricSeries(window_seconds, clock=clock)
+        self.rtt_ms = MetricSeries(window_seconds, clock=clock)
+        self.peer_rtt_ms = MetricSeries(window_seconds, clock=clock)
+        self._streams: list[StreamLike] = []
+        self._baselines: dict[StreamLike, tuple[int, int]] = {}
+        self._active: StreamLike | None = None
+        self._pending: dict[int, float] = {}
+        self._ids = itertools.count(1)
+        self._last_tick: float | None = None
+        self._tick_count = 0
+        self._timer = QTimer(self)
+        self._timer.setInterval(interval_ms)
+        self._timer.timeout.connect(self._on_tick)
+
+    @property
+    def window_seconds(self) -> float:
+        return self._window
+
+    def set_window_seconds(self, window_seconds: float) -> None:
+        self._window = window_seconds
+        for series in (self.send_bps, self.recv_bps, self.rtt_ms, self.peer_rtt_ms):
+            series.set_window(window_seconds)
+
+    def add_stream(self, stream: StreamLike) -> None:
+        if stream not in self._baselines:
+            self._streams.append(stream)
+        self._baselines[stream] = (stream.bytes_sent, stream.bytes_received)
+        self._active = stream
+        if not self._timer.isActive():
+            self._last_tick = None
+            self._timer.start()
+
+    def remove_stream(self, stream: StreamLike) -> None:
+        if stream not in self._baselines:
+            return
+        self._streams.remove(stream)
+        del self._baselines[stream]
+        if self._active is stream:
+            self._active = self._streams[-1] if self._streams else None
+        if not self._streams:
+            self._timer.stop()
+            self._pending.clear()
+            self._last_tick = None
+
+    def reset(self) -> None:
+        """Detach everything and clear the graphs (new connection attempt)."""
+        for stream in list(self._streams):
+            self.remove_stream(stream)
+        for series in (self.send_bps, self.recv_bps, self.rtt_ms, self.peer_rtt_ms):
+            series.clear()
+
+    def handle_message(self, stream: StreamLike, message: dict) -> None:
+        match message.get("type"):
+            case "ping":
+                stream.send_json({"type": "pong", "id": message.get("id")})
+                rtt = message.get("rtt")
+                if isinstance(rtt, (int, float)) and stream is self._active:
+                    self.peer_rtt_ms.add(float(rtt))
+            case "pong":
+                ping_id = message.get("id")
+                if isinstance(ping_id, int):
+                    sent = self._pending.pop(ping_id, None)
+                    if sent is not None:
+                        self.rtt_ms.add((self._clock() - sent) * 1000.0)
+
+    def _on_tick(self) -> None:
+        now = self._clock()
+        delta_sent = delta_received = 0
+        for stream in self._streams:
+            base_sent, base_received = self._baselines[stream]
+            delta_sent += stream.bytes_sent - base_sent
+            delta_received += stream.bytes_received - base_received
+            self._baselines[stream] = (stream.bytes_sent, stream.bytes_received)
+        if self._last_tick is not None and (elapsed := now - self._last_tick) > 0:
+            self.send_bps.add(delta_sent / elapsed)
+            self.recv_bps.add(delta_received / elapsed)
+        self._last_tick = now
+
+        if self._active is not None:
+            for ping_id in [i for i, t in self._pending.items() if now - t > _PING_PRUNE_SECONDS]:
+                del self._pending[ping_id]
+            ping_id = next(self._ids)
+            self._pending[ping_id] = now
+            ping: dict = {"type": "ping", "id": ping_id}
+            if (rtt := self.rtt_ms.latest()) is not None:
+                ping["rtt"] = rtt
+            self._active.send_json(ping)
+
+        self._tick_count += 1
+        if self._tick_count % _HEARTBEAT_TICKS == 0:
+            _log.debug(
+                "send %.1f KB/s, recv %.1f KB/s, rtt %s, peer rtt %s, %d stream(s)",
+                (self.send_bps.latest() or 0.0) / 1024,
+                (self.recv_bps.latest() or 0.0) / 1024,
+                f"{rtt:.1f} ms" if (rtt := self.rtt_ms.latest()) is not None else "n/a",
+                f"{peer:.1f} ms" if (peer := self.peer_rtt_ms.latest()) is not None else "n/a",
+                len(self._streams),
+            )
+        self.updated.emit()
+
+
+def format_rate(bytes_per_second: float) -> str:
+    if bytes_per_second >= 1024 * 1024:
+        return f"{bytes_per_second / (1024 * 1024):.1f} MB/s"
+    if bytes_per_second >= 1024:
+        return f"{bytes_per_second / 1024:.1f} KB/s"
+    return f"{bytes_per_second:.0f} B/s"
+
+
+def format_ms(ms: float) -> str:
+    return f"{ms:.1f} ms"
+
+
+class GraphWidget(QWidget):
+    """A rolling line graph over the monitor's window, painted with QPainter.
+
+    Holds references to the monitor's live MetricSeries and pulls their data
+    inside paintEvent, so a hidden graph does no per-sample work at all.
+    """
+
+    def __init__(
+        self,
+        title: str,
+        series: list[tuple[str, QColor, MetricSeries]],
+        monitor: PerformanceMonitor,
+        format_value: Callable[[float], str],
+        *,
+        clock: Callable[[], float] = time.monotonic,
+        parent: QWidget | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self._title = title
+        self._series = series
+        self._monitor = monitor
+        self._format_value = format_value
+        self._clock = clock
+        self.setMinimumSize(300, 120)
+
+    def paintEvent(self, event: QPaintEvent) -> None:
+        painter = QPainter(self)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        palette = self.palette()
+        painter.fillRect(self.rect(), palette.base())
+        painter.setPen(palette.color(palette.ColorRole.Mid))
+        painter.drawRect(self.rect().adjusted(0, 0, -1, -1))
+        painter.setPen(palette.color(palette.ColorRole.Text))
+        painter.drawText(8, 16, self._title)
+
+        window = self._monitor.window_seconds
+        now = self._clock()
+        data = [(label, color, series.samples()) for label, color, series in self._series]
+        if not any(samples for _label, _color, samples in data):
+            painter.drawText(
+                self.rect(), Qt.AlignmentFlag.AlignCenter, "no data"
+            )
+            return
+        y_max = max(
+            (value for _l, _c, samples in data for _t, value in samples), default=1.0
+        )
+        y_max = max(y_max, 1.0)
+
+        graph = self.rect().adjusted(8, 24, -8, -20)
+        for label, color, samples in data:
+            if not samples:
+                continue
+            polyline = QPolygonF()
+            for t, value in samples:
+                x = graph.left() + graph.width() * (1 - (now - t) / window)
+                y = graph.bottom() - graph.height() * (value / y_max)
+                polyline.append(QPointF(x, y))
+            painter.setPen(color)
+            painter.drawPolyline(polyline)
+
+        # Legend with latest values along the bottom edge.
+        x = graph.left()
+        for label, color, samples in data:
+            latest = samples[-1][1] if samples else None
+            text = f"{label} {self._format_value(latest)}" if latest is not None else f"{label} —"
+            painter.setPen(color)
+            painter.drawText(x, self.rect().bottom() - 6, text)
+            x += painter.fontMetrics().horizontalAdvance(text) + 16
+        painter.setPen(palette.color(palette.ColorRole.Text))
+        painter.drawText(
+            self.rect().right() - 8 - painter.fontMetrics().horizontalAdvance(self._format_value(y_max)),
+            16,
+            self._format_value(y_max),
+        )
+
+
+class PerformanceTab(QWidget):
+    """Bandwidth and round-trip-time graphs for the current connection.
+
+    Graphs repaint only while this tab is visible: sampling continues in the
+    monitor regardless, but a background tab schedules zero paint work.
+    """
+
+    def __init__(self, monitor: PerformanceMonitor, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._monitor = monitor
+        self.bandwidth_graph = GraphWidget(
+            "Bandwidth",
+            [
+                ("send", QColor("#2196f3"), monitor.send_bps),
+                ("receive", QColor("#4caf50"), monitor.recv_bps),
+            ],
+            monitor,
+            format_rate,
+        )
+        self.ping_graph = GraphWidget(
+            "Round-trip time",
+            [
+                ("this side", QColor("#ff9800"), monitor.rtt_ms),
+                ("peer", QColor("#9c27b0"), monitor.peer_rtt_ms),
+            ],
+            monitor,
+            format_ms,
+        )
+        layout = QVBoxLayout(self)
+        layout.addWidget(self.bandwidth_graph, stretch=1)
+        layout.addWidget(self.ping_graph, stretch=1)
+        monitor.updated.connect(self._refresh)
+
+    def _refresh(self) -> None:
+        if not self.isVisible():
+            return  # hidden tab page: schedule no paint work at all
+        self._refresh_now()
+
+    def _refresh_now(self) -> None:
+        self.bandwidth_graph.update()
+        self.ping_graph.update()
+
+    def showEvent(self, event: QShowEvent) -> None:
+        super().showEvent(event)
+        self._refresh_now()  # repaint with the history accrued while hidden

remotedesktop-0.8.0/src/remotedesktop/preferences.py

@@ -0,0 +1,49 @@
+"""The Preferences tab: user-adjustable settings, persisted in `Settings`.
+
+Currently one preference — the performance-history window length. Values live
+in the shared SQLite settings table (the single-database architecture), so
+they survive restarts and are injectable in tests like every other store.
+"""
+
+from PySide6.QtWidgets import QFormLayout, QSpinBox, QWidget
+
+from remotedesktop.config import Settings
+from remotedesktop.performance import PerformanceMonitor
+
+PERFORMANCE_WINDOW_KEY = "performance_window_seconds"
+DEFAULT_PERFORMANCE_WINDOW_SECONDS = 120
+
+
+def load_performance_window_seconds(settings: Settings) -> int:
+    raw = settings.get(PERFORMANCE_WINDOW_KEY, str(DEFAULT_PERFORMANCE_WINDOW_SECONDS))
+    try:
+        value = int(raw)  # ty: ignore[invalid-argument-type]
+    except (TypeError, ValueError):
+        return DEFAULT_PERFORMANCE_WINDOW_SECONDS
+    return value if value > 0 else DEFAULT_PERFORMANCE_WINDOW_SECONDS
+
+
+class PreferencesTab(QWidget):
+    def __init__(
+        self,
+        settings: Settings,
+        performance: PerformanceMonitor,
+        parent: QWidget | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self._settings = settings
+        self._performance = performance
+        self.history_minutes = QSpinBox()
+        self.history_minutes.setRange(1, 30)
+        self.history_minutes.setSuffix(" min")
+        self.history_minutes.setValue(
+            max(1, round(load_performance_window_seconds(settings) / 60))
+        )
+        self.history_minutes.valueChanged.connect(self._on_history_changed)
+        layout = QFormLayout(self)
+        layout.addRow("Performance history", self.history_minutes)
+
+    def _on_history_changed(self, minutes: int) -> None:
+        seconds = minutes * 60
+        self._settings.set(PERFORMANCE_WINDOW_KEY, str(seconds))
+        self._performance.set_window_seconds(float(seconds))

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/src/remotedesktop/protocol.py

@@ -44,6 +44,10 @@ class MessageStream(QObject):
         super().__init__(parent)
         self.socket = socket
         self.max_payload = max_payload
+        # Framed application bytes (headers included, TLS overhead excluded),
+        # sampled by the performance monitor to compute bandwidth.
+        self.bytes_sent = 0
+        self.bytes_received = 0
         socket.readyRead.connect(self._on_ready_read)
 
     def send_json(self, message: dict) -> None:
@@ -56,6 +60,7 @@ class MessageStream(QObject):
         self._send(_KIND_DELTA, payload)
 
     def _send(self, kind: int, payload: bytes) -> None:
+        self.bytes_sent += _HEADER.size + len(payload)
         self.socket.write(_HEADER.pack(len(payload), kind) + payload)
 
     def _on_ready_read(self) -> None:
@@ -79,6 +84,7 @@ class MessageStream(QObject):
                 return
             self.socket.read(_HEADER.size)
             payload = self.socket.read(length).data()
+            self.bytes_received += _HEADER.size + length
             if kind == _KIND_JSON:
                 try:
                     message = json.loads(bytes(payload).decode())

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/src/remotedesktop/server.py

@@ -7,7 +7,7 @@ import sqlite3
 import sys
 import time
 
-from PySide6.QtCore import Qt
+from PySide6.QtCore import QProcess, Qt
 from PySide6.QtGui import QCloseEvent
 from PySide6.QtWidgets import (
     QApplication,
@@ -16,6 +16,7 @@ from PySide6.QtWidgets import (
     QMainWindow,
     QMessageBox,
     QPlainTextEdit,
+    QPushButton,
     QTabWidget,
     QVBoxLayout,
     QWidget,
@@ -31,6 +32,8 @@ from remotedesktop.discovery import (
     DiscoveryResponder,
 )
 from remotedesktop.inventory import ConnectionInventory, InventoryTab
+from remotedesktop.performance import PerformanceMonitor, PerformanceTab
+from remotedesktop.preferences import PreferencesTab, load_performance_window_seconds
 from remotedesktop.sharing import ShareServer
 
 _log = logging.getLogger("remotedesktop.server")
@@ -60,14 +63,27 @@ class ServerWindow(QMainWindow):
         self.connection_log = QPlainTextEdit()
         self.connection_log.setReadOnly(True)
         self.connection_log.setMaximumBlockCount(1000)
+        self.restart_button = QPushButton("Restart server")
+        self.restart_button.setToolTip(
+            "Relaunch this app (e.g. after updating the software). It can be "
+            "clicked from a remote desktop session, so an update doesn't "
+            "require visiting this computer."
+        )
+        self.restart_button.clicked.connect(self._restart_server)
         status_tab = QWidget()
         status_layout = QVBoxLayout(status_tab)
         status_layout.addWidget(self._summary)
         status_layout.addWidget(self.autostart_checkbox, alignment=Qt.AlignmentFlag.AlignHCenter)
+        status_layout.addWidget(self.restart_button, alignment=Qt.AlignmentFlag.AlignHCenter)
         status_layout.addStretch(1)
 
         # Tests inject a connection to a temp database; the app uses the default.
         self._db = connection if connection is not None else db.connect(default_db_path())
+        self._settings = Settings(self._db)
+        self.performance = PerformanceMonitor(
+            window_seconds=float(load_performance_window_seconds(self._settings)),
+            parent=self,
+        )
         self.inventory = ConnectionInventory(self._db, "server_peers", self)
         tabs = QTabWidget()
         tabs.addTab(status_tab, "Status")
@@ -75,7 +91,9 @@ class ServerWindow(QMainWindow):
             InventoryTab(self.inventory, "Revoke access", self._revoke_client),
             "Clients on LAN",
         )
+        tabs.addTab(PerformanceTab(self.performance), "Performance")
         tabs.addTab(self.connection_log, "Connection log")
+        tabs.addTab(PreferencesTab(self._settings, self.performance), "Preferences")
         self.setCentralWidget(tabs)
 
         if credentials is None:
@@ -91,6 +109,7 @@ class ServerWindow(QMainWindow):
             credentials=credentials,
             paired=paired,
             clipboard=self._clipboard,
+            performance=self.performance,
             parent=self,
         )
         self.share_server.status.connect(self.log)
@@ -119,7 +138,6 @@ class ServerWindow(QMainWindow):
                     f"(UDP port {discovery_port}, TCP port {self.share_server.port})"
                 )
         self._update_summary(0)
-        self._settings = Settings(self._db)
         window_state.restore_geometry(self, self._settings, window_state.SERVER_GEOMETRY_KEY)
 
     def log(self, message: str) -> None:
@@ -169,6 +187,38 @@ class ServerWindow(QMainWindow):
         if answer == QMessageBox.StandardButton.Yes:
             self.share_server.revoke_client(client_id)
 
+    def _restart_server(self) -> None:
+        """Relaunch this app in a new process and exit.
+
+        Meant to be clicked through a remote desktop session after updating
+        the software, so the new version starts without anyone at this
+        computer. The listening sockets are closed before spawning so the
+        replacement can bind the same ports.
+        """
+        answer = QMessageBox.question(
+            self,
+            "Restart server",
+            "Restart the server app?\n\n"
+            "Viewers will be disconnected and can reconnect in a few seconds "
+            "(approved clients reconnect without a new permission prompt).",
+        )
+        if answer != QMessageBox.StandardButton.Yes:
+            return
+        self.log("Restarting: freeing ports and launching a new server process")
+        _log.info("Restart requested — relaunching %s -m remotedesktop.server", sys.executable)
+        if self.responder is not None:
+            self.responder.stop()
+            self.responder = None
+        self.share_server.close()
+        if not QProcess.startDetached(sys.executable, ["-m", "remotedesktop.server"]):
+            # Extremely unlikely (sys.executable exists); the app stays open —
+            # sharing is stopped, but the machine isn't left with nothing.
+            self.log("Restart failed: could not launch a new process — restart manually")
+            _log.error("QProcess.startDetached failed for %s", sys.executable)
+            return
+        self.close()
+        QApplication.quit()
+
     def _ask_approval(self, client_id: str, client_name: str) -> bool:
         box = QMessageBox(
             QMessageBox.Icon.Question,

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/src/remotedesktop/sharing.py

@@ -40,6 +40,7 @@ from remotedesktop.config import (
 from remotedesktop.discovery import DEFAULT_CONNECT_PORT
 from remotedesktop import frames
 from remotedesktop.input_injection import InputInjector
+from remotedesktop.performance import PerformanceMonitor
 from remotedesktop.protocol import MAX_PAYLOAD, PROTOCOL_VERSION, MessageStream
 from remotedesktop import db, tls
 
@@ -87,9 +88,11 @@ class ShareServer(QObject):
         fps: int = DEFAULT_FPS,
         injector: InputInjector | None = None,
         clipboard=None,
+        performance: PerformanceMonitor | None = None,
         parent: QObject | None = None,
     ) -> None:
         super().__init__(parent)
+        self._performance = performance
         self._approve_client = approve_client
         self._paired = paired if paired is not None else PairedClients(db.connect(default_db_path()))
         self._fps = fps
@@ -170,6 +173,8 @@ class ShareServer(QObject):
         self._previous_frame = None
         if had_clients:
             self.clientCountChanged.emit(0)
+        if self._performance is not None:
+            self._performance.reset()
         self._server.close()
         self.status.emit("Server closed")
 
@@ -198,6 +203,11 @@ class ShareServer(QObject):
             stream.jsonReceived.connect(lambda m, s=stream: self._on_message(s, m))
 
     def _on_message(self, stream: MessageStream, message: dict) -> None:
+        if message.get("type") in ("ping", "pong"):
+            # Same admission rule as input/clipboard: pre-auth peers get nothing.
+            if stream in self._streams and self._performance is not None:
+                self._performance.handle_message(stream, message)
+            return
         if message.get("type") == "input":
             if stream in self._streams:
                 self._inject(stream, message)
@@ -330,6 +340,8 @@ class ShareServer(QObject):
         stream.send_json(welcome)
         self._needs_keyframe.add(stream)  # its first frame must be a full one
         self._streams.append(stream)
+        if self._performance is not None:
+            self._performance.add_stream(stream)
         self.clientCountChanged.emit(len(self._streams))
         self.status.emit(
             f'Streaming screen to "{client_name}" at {self._fps} fps '
@@ -396,6 +408,10 @@ class ShareServer(QObject):
             stream.send_json(message)
 
     def _drop(self, stream: MessageStream) -> None:
+        # Detach from the monitor before the deferred delete below, so it
+        # never samples a deleted stream (idempotent for never-admitted ones).
+        if self._performance is not None:
+            self._performance.remove_stream(stream)
         self._controllers.discard(stream)
         self._all_streams.discard(stream)
         self._prompting.discard(stream)
@@ -511,9 +527,11 @@ class ShareClient(QObject):
         *,
         known_servers: KnownServers | None = None,
         clipboard=None,
+        performance: PerformanceMonitor | None = None,
         parent: QObject | None = None,
     ) -> None:
         super().__init__(parent)
+        self._performance = performance
         self._client_id, self._name = identity or load_client_identity(
             db.connect(default_db_path())
         )
@@ -545,6 +563,9 @@ class ShareClient(QObject):
 
     def connect_to(self, host: str, port: int) -> None:
         self._socket.abort()  # drop any previous connection or attempt
+        if self._performance is not None:
+            # abort() emits no disconnected signal, so detach explicitly.
+            self._performance.remove_stream(self._stream)
         self._got_first_frame = False
         self._frame_count = 0
         self._last_image = None
@@ -600,6 +621,8 @@ class ShareClient(QObject):
         self._stream.send_json(hello)
 
     def _on_disconnected(self) -> None:
+        if self._performance is not None:
+            self._performance.remove_stream(self._stream)
         self.status.emit("Disconnected from server")
         self.disconnected.emit()
 
@@ -626,6 +649,11 @@ class ShareClient(QObject):
                     f'Server "{name}" accepted the connection — waiting for first frame'
                 )
                 self.connected.emit(name)
+                if self._performance is not None:
+                    # Attach only once admitted: handshake traffic is never
+                    # sampled and no ping goes to a server that hasn't
+                    # welcomed us.
+                    self._performance.add_stream(self._stream)
             case "pending":
                 self.status.emit(
                     "Server is asking its user for permission — waiting for approval"
@@ -639,6 +667,9 @@ class ShareClient(QObject):
                 if self._clipboard is not None:
                     self.status.emit("Clipboard update received from server")
                     self._clipboard.apply(message)
+            case "ping" | "pong":
+                if self._performance is not None:
+                    self._performance.handle_message(self._stream, message)
 
     def _on_frame(self, data: bytes) -> None:
         # Full frame — PNG keyframe or (legacy servers) JPEG; sniffed from

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/tests/test_client_window.py

@@ -30,6 +30,10 @@ def test_window_starts_disconnected(qapp, tmp_path):
     window = make_window(tmp_path)
     assert window.statusBar().currentMessage() == "Not connected"
     assert "Client started" in window.connection_log.toPlainText()
+    tabs = window.centralWidget()
+    labels = [tabs.tabText(i) for i in range(tabs.count())]
+    assert "Performance" in labels and "Preferences" in labels
+    assert not window.performance._timer.isActive()  # idle: no periodic work
     window.close()
 
 

remotedesktop-0.8.0/tests/test_performance.py

@@ -0,0 +1,250 @@
+import json
+
+import pytest
+from PySide6.QtGui import QShowEvent
+from PySide6.QtNetwork import QHostAddress, QTcpServer, QTcpSocket
+from PySide6.QtWidgets import QApplication
+
+from remotedesktop import db
+from remotedesktop.config import KnownServers, PairedClients
+from remotedesktop.performance import (
+    GraphWidget,
+    MetricSeries,
+    PerformanceMonitor,
+    PerformanceTab,
+)
+from remotedesktop.protocol import MessageStream
+from remotedesktop.sharing import ShareClient, ShareServer
+
+from test_sharing import IDENTITY, pump
+
+
+class FakeClock:
+    def __init__(self) -> None:
+        self.t = 1000.0
+
+    def __call__(self) -> float:
+        return self.t
+
+    def advance(self, dt: float) -> None:
+        self.t += dt
+
+
+class FakeStream:
+    def __init__(self) -> None:
+        self.bytes_sent = 0
+        self.bytes_received = 0
+        self.sent: list[dict] = []
+
+    def send_json(self, message: dict) -> None:
+        self.sent.append(message)
+
+
+def test_metric_series_trims_to_window():
+    clock = FakeClock()
+    series = MetricSeries(10.0, clock=clock)
+    series.add(1.0)
+    clock.advance(5)
+    series.add(2.0)
+    clock.advance(6)  # first sample is now 11 s old, second 6 s
+    assert [value for _t, value in series.samples()] == [2.0]
+    series.set_window(1.0)  # tightening the window re-trims immediately
+    assert series.samples() == []
+
+
+def test_monitor_samples_aggregate_bandwidth(qapp):
+    clock = FakeClock()
+    monitor = PerformanceMonitor(window_seconds=60, clock=clock)
+    first, second = FakeStream(), FakeStream()
+    monitor.add_stream(first)
+    monitor._on_tick()  # first tick establishes the baseline; no rate sample
+    assert monitor.send_bps.latest() is None
+    first.bytes_sent += 1000
+    first.bytes_received += 500
+    clock.advance(2.0)
+    monitor._on_tick()
+    assert monitor.send_bps.latest() == 500.0
+    assert monitor.recv_bps.latest() == 250.0
+    # A second stream aggregates; removing it never yields a negative rate.
+    monitor.add_stream(second)
+    second.bytes_sent += 300
+    clock.advance(1.0)
+    monitor._on_tick()
+    assert monitor.send_bps.latest() == 300.0
+    monitor.remove_stream(second)
+    clock.advance(1.0)
+    monitor._on_tick()
+    assert monitor.send_bps.latest() == 0.0
+
+
+def test_monitor_skips_rate_on_zero_elapsed(qapp):
+    monitor = PerformanceMonitor(clock=FakeClock())  # clock never advances
+    monitor.add_stream(FakeStream())
+    monitor._on_tick()
+    monitor._on_tick()
+    assert monitor.send_bps.latest() is None
+
+
+def test_ping_pong_records_rtt_and_replies(qapp):
+    clock = FakeClock()
+    monitor = PerformanceMonitor(clock=clock)
+    stream = FakeStream()
+    monitor.add_stream(stream)
+    monitor._on_tick()
+    ping = stream.sent[-1]
+    assert ping["type"] == "ping"
+    assert "rtt" not in ping  # nothing measured yet
+    clock.advance(0.05)
+    monitor.handle_message(stream, {"type": "pong", "id": ping["id"]})
+    assert monitor.rtt_ms.latest() == pytest.approx(50.0)
+    clock.advance(1.0)
+    monitor._on_tick()
+    assert stream.sent[-1]["rtt"] == pytest.approx(50.0)  # piggybacked
+    # An incoming ping is answered with an echoing pong and records peer RTT.
+    monitor.handle_message(stream, {"type": "ping", "id": 99, "rtt": 12.5})
+    assert stream.sent[-1] == {"type": "pong", "id": 99}
+    assert monitor.peer_rtt_ms.latest() == 12.5
+
+
+def test_stale_or_malformed_pongs_are_ignored(qapp):
+    monitor = PerformanceMonitor(clock=FakeClock())
+    stream = FakeStream()
+    monitor.add_stream(stream)
+    monitor.handle_message(stream, {"type": "pong", "id": 12345})
+    monitor.handle_message(stream, {"type": "pong", "id": "weird"})
+    monitor.handle_message(stream, {"type": "pong"})
+    assert monitor.rtt_ms.latest() is None
+
+
+def test_reset_clears_everything_and_stops_timer(qapp):
+    clock = FakeClock()
+    monitor = PerformanceMonitor(clock=clock)
+    monitor.add_stream(FakeStream())
+    monitor._on_tick()
+    clock.advance(1.0)
+    monitor._on_tick()
+    assert monitor._timer.isActive()
+    monitor.reset()
+    assert not monitor._timer.isActive()
+    assert monitor.send_bps.samples() == []
+    assert monitor.rtt_ms.samples() == []
+    assert monitor._pending == {}
+
+
+def test_message_stream_counts_framed_bytes(qapp):
+    listener = QTcpServer()
+    assert listener.listen(QHostAddress.SpecialAddress.LocalHost, 0)
+    out_sock = QTcpSocket()
+    out_sock.connectToHost("127.0.0.1", listener.serverPort())
+    pump(qapp, lambda: listener.hasPendingConnections())
+    in_sock = listener.nextPendingConnection()
+    sender, receiver = MessageStream(out_sock), MessageStream(in_sock)
+    got = []
+    receiver.jsonReceived.connect(got.append)
+    receiver.frameReceived.connect(got.append)
+    try:
+        sender.send_json({"a": 1})
+        sender.send_frame(b"xyz")
+        pump(qapp, lambda: len(got) == 2)
+        # 4-byte length + 1 kind byte per message, plus the payloads.
+        expected = (5 + len(json.dumps({"a": 1}).encode())) + (5 + 3)
+        assert sender.bytes_sent == expected
+        assert receiver.bytes_received == expected
+    finally:
+        out_sock.abort()
+        listener.close()
+
+
+def make_pair(credentials, tmp_path, *, server_perf, client_perf):
+    server = ShareServer(
+        approve_client=lambda *_: True,
+        credentials=credentials,
+        paired=PairedClients(db.connect(tmp_path / "server.db")),
+        performance=server_perf,
+    )
+    assert server.listen(0)
+    client = ShareClient(
+        identity=IDENTITY,
+        known_servers=KnownServers(db.connect(tmp_path / "client.db")),
+        performance=client_perf,
+    )
+    return server, client
+
+
+def test_rtt_and_bandwidth_measured_on_both_ends(qapp, credentials, tmp_path):
+    server_perf = PerformanceMonitor(interval_ms=50)
+    client_perf = PerformanceMonitor(interval_ms=50)
+    server, client = make_pair(
+        credentials, tmp_path, server_perf=server_perf, client_perf=client_perf
+    )
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        # Both sides measure their own RTT ...
+        pump(qapp, lambda: client_perf.rtt_ms.latest() is not None)
+        pump(qapp, lambda: server_perf.rtt_ms.latest() is not None)
+        # ... and learn the peer's measurement from piggybacked pings.
+        pump(qapp, lambda: client_perf.peer_rtt_ms.latest() is not None)
+        pump(qapp, lambda: server_perf.peer_rtt_ms.latest() is not None)
+        for series in (client_perf.rtt_ms, client_perf.peer_rtt_ms):
+            assert all(value >= 0 for _t, value in series.samples())
+        # Bandwidth flows: frames server->client, pings both ways.
+        pump(qapp, lambda: client_perf.recv_bps.latest() is not None)
+        pump(qapp, lambda: server_perf.send_bps.latest() is not None)
+        assert any(value > 0 for _t, value in client_perf.recv_bps.samples())
+    finally:
+        client.close()
+        server.close()
+
+
+def test_old_peer_leaves_rtt_series_empty(qapp, credentials, tmp_path):
+    # A performance-less server takes the exact code path a 0.7.0 server
+    # takes for ping messages: silently dropped, never answered.
+    client_perf = PerformanceMonitor(interval_ms=50)
+    server, client = make_pair(
+        credentials, tmp_path, server_perf=None, client_perf=client_perf
+    )
+    frames = []
+    client.frameReceived.connect(frames.append)
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        pump(qapp, lambda: len(client_perf.recv_bps.samples()) >= 2)
+        assert client_perf.rtt_ms.latest() is None
+        assert client_perf.peer_rtt_ms.latest() is None
+        assert frames  # unanswered pings don't harm the connection
+    finally:
+        client.close()
+        server.close()
+
+
+def test_graph_widgets_render_headless(qapp):
+    seeded = PerformanceMonitor()
+    seeded.send_bps.add(100.0)
+    seeded.send_bps.add(2048.0)
+    seeded.recv_bps.add(50.0)
+    for monitor in (seeded, PerformanceMonitor()):  # data and "no data" paths
+        tab = PerformanceTab(monitor)
+        tab.resize(400, 300)
+        pixmap = tab.grab()
+        assert not pixmap.isNull()
+        assert pixmap.width() > 0
+
+
+def test_tab_schedules_no_paints_while_hidden(qapp, monkeypatch):
+    monitor = PerformanceMonitor()
+    _tab = PerformanceTab(monitor)  # subscribes to monitor.updated
+    painted = []
+    monkeypatch.setattr(GraphWidget, "update", lambda self: painted.append(self))
+    monitor.updated.emit()  # tab was never shown -> not visible
+    assert painted == []
+    monkeypatch.setattr(PerformanceTab, "isVisible", lambda self: True)
+    monitor.updated.emit()
+    assert len(painted) == 2  # both graphs refreshed
+
+
+def test_tab_refreshes_on_show_event(qapp, monkeypatch):
+    monitor = PerformanceMonitor()
+    tab = PerformanceTab(monitor)
+    painted = []
+    monkeypatch.setattr(GraphWidget, "update", lambda self: painted.append(self))
+    QApplication.sendEvent(tab, QShowEvent())
+    assert len(painted) == 2

remotedesktop-0.8.0/tests/test_preferences.py

@@ -0,0 +1,31 @@
+from remotedesktop import db
+from remotedesktop.config import Settings
+from remotedesktop.performance import PerformanceMonitor
+from remotedesktop.preferences import (
+    PERFORMANCE_WINDOW_KEY,
+    PreferencesTab,
+    load_performance_window_seconds,
+)
+
+
+def test_default_and_invalid_values_fall_back(tmp_path):
+    settings = Settings(db.connect(tmp_path / "prefs.db"))
+    assert load_performance_window_seconds(settings) == 120
+    settings.set(PERFORMANCE_WINDOW_KEY, "garbage")
+    assert load_performance_window_seconds(settings) == 120
+    settings.set(PERFORMANCE_WINDOW_KEY, "-5")
+    assert load_performance_window_seconds(settings) == 120
+
+
+def test_history_change_persists_and_applies(qapp, tmp_path):
+    connection = db.connect(tmp_path / "prefs.db")
+    settings = Settings(connection)
+    monitor = PerformanceMonitor()
+    tab = PreferencesTab(settings, monitor)
+    assert tab.history_minutes.value() == 2  # the 2-minute default
+    tab.history_minutes.setValue(5)  # fires valueChanged
+    assert settings.get(PERFORMANCE_WINDOW_KEY) == "300"
+    assert monitor.window_seconds == 300.0
+    # A fresh tab (new window / restart) reads the persisted value.
+    tab2 = PreferencesTab(settings, PerformanceMonitor())
+    assert tab2.history_minutes.value() == 5

{remotedesktop-0.7.0 → remotedesktop-0.8.0}/tests/test_server_window.py

@@ -1,7 +1,9 @@
 import socket
+import sys
 
+from PySide6.QtCore import QProcess
 from PySide6.QtNetwork import QHostAddress, QTcpServer
-from PySide6.QtWidgets import QMessageBox
+from PySide6.QtWidgets import QApplication, QMessageBox
 
 from remotedesktop import db
 from remotedesktop.autostart import Autostart
@@ -33,6 +35,10 @@ def test_window_listens_and_is_discoverable(qapp, credentials, tmp_path):
         assert window._discoverable
         assert "Discoverable on this LAN" in window._summary.text()
         assert "Not sharing" in window._summary.text()
+        tabs = window.centralWidget()
+        labels = [tabs.tabText(i) for i in range(tabs.count())]
+        assert "Performance" in labels and "Preferences" in labels
+        assert not window.performance._timer.isActive()  # idle: no periodic work
     finally:
         window.close()
 
@@ -85,6 +91,40 @@ def test_autostart_checkbox_toggles_registration(qapp, credentials, tmp_path):
         window.close()
 
 
+def test_restart_declined_keeps_serving(qapp, credentials, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.No)
+    )
+    launches = []
+    monkeypatch.setattr(QProcess, "startDetached", staticmethod(lambda *a: launches.append(a)))
+    window = make_window(credentials, tmp_path)
+    try:
+        window._restart_server()
+        assert launches == []
+        assert window.share_server._server.isListening()
+        assert window.responder is not None
+    finally:
+        window.close()
+
+
+def test_restart_frees_ports_and_relaunches(qapp, credentials, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.Yes)
+    )
+    launches, quits = [], []
+    monkeypatch.setattr(
+        QProcess, "startDetached", staticmethod(lambda *a: launches.append(a) or True)
+    )
+    monkeypatch.setattr(QApplication, "quit", staticmethod(lambda: quits.append(True)))
+    window = make_window(credentials, tmp_path)
+    window._restart_server()
+    # Ports are freed before the new process is spawned, so it can bind them.
+    assert window.responder is None
+    assert not window.share_server._server.isListening()
+    assert launches == [(sys.executable, ["-m", "remotedesktop.server"])]
+    assert quits == [True]
+
+
 def stub_approval_prompt(monkeypatch, button):
     """Answer _ask_approval's stay-on-top QMessageBox without showing any UI.