remotedesktop 0.14.0__tar.gz → 0.16.0__tar.gz

{remotedesktop-0.14.0 → remotedesktop-0.16.0}/CLAUDE.md

@@ -51,7 +51,7 @@ Managed with `uv` (hatchling build backend, src layout):
 - **Log exchange**: either side can fetch the peer's debug log over the connection (`{"type": "log_request"}` → `{"type": "log", "text": ...}`, admitted streams only). `ShareServer`/`ShareClient` take a `log_provider=` callable (the windows pass `logs.read_log_tail("server"/"client")`, capped at `logs.TAIL_BYTES`); a missing provider/file answers with a placeholder rather than hanging the requester. Both windows have a "Get client log"/"Get server log" button in the Connection log tab; the reply opens a `logs.PeerLogDialog`. The server requests from the most recently admitted stream.
 - **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).
+- **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 **every** attached stream (each ping id maps to its stream; a pong is honored only on the stream it was sent to). The graphs' RTT series follow only the *active* (most recently admitted) stream; per-stream send/recv/RTT snapshots come from `metrics_for(stream)` and feed the server's Status-tab `ViewersTable` (`server.py`), which joins them with `ShareServer.viewers()` — identity fields (`user`/`host`/`os`) that the client hello reports (`_client_details()`; missing on old clients, shown as dashes). The ping is: `{"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.14.0 → remotedesktop-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.14.0
+Version: 0.16.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

{remotedesktop-0.14.0 → remotedesktop-0.16.0}/src/remotedesktop/__init__.py

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

{remotedesktop-0.14.0 → remotedesktop-0.16.0}/src/remotedesktop/performance.py

@@ -93,6 +93,35 @@ class MetricSeries:
         while self._samples and self._samples[0][0] < cutoff:
             self._samples.popleft()
 
+    def statistics(self) -> dict | None:
+        """`sample_statistics` over the samples still in the window."""
+        return sample_statistics([value for _t, value in self.samples()])
+
+
+def sample_statistics(values: list[float]) -> dict | None:
+    """Summary statistics for a sample list, or None when it is empty:
+    {"count", "mean", "min", "max", "p99", "jitter"}. Jitter is the mean
+    absolute difference of *consecutive* samples (the classic packet-jitter
+    definition), so a steady 100 ms link has zero jitter while one bouncing
+    1↔100 ms scores high; p99 is nearest-rank."""
+    if not values:
+        return None
+    ordered = sorted(values)
+    count = len(values)
+    jitter = (
+        sum(abs(b - a) for a, b in zip(values, values[1:])) / (count - 1)
+        if count > 1
+        else 0.0
+    )
+    return {
+        "count": count,
+        "mean": sum(values) / count,
+        "min": ordered[0],
+        "max": ordered[-1],
+        "p99": ordered[max(0, math.ceil(0.99 * count) - 1)],
+        "jitter": jitter,
+    }
+
 
 class PerformanceMonitor(QObject):
     """Samples bandwidth and measures RTT for the attached streams.
@@ -107,6 +136,10 @@ class PerformanceMonitor(QObject):
     updated = Signal()  # one emit per sample tick
     connectionLost = Signal(object)  # the active stream whose responsive peer went silent
 
+    # Graphs aggregate bandwidth across streams and plot the *active* (most
+    # recently attached) stream's RTT as a single coherent line; per-stream
+    # numbers for all attached streams are available via metrics_for().
+
     def __init__(
         self,
         *,
@@ -126,6 +159,14 @@ class PerformanceMonitor(QObject):
         self.peer_rtt_ms = MetricSeries(window_seconds, clock=clock)
         self._streams: list[StreamLike] = []
         self._baselines: dict[StreamLike, tuple[int, int]] = {}
+        # Per-stream numbers (for the server's viewers table); the rolling
+        # series above stay aggregate/active-stream only. RTT keeps a full
+        # window-following series per stream so the table can show window
+        # statistics, not just the latest sample.
+        self._stream_send_bps: dict[StreamLike, float] = {}
+        self._stream_recv_bps: dict[StreamLike, float] = {}
+        self._stream_rtt: dict[StreamLike, MetricSeries] = {}
+        self._stream_peer_rtt: dict[StreamLike, float] = {}
         self._active: StreamLike | None = None
         # Dead-connection detection, all scoped to the active stream: when its
         # bytes_received counter last grew, whether its peer ever answered a
@@ -133,7 +174,7 @@ class PerformanceMonitor(QObject):
         self._last_data: float | None = None
         self._peer_responsive = False
         self._lost_reported = False
-        self._pending: dict[int, float] = {}
+        self._pending: dict[int, tuple[StreamLike, float]] = {}
         self._ids = itertools.count(1)
         self._last_tick: float | None = None
         self._tick_count = 0
@@ -153,6 +194,8 @@ class PerformanceMonitor(QObject):
         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)
+        for series in self._stream_rtt.values():
+            series.set_window(window_seconds)
 
     def add_stream(self, stream: StreamLike) -> None:
         if stream not in self._baselines:
@@ -168,6 +211,15 @@ class PerformanceMonitor(QObject):
             return
         self._streams.remove(stream)
         del self._baselines[stream]
+        for per_stream in (
+            self._stream_send_bps,
+            self._stream_recv_bps,
+            self._stream_rtt,
+            self._stream_peer_rtt,
+        ):
+            per_stream.pop(stream, None)
+        for ping_id in [i for i, (s, _t) in self._pending.items() if s is stream]:
+            del self._pending[ping_id]
         if self._active is stream:
             self._activate(self._streams[-1] if self._streams else None)
         if not self._streams:
@@ -175,6 +227,20 @@ class PerformanceMonitor(QObject):
             self._pending.clear()
             self._last_tick = None
 
+    def metrics_for(self, stream: StreamLike) -> dict:
+        """Numbers for one attached stream (None where not yet measured):
+        {"send_bps", "recv_bps", "rtt_ms", "peer_rtt_ms", "rtt_stats"} —
+        rtt_ms is the latest sample, rtt_stats the `sample_statistics`
+        summary over the rolling window."""
+        rtt_series = self._stream_rtt.get(stream)
+        return {
+            "send_bps": self._stream_send_bps.get(stream),
+            "recv_bps": self._stream_recv_bps.get(stream),
+            "rtt_ms": rtt_series.latest() if rtt_series is not None else None,
+            "peer_rtt_ms": self._stream_peer_rtt.get(stream),
+            "rtt_stats": rtt_series.statistics() if rtt_series is not None else None,
+        }
+
     def _activate(self, stream: StreamLike | None) -> None:
         self._active = stream
         self._last_data = self._clock() if stream is not None else None
@@ -193,6 +259,8 @@ class PerformanceMonitor(QObject):
             case "ping":
                 stream.send_json({"type": "pong", "id": message.get("id")})
                 rtt = message.get("rtt")
+                if isinstance(rtt, (int, float)):
+                    self._stream_peer_rtt[stream] = float(rtt)
                 if stream is self._active:
                     # A peer that pings us runs this feature too — that arms
                     # the silence detector just as well as a pong does.
@@ -204,35 +272,57 @@ class PerformanceMonitor(QObject):
                     self._peer_responsive = True
                 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)
+                    pending = self._pending.pop(ping_id, None)
+                    # Only honor a pong arriving on the stream it was sent to.
+                    if pending is not None and pending[0] is stream:
+                        rtt_ms = (self._clock() - pending[1]) * 1000.0
+                        series = self._stream_rtt.get(stream)
+                        if series is None:
+                            series = self._stream_rtt[stream] = MetricSeries(
+                                self._window, clock=self._clock
+                            )
+                        series.add(rtt_ms)
+                        if stream is self._active:
+                            self.rtt_ms.add(rtt_ms)
 
     def _on_tick(self) -> None:
         now = self._clock()
+        elapsed = now - self._last_tick if self._last_tick is not None else None
         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
+            sent = stream.bytes_sent - base_sent
+            received = stream.bytes_received - base_received
+            delta_sent += sent
+            delta_received += received
+            if elapsed is not None and elapsed > 0:
+                self._stream_send_bps[stream] = sent / elapsed
+                self._stream_recv_bps[stream] = received / elapsed
             if stream is self._active and stream.bytes_received > base_received:
                 self._last_data = now
             self._baselines[stream] = (stream.bytes_sent, stream.bytes_received)
-        if self._last_tick is not None and (elapsed := now - self._last_tick) > 0:
+        if elapsed is not None and elapsed > 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]
+        for ping_id in [
+            i for i, (_s, t) in self._pending.items() if now - t > _PING_PRUNE_SECONDS
+        ]:
+            del self._pending[ping_id]
+        # Every stream gets its own ping so the viewers table can show
+        # per-viewer RTT; each ping carries our latest measurement for that
+        # same link, so both ends see both directions.
+        for stream in self._streams:
             ping_id = next(self._ids)
-            self._pending[ping_id] = now
+            self._pending[ping_id] = (stream, now)
             ping: dict = {"type": "ping", "id": ping_id}
-            if (rtt := self.rtt_ms.latest()) is not None:
+            series = self._stream_rtt.get(stream)
+            if series is not None and (rtt := series.latest()) is not None:
                 ping["rtt"] = rtt
-            self._active.send_json(ping)
+            stream.send_json(ping)
 
+        if self._active is not None:
             if (
                 self._peer_responsive
                 and not self._lost_reported
@@ -311,6 +401,7 @@ class GraphWidget(QWidget):
         format_value: Callable[[float], str],
         *,
         tick_unit: Callable[[float], float] = lambda _value: 1.0,
+        show_stats: bool = False,
         clock: Callable[[], float] = time.monotonic,
         parent: QWidget | None = None,
     ) -> None:
@@ -323,8 +414,12 @@ class GraphWidget(QWidget):
         # the axis ceiling is a round number of that unit (100 KB/s, not the
         # 97.7 KB/s that a round number of bytes/s would render as).
         self._tick_unit = tick_unit
+        # One extra bottom row per series with window statistics
+        # (mean/min/max/p99/jitter) — used by the round-trip-time graph.
+        self._show_stats = show_stats
         self._clock = clock
-        self.setMinimumSize(300, 140)  # room for the axis-label rows
+        extra_rows = len(series) if show_stats else 0
+        self.setMinimumSize(300, 140 + extra_rows * self.fontMetrics().height())
 
     def paintEvent(self, event: QPaintEvent) -> None:
         painter = QPainter(self)
@@ -356,10 +451,16 @@ class GraphWidget(QWidget):
         y_ticks = [y_max * i / _GRID_DIVISIONS for i in range(_GRID_DIVISIONS + 1)]
         y_labels = [self._format_value(v) for v in y_ticks]
         left = 8 + max(metrics.horizontalAdvance(t) for t in y_labels) + 6
-        graph = self.rect().adjusted(left, 24, -12, -(2 * metrics.height() + 12))
+        # Bottom rows: X tick labels, legend, then (optionally) one
+        # statistics line per series.
+        bottom_rows = 2 + (len(self._series) if self._show_stats else 0)
+        graph = self.rect().adjusted(left, 24, -12, -(bottom_rows * metrics.height() + 10))
 
+        # Solid but translucent: dotted lines all but vanished on high-DPI
+        # displays, where the dots land between device pixels.
         grid_color = palette.color(palette.ColorRole.Mid)
-        grid_pen = QPen(grid_color, 0, Qt.PenStyle.DotLine)
+        grid_color.setAlpha(150)
+        grid_pen = QPen(grid_color, 0)
         text_color = palette.color(palette.ColorRole.Text)
         for value, label in zip(y_ticks, y_labels):
             y = graph.bottom() - graph.height() * (value / y_max)
@@ -383,10 +484,11 @@ class GraphWidget(QWidget):
             text_x = min(max(x - width / 2, graph.left()), graph.right() - width)
             painter.setPen(text_color)
             painter.drawText(round(text_x), x_label_baseline, label)
+        legend_baseline = x_label_baseline + metrics.height()
         caption = "seconds ago"
         painter.drawText(
             self.rect().right() - 8 - metrics.horizontalAdvance(caption),
-            self.rect().bottom() - 6,
+            legend_baseline,
             caption,
         )
 
@@ -401,14 +503,30 @@ class GraphWidget(QWidget):
             painter.setPen(color)
             painter.drawPolyline(polyline)
 
-        # Legend with latest values along the bottom edge.
+        # Legend with latest values, then one statistics row per series.
         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(round(x), self.rect().bottom() - 6, text)
+            painter.drawText(round(x), legend_baseline, text)
             x += metrics.horizontalAdvance(text) + 16
+        if self._show_stats:
+            baseline = legend_baseline
+            fmt = self._format_value
+            for label, color, samples in data:
+                baseline += metrics.height()
+                stats = sample_statistics([value for _t, value in samples])
+                if stats is None:
+                    text = f"{label}: no data in window"
+                else:
+                    text = (
+                        f"{label}:  mean {fmt(stats['mean'])} · min {fmt(stats['min'])}"
+                        f" · max {fmt(stats['max'])} · p99 {fmt(stats['p99'])}"
+                        f" · jitter {fmt(stats['jitter'])} · n={stats['count']}"
+                    )
+                painter.setPen(color)
+                painter.drawText(graph.left(), baseline, text)
 
 
 class PerformanceTab(QWidget):
@@ -450,6 +568,7 @@ class PerformanceTab(QWidget):
             ],
             monitor,
             format_ms,
+            show_stats=True,
         )
         layout = QVBoxLayout(self)
         layout.addWidget(self.bandwidth_graph, stretch=1)

{remotedesktop-0.14.0 → remotedesktop-0.16.0}/src/remotedesktop/server.py

@@ -8,15 +8,19 @@ import sys
 import time
 
 from PySide6.QtCore import QProcess, Qt
-from PySide6.QtGui import QCloseEvent
+from PySide6.QtGui import QCloseEvent, QShowEvent
 from PySide6.QtWidgets import (
+    QAbstractItemView,
     QApplication,
     QCheckBox,
+    QHeaderView,
     QLabel,
     QMainWindow,
     QMessageBox,
     QPlainTextEdit,
     QPushButton,
+    QTableWidget,
+    QTableWidgetItem,
     QTabWidget,
     QVBoxLayout,
     QWidget,
@@ -34,13 +38,97 @@ from remotedesktop.discovery import (
 from remotedesktop.inventory import ConnectionInventory, InventoryTab
 from remotedesktop.logs import PeerLogDialog, read_log_tail
 from remotedesktop.modal_loop import ModalLoopPump
-from remotedesktop.performance import PerformanceMonitor, PerformanceTab
+from remotedesktop.performance import PerformanceMonitor, PerformanceTab, format_ms, format_rate
 from remotedesktop.preferences import PreferencesTab, load_performance_window_seconds
 from remotedesktop.sharing import ShareServer
 
 _log = logging.getLogger("remotedesktop.server")
 
 
+class ViewersTable(QTableWidget):
+    """Connected viewers with who/what they are and live per-viewer metrics.
+
+    Identity fields come from each viewer's hello (`ShareServer.viewers()`);
+    Send/Receive/Round trip come from the performance monitor's per-stream
+    numbers. Rows refresh when the viewer count changes and once per monitor
+    tick — but only while visible (background tabs schedule no work).
+    """
+
+    _COLUMNS = [
+        "Name", "Address", "User", "Computer", "OS", "Send", "Receive",
+        "RTT", "RTT mean", "RTT min", "RTT max", "RTT p99", "RTT jitter",
+    ]
+    # Metric cells change text every tick, so their columns get a constant
+    # width (sized to the widest plausible value) instead of
+    # ResizeToContents — otherwise the columns visibly jitter each second.
+    _RATE_COLUMNS = (5, 6)  # Send / Receive
+    _MS_COLUMNS = (7, 8, 9, 10, 11, 12)  # RTT latest + window statistics
+    _METRIC_COLUMNS = _RATE_COLUMNS + _MS_COLUMNS
+
+    def __init__(self, share_server, performance: PerformanceMonitor, parent=None) -> None:
+        # One extra headerless column takes the stretch so the data columns
+        # stay sized to their contents (the InventoryTab spacer pattern).
+        super().__init__(0, len(self._COLUMNS) + 1, parent)
+        self.setHorizontalHeaderLabels(self._COLUMNS + [""])
+        self.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self.setSelectionMode(QAbstractItemView.SelectionMode.NoSelection)
+        self.verticalHeader().setVisible(False)
+        header = self.horizontalHeader()
+        header.setSectionResizeMode(QHeaderView.ResizeMode.ResizeToContents)
+        header.setStretchLastSection(True)
+        rate_width = self.fontMetrics().horizontalAdvance("9999.9 MB/s") + 24
+        ms_width = self.fontMetrics().horizontalAdvance("9999.9 ms") + 24
+        for column in self._METRIC_COLUMNS:
+            header.setSectionResizeMode(column, QHeaderView.ResizeMode.Fixed)
+            self.setColumnWidth(column, rate_width if column in self._RATE_COLUMNS else ms_width)
+        self._share_server = share_server
+        self._performance = performance
+        share_server.clientCountChanged.connect(self._on_count_changed)
+        performance.updated.connect(self._on_monitor_tick)
+        self.refresh()
+
+    def _on_count_changed(self, _count: int) -> None:
+        self.refresh()
+
+    def _on_monitor_tick(self) -> None:
+        if self.isVisible():
+            self.refresh()
+
+    def showEvent(self, event: QShowEvent) -> None:
+        super().showEvent(event)
+        self.refresh()  # catch up on metrics accrued while hidden
+
+    def refresh(self) -> None:
+        viewers = self._share_server.viewers()
+        self.setRowCount(len(viewers))
+        for row, viewer in enumerate(viewers):
+            metrics = self._performance.metrics_for(viewer["stream"])
+            send, recv, rtt = metrics["send_bps"], metrics["recv_bps"], metrics["rtt_ms"]
+            stats = metrics["rtt_stats"] or {}
+            values = [
+                viewer["name"] or "(unknown)",
+                viewer["address"],
+                viewer["user"] or "—",
+                viewer["host"] or "—",
+                viewer["os"] or "—",
+                format_rate(send) if send is not None else "—",
+                format_rate(recv) if recv is not None else "—",
+                format_ms(rtt) if rtt is not None else "—",
+            ] + [
+                format_ms(stats[key]) if key in stats else "—"
+                for key in ("mean", "min", "max", "p99", "jitter")
+            ]
+            for column, value in enumerate(values):
+                item = QTableWidgetItem(value)
+                if column in self._METRIC_COLUMNS:
+                    # Right-aligned numbers change magnitude without the
+                    # digits appearing to wander.
+                    item.setTextAlignment(
+                        Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter
+                    )
+                self.setItem(row, column, item)
+
+
 class ServerWindow(QMainWindow):
     def __init__(
         self,
@@ -90,9 +178,10 @@ class ServerWindow(QMainWindow):
         status_tab = QWidget()
         status_layout = QVBoxLayout(status_tab)
         status_layout.addWidget(self._summary)
+        # The viewers table is inserted here (index 1) once share_server
+        # exists, taking the tab's spare space.
         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())
@@ -133,6 +222,8 @@ class ServerWindow(QMainWindow):
             log_provider=lambda: read_log_tail("server"),
             parent=self,
         )
+        self.viewers_table = ViewersTable(self.share_server, self.performance)
+        status_layout.insertWidget(1, self.viewers_table, stretch=1)
         self.share_server.status.connect(self.log)
         self.share_server.clientCountChanged.connect(self._update_summary)
         self.share_server.peerEvent.connect(self._record_peer)

{remotedesktop-0.14.0 → remotedesktop-0.16.0}/src/remotedesktop/sharing.py

@@ -13,8 +13,10 @@ Both classes emit human-readable `status` messages for every phase so the
 GUIs can show a debug log.
 """
 
+import getpass
 import hmac
 import logging
+import platform
 import socket as socket_module
 import time
 from collections.abc import Callable
@@ -66,7 +68,26 @@ _PREAUTH_MAX_PAYLOAD = 64 * 1024
 
 
 def _peer(sock: QTcpSocket) -> str:
-    return f"{sock.peerAddress().toString()}:{sock.peerPort()}"
+    host = sock.peerAddress().toString()
+    # The server listens dual-stack, so IPv4 peers arrive as IPv4-mapped
+    # IPv6 addresses ("::ffff:192.168.6.29") — show them as plain IPv4.
+    if host.startswith("::ffff:"):
+        host = host[len("::ffff:") :]
+    return f"{host}:{sock.peerPort()}"
+
+
+def _client_details() -> dict:
+    """Who and what this client machine is, shown in the server's viewers
+    table. Best-effort: a missing login name just yields an empty field."""
+    try:
+        user = getpass.getuser()
+    except OSError:
+        user = ""
+    return {
+        "user": user,
+        "host": socket_module.gethostname(),
+        "os": f"{platform.system()} {platform.release()} ({platform.version()})",
+    }
 
 
 def _coord(value) -> float:
@@ -129,6 +150,9 @@ class ShareServer(QObject):
         # backlog, or asked for one), and the previous capture to diff.
         self._delta_capable: set[MessageStream] = set()
         self._needs_keyframe: set[MessageStream] = set()
+        # What each stream's hello said about the machine behind it
+        # (name/user/host/os), for the server UI's viewers table.
+        self._viewer_info: dict[MessageStream, dict] = {}
         self._previous_frame: QImage | None = None
         # DXGI desktop duplication (~10 ms per changed 4K frame, ~0 when the
         # screen is idle, vs ~96 ms for grabWindow). Created lazily on the
@@ -184,6 +208,7 @@ class ShareServer(QObject):
         self._backlogged.clear()
         self._delta_capable.clear()
         self._needs_keyframe.clear()
+        self._viewer_info.clear()
         self._previous_frame = None
         if self._dxgi is not None:
             self._dxgi.close()
@@ -264,6 +289,21 @@ class ShareServer(QObject):
             return
         self._handle_hello(stream, message)
 
+    def viewers(self) -> list[dict]:
+        """One entry per admitted stream for the server UI's viewers table:
+        {name, address, user, host, os, stream} — the stream is the key for
+        PerformanceMonitor.metrics_for."""
+        result = []
+        for stream in self._streams:
+            info = dict(self._viewer_info.get(stream, {}))
+            info.setdefault("name", "")
+            info.setdefault("address", _peer(stream.socket))
+            for field in ("user", "host", "os"):
+                info.setdefault(field, "")
+            info["stream"] = stream
+            result.append(info)
+        return result
+
     def revoke_client(self, client_id: str) -> None:
         """Remove a client's pairing and disconnect it if currently connected.
 
@@ -305,6 +345,13 @@ class ShareServer(QObject):
         self.status.emit(f'Hello from "{client_name}" ({client_id}) at {peer}')
         if message.get("delta"):
             self._delta_capable.add(stream)
+        self._viewer_info[stream] = {
+            "name": client_name,
+            "address": peer,
+            "user": str(message.get("user", "")),
+            "host": str(message.get("host", "")),
+            "os": str(message.get("os", "")),
+        }
         if isinstance(client_id, str) and client_id:
             self._stream_key[stream] = (client_id, client_name, peer)
             self._emit_peer(stream, "attempt")
@@ -471,6 +518,7 @@ class ShareServer(QObject):
         self._backlogged.discard(stream)
         self._delta_capable.discard(stream)
         self._needs_keyframe.discard(stream)
+        self._viewer_info.pop(stream, None)
         self._release_input(stream)
         final = stream in self._final
         self._final.discard(stream)
@@ -714,6 +762,7 @@ class ShareClient(QObject):
             "client_id": self._client_id,
             "name": self._name,
             "delta": True,  # we understand inter-frame delta messages
+            **_client_details(),
         }
         if self._server_token:
             hello["token"] = self._server_token

{remotedesktop-0.14.0 → remotedesktop-0.16.0}/tests/test_performance.py

@@ -54,6 +54,44 @@ def test_metric_series_trims_to_window():
     assert series.samples() == []
 
 
+def test_sample_statistics_summarize_the_window():
+    from remotedesktop.performance import sample_statistics
+
+    assert sample_statistics([]) is None
+    single = sample_statistics([5.0])
+    assert single == {
+        "count": 1, "mean": 5.0, "min": 5.0, "max": 5.0, "p99": 5.0, "jitter": 0.0,
+    }
+    stats = sample_statistics([2.0, 4.0, 2.0, 12.0])
+    assert stats is not None
+    assert stats["count"] == 4
+    assert stats["mean"] == 5.0
+    assert stats["min"] == 2.0 and stats["max"] == 12.0
+    assert stats["p99"] == 12.0  # nearest-rank on a small sample = max
+    # Jitter: mean |consecutive delta| = (2 + 2 + 10) / 3
+    assert stats["jitter"] == pytest.approx(14.0 / 3.0)
+    # A steady series has zero jitter no matter its level.
+    steady = sample_statistics([100.0] * 50)
+    assert steady is not None and steady["jitter"] == 0.0
+    # p99 excludes a single outlier once there are >= 100 samples.
+    many = sample_statistics([10.0] * 99 + [500.0])
+    assert many is not None and many["p99"] == 10.0
+
+
+def test_metric_series_statistics_follow_the_window():
+    clock = FakeClock()
+    series = MetricSeries(10.0, clock=clock)
+    assert series.statistics() is None
+    series.add(100.0)  # will age out of the window
+    clock.advance(8.0)
+    for value in (2.0, 4.0):
+        series.add(value)
+    clock.advance(3.0)  # first sample is now 11 s old
+    stats = series.statistics()
+    assert stats is not None
+    assert stats["count"] == 2 and stats["max"] == 4.0  # 100.0 aged out
+
+
 def test_monitor_samples_aggregate_bandwidth(qapp):
     clock = FakeClock()
     monitor = PerformanceMonitor(window_seconds=60, clock=clock)
@@ -108,6 +146,61 @@ def test_ping_pong_records_rtt_and_replies(qapp):
     assert monitor.peer_rtt_ms.latest() == 12.5
 
 
+def test_per_stream_metrics_track_each_viewer(qapp):
+    clock = FakeClock()
+    monitor = PerformanceMonitor(clock=clock)
+    first, second = FakeStream(), FakeStream()
+    monitor.add_stream(first)
+    monitor.add_stream(second)
+    monitor._on_tick()  # baselines; every attached stream gets its own ping
+    assert [m["type"] for m in first.sent] == ["ping"]
+    assert [m["type"] for m in second.sent] == ["ping"]
+    first.bytes_sent += 1000
+    second.bytes_sent += 500
+    clock.advance(2.0)
+    monitor._on_tick()
+    assert monitor.metrics_for(first)["send_bps"] == 500.0
+    assert monitor.metrics_for(second)["send_bps"] == 250.0
+    # Each stream's pong records that stream's RTT; the graph series only
+    # follows the active (most recently attached) stream.
+    clock.advance(0.05)
+    monitor.handle_message(first, {"type": "pong", "id": first.sent[-1]["id"]})
+    assert monitor.metrics_for(first)["rtt_ms"] == pytest.approx(50.0)
+    assert monitor.rtt_ms.latest() is None  # first is not the active stream
+    # An incoming ping's piggybacked measurement lands on its own stream.
+    monitor.handle_message(first, {"type": "ping", "id": 99, "rtt": 12.5})
+    assert monitor.metrics_for(first)["peer_rtt_ms"] == 12.5
+    assert monitor.peer_rtt_ms.latest() is None
+    # A pong answered on the wrong stream is ignored.
+    monitor.handle_message(first, {"type": "pong", "id": second.sent[-1]["id"]})
+    assert monitor.metrics_for(second)["rtt_ms"] is None
+    # Removing a stream clears its numbers.
+    monitor.remove_stream(first)
+    assert monitor.metrics_for(first) == {
+        "send_bps": None, "recv_bps": None, "rtt_ms": None, "peer_rtt_ms": None,
+        "rtt_stats": None,
+    }
+
+
+def test_per_stream_rtt_statistics_cover_the_window(qapp):
+    clock = FakeClock()
+    monitor = PerformanceMonitor(clock=clock)
+    stream = FakeStream()
+    monitor.add_stream(stream)
+    for rtt_s in (0.010, 0.020, 0.090):
+        monitor._on_tick()
+        clock.advance(rtt_s)
+        monitor.handle_message(stream, {"type": "pong", "id": stream.sent[-1]["id"]})
+        clock.advance(1.0)
+    stats = monitor.metrics_for(stream)["rtt_stats"]
+    assert stats is not None
+    assert stats["count"] == 3
+    assert stats["min"] == pytest.approx(10.0)
+    assert stats["max"] == pytest.approx(90.0)
+    assert stats["mean"] == pytest.approx(40.0)
+    assert monitor.metrics_for(stream)["rtt_ms"] == pytest.approx(90.0)
+
+
 def test_stale_or_malformed_pongs_are_ignored(qapp):
     monitor = PerformanceMonitor(clock=FakeClock())
     stream = FakeStream()
@@ -173,6 +266,32 @@ def make_pair(credentials, tmp_path, *, server_perf, client_perf):
     return server, client
 
 
+def test_server_viewers_snapshot_carries_hello_details(qapp, credentials, tmp_path):
+    server_perf = PerformanceMonitor(interval_ms=50)
+    server, client = make_pair(
+        credentials,
+        tmp_path,
+        server_perf=server_perf,
+        client_perf=PerformanceMonitor(interval_ms=50),  # answers the pings
+    )
+    connected = []
+    client.connected.connect(connected.append)
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        pump(qapp, lambda: connected)
+        viewers = server.viewers()
+        assert len(viewers) == 1
+        viewer = viewers[0]
+        assert viewer["name"] and viewer["user"] and viewer["host"]
+        assert viewer["os"].startswith("Windows")
+        assert "127.0.0.1" in viewer["address"]
+        # The stream key links the snapshot to per-viewer metrics.
+        pump(qapp, lambda: server_perf.metrics_for(viewer["stream"])["rtt_ms"] is not None)
+    finally:
+        client.close()
+        server.close()
+
+
 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)

{remotedesktop-0.14.0 → remotedesktop-0.16.0}/tests/test_server_window.py

@@ -201,6 +201,77 @@ def test_approval_prompt_pairs_client_and_updates_summary(qapp, credentials, tmp
         window.close()
 
 
+def test_viewers_table_lists_connected_client_details(qapp, credentials, tmp_path, monkeypatch):
+    stub_approval_prompt(monkeypatch, QMessageBox.StandardButton.Yes)
+    window = make_window(credentials, tmp_path)
+    client = make_client(tmp_path)
+    names = []
+    client.connected.connect(names.append)
+    assert window.viewers_table.rowCount() == 0
+    client.connect_to("127.0.0.1", window.share_server.port)
+    try:
+        pump(qapp, lambda: names)
+        pump(qapp, lambda: window.viewers_table.rowCount() == 1)
+        row = []
+        for column in range(len(window.viewers_table._COLUMNS)):
+            item = window.viewers_table.item(0, column)
+            assert item is not None
+            row.append(item.text())
+        name, address, user, host, os_info, send, recv, rtt = row[:8]
+        # The hello carried this machine's real login/host/OS details.
+        assert name and user != "—" and host != "—"
+        assert "127.0.0.1" in address and "::ffff:" not in address
+        assert os_info.startswith("Windows")
+        # No monitor tick has necessarily run yet; metrics are dashes or values.
+        assert send and recv and rtt
+        client.close()
+        pump(qapp, lambda: window.viewers_table.rowCount() == 0)
+    finally:
+        client.close()
+        window.close()
+
+
+def test_viewers_table_metric_columns_keep_constant_width(qapp):
+    from PySide6.QtCore import QObject, Signal
+
+    from remotedesktop.performance import PerformanceMonitor
+    from remotedesktop.server import ViewersTable
+    from test_performance import FakeStream
+
+    class FakeShareServer(QObject):
+        clientCountChanged = Signal(int)
+
+        def __init__(self, viewers):
+            super().__init__()
+            self._viewers = viewers
+
+        def viewers(self):
+            return self._viewers
+
+    stream = FakeStream()
+    monitor = PerformanceMonitor()
+    viewer = {"name": "n", "address": "a", "user": "u", "host": "h", "os": "o", "stream": stream}
+    table = ViewersTable(FakeShareServer([viewer]), monitor)
+    widths = [table.columnWidth(c) for c in ViewersTable._METRIC_COLUMNS]
+    assert all(w > 0 for w in widths)
+    # Values swinging from B/s to hundreds of MB/s must not move the columns.
+    from remotedesktop.performance import MetricSeries
+
+    rtt_series = MetricSeries(120.0)
+    rtt_series.add(2.1)
+    monitor._stream_send_bps[stream] = 312.0
+    monitor._stream_recv_bps[stream] = 5.0
+    monitor._stream_rtt[stream] = rtt_series
+    table.refresh()
+    assert [table.columnWidth(c) for c in ViewersTable._METRIC_COLUMNS] == widths
+    monitor._stream_send_bps[stream] = 250.0 * 1024 * 1024
+    rtt_series.add(1234.5)
+    table.refresh()
+    assert [table.columnWidth(c) for c in ViewersTable._METRIC_COLUMNS] == widths
+    send_item = table.item(0, 5)
+    assert send_item is not None and send_item.text() == "250.0 MB/s"
+
+
 def test_refused_approval_denies_client(qapp, credentials, tmp_path, monkeypatch):
     stub_approval_prompt(monkeypatch, QMessageBox.StandardButton.No)
     window = make_window(credentials, tmp_path)