remotedesktop 0.7.0__tar.gz → 0.9.0__tar.gz

{remotedesktop-0.7.0 → remotedesktop-0.9.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.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.7.0
+Version: 0.9.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.9.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.9.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.9.0"

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

@@ -23,11 +23,13 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
-from remotedesktop import db, logs, window_state
+from remotedesktop import db, icon, logs, window_state
 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
 
@@ -91,8 +93,14 @@ class ClientWindow(QMainWindow):
     ) -> None:
         super().__init__()
         self.setWindowTitle("Remote Desktop Client")
+        self.setWindowIcon(icon.app_icon("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 +109,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 +121,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 +138,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 +189,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
@@ -254,7 +265,9 @@ class ClientWindow(QMainWindow):
 
 def main() -> None:  # pragma: no cover - runs the Qt event loop
     log_path = logs.init_logging("client")
+    icon.set_windows_app_id("remotedesktop.client")
     app = QApplication(sys.argv)
+    app.setWindowIcon(icon.app_icon("client"))
     window = ClientWindow()  # auto_scan starts the first LAN scan
     window.log(f"Detailed log: {log_path}")
     window.show()

remotedesktop-0.9.0/src/remotedesktop/icon.py

@@ -0,0 +1,69 @@
+"""The application icon, drawn in code.
+
+A monitor with a mouse pointer on the screen — "this desktop is controlled
+remotely". Painted with QPainter at every common icon size (no binary asset
+to version or package), with an accent color per app so the client (blue)
+and server (green) are distinguishable in the taskbar when both run on one
+machine.
+"""
+
+import ctypes
+import sys
+
+from PySide6.QtCore import QPointF, QRectF, Qt
+from PySide6.QtGui import QColor, QIcon, QPainter, QPixmap, QPolygonF
+
+_SIZES = (16, 24, 32, 48, 64, 128, 256)
+_FRAME = QColor("#37474f")
+_ACCENTS = {"client": QColor("#1e88e5"), "server": QColor("#43a047")}
+# A classic cursor-arrow outline on a 0..17 grid, placed on the screen.
+_POINTER = [(0, 0), (0, 14), (4, 11), (7, 17), (9.5, 16), (6.5, 10), (11, 10)]
+
+
+def _pixmap(size: int, accent: QColor) -> QPixmap:
+    pixmap = QPixmap(size, size)
+    pixmap.fill(Qt.GlobalColor.transparent)
+    painter = QPainter(pixmap)
+    painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+    s = size / 64.0
+    painter.setPen(Qt.PenStyle.NoPen)
+    # Monitor frame, screen, stand, base.
+    painter.setBrush(_FRAME)
+    painter.drawRoundedRect(QRectF(4 * s, 6 * s, 56 * s, 40 * s), 5 * s, 5 * s)
+    painter.setBrush(accent)
+    painter.drawRoundedRect(QRectF(9 * s, 11 * s, 46 * s, 30 * s), 2 * s, 2 * s)
+    painter.setBrush(_FRAME)
+    painter.drawRect(QRectF(28 * s, 46 * s, 8 * s, 6 * s))
+    painter.drawRoundedRect(QRectF(18 * s, 52 * s, 28 * s, 5 * s), 2 * s, 2 * s)
+    # Mouse pointer on the screen: remote control.
+    pointer = QPolygonF(
+        [QPointF((22 + x * 1.4) * s, (14 + y * 1.4) * s) for x, y in _POINTER]
+    )
+    painter.setBrush(QColor("white"))
+    painter.drawPolygon(pointer)
+    painter.end()
+    return pixmap
+
+
+def app_icon(role: str) -> QIcon:
+    """The window/taskbar icon for "client" or "server"."""
+    accent = _ACCENTS[role]
+    icon = QIcon()
+    for size in _SIZES:
+        icon.addPixmap(_pixmap(size, accent))
+    return icon
+
+
+def set_windows_app_id(app_id: str) -> None:
+    """Give this process its own Windows taskbar identity.
+
+    Without it, Windows groups the app under the Python interpreter's
+    identity and may show the interpreter's icon in the taskbar instead of
+    the window icon. Harmless no-op off Windows or on failure.
+    """
+    if sys.platform != "win32":  # pragma: no cover - Windows is the target
+        return
+    try:
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_id)
+    except (AttributeError, OSError):  # pragma: no cover - defensive
+        pass

remotedesktop-0.9.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.9.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.9.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())