remotedesktop 0.9.0__tar.gz → 0.11.0__tar.gz

{remotedesktop-0.9.0 → remotedesktop-0.11.0}/CLAUDE.md

@@ -47,6 +47,8 @@ Managed with `uv` (hatchling build backend, src layout):
 - **Revoking access**: `InventoryTab` takes an optional `(action_label, action_callback)`; the callback gets the selected peer's key. The server's tab wires "Revoke access" → `ShareServer.revoke_client(client_id)` (removes the token via `PairedClients.revoke`, disconnects any live stream with a `denied: access revoked`, and `_drop` reports state "revoked"; a `_revoked` set distinguishes it from a plain disconnect). The client's tab wires "Forget server" → `KnownServers.forget(key)` + disconnect. After either, the next connection needs a fresh approval. Server and client each use a *separate table* (`server_peers` / `client_peers`, selected via the `table=` arg) so a machine running both apps doesn't commingle them; `peers` is the default table used by tests. `ConnectionInventory` never lets a DB error break connectivity (load/save are wrapped).
 - Sharing tests drive real sockets on the GUI thread by pumping `qapp.processEvents()` until a condition holds (see `pump()` in `tests/test_sharing.py`). Use the `make_server`/`make_client` helpers there and the session-scoped `credentials` fixture (one generated cert reused across tests — generating per test is ~100ms each). Tests exercise the real pairing flow (auto-approve), so there is no "pre-approve" shortcut anymore.
 - **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.
+- **Modal-loop pump** (`modal_loop.py`): a Windows title-bar drag (or click-and-hold) puts the window's thread into a native modal move/size loop where Qt's dispatcher stops — for the server this deadlocked when a *remote* click grabbed the server window's own title bar (the mouse-up sat unread on the socket). `ServerWindow.nativeEvent` feeds `ModalLoopPump`, which runs a native `SetTimer` between `WM_ENTERSIZEMOVE`/`WM_EXITSIZEMOVE` whose callback pumps Qt events (user input excluded). Tests inject a fake `timers` backend — never let them create real Win32 timers.
+- **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).

{remotedesktop-0.9.0 → remotedesktop-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.9.0
+Version: 0.11.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.9.0 → remotedesktop-0.11.0}/src/remotedesktop/__init__.py

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

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

@@ -24,6 +24,7 @@ from PySide6.QtWidgets import (
 )
 
 from remotedesktop import db, icon, logs, window_state
+from remotedesktop.logs import PeerLogDialog, read_log_tail
 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
@@ -120,7 +121,14 @@ class ClientWindow(QMainWindow):
         self.connection_log = QPlainTextEdit(self)
         self.connection_log.setReadOnly(True)
         self.connection_log.setMaximumBlockCount(1000)
-        tabs.addTab(self.connection_log, "Connection log")
+        self.get_log_button = QPushButton("Get server log")
+        self.get_log_button.setToolTip("Ask the connected server to send its debug log")
+        self.get_log_button.clicked.connect(self._request_server_log)
+        log_tab = QWidget()
+        log_layout = QVBoxLayout(log_tab)
+        log_layout.addWidget(self.get_log_button, alignment=Qt.AlignmentFlag.AlignLeft)
+        log_layout.addWidget(self.connection_log)
+        tabs.addTab(log_tab, "Connection log")
         tabs.addTab(PreferencesTab(self._settings, self.performance), "Preferences")
 
         self.discovery_panel.serverActivated.connect(self._on_server_activated)
@@ -195,6 +203,7 @@ class ClientWindow(QMainWindow):
             known_servers=self._known_servers,
             clipboard=self._clipboard,
             performance=self.performance,
+            log_provider=lambda: read_log_tail("client"),
             parent=self,
         )
         self._client = client
@@ -204,6 +213,7 @@ class ClientWindow(QMainWindow):
         client.denied.connect(self._on_denied)
         client.disconnected.connect(self._on_disconnected)
         client.frameReceived.connect(self._on_frame)
+        client.logReceived.connect(self._show_server_log)
         self.viewer.clear(f"Connecting to {server.name} …")
         self.statusBar().showMessage(f"Connecting to {server.name} ({server.host}:{server.port}) …")
         client.connect_to(server.host, server.port)
@@ -248,6 +258,20 @@ class ClientWindow(QMainWindow):
             self.viewer.clear("Disconnected")
             self.statusBar().showMessage(f"Disconnected from {self._server_name}")
 
+    def _request_server_log(self) -> None:
+        if self._client is None:
+            self.log("Not connected — no server to request a log from")
+            return
+        self._client.request_log()
+
+    def _show_server_log(self, text: str) -> None:
+        title = (
+            f'Log from server "{self._server_name}"'
+            if self._server_name
+            else "Log from server"
+        )
+        PeerLogDialog(title, text, self).show()
+
     def _on_frame(self, image) -> None:
         self._frame_count += 1
         self.viewer.show_frame(image)

remotedesktop-0.11.0/src/remotedesktop/logs.py

@@ -0,0 +1,94 @@
+"""Persistent debug logging for the client and server apps.
+
+The GUI "Connection log" panes only live as long as their window, which makes
+an intermittent connection problem impossible to diagnose after the fact.
+`init_logging` attaches a rotating file handler to the "remotedesktop" logger
+so everything the panes show — plus lower-level socket and protocol detail
+that is logged directly — survives on disk with millisecond timestamps.
+
+Only the app entry points call `init_logging`; library code and tests just
+log to `logging.getLogger("remotedesktop...")`, which is a no-op without a
+handler.
+"""
+
+import logging
+import logging.handlers
+from pathlib import Path
+
+import platformdirs
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QDialog, QPlainTextEdit, QVBoxLayout, QWidget
+
+# Cap on what a peer gets when it asks for our log: the most recent entries
+# are what matter, and the reply must stay a comfortable single message.
+TAIL_BYTES = 1_000_000
+
+
+def default_log_dir() -> Path:
+    return Path(platformdirs.user_log_dir("remotedesktop", appauthor=False))
+
+
+def log_path(app_name: str, *, directory: Path | None = None) -> Path:
+    log_dir = directory if directory is not None else default_log_dir()
+    return log_dir / f"{app_name}.log"
+
+
+def read_log_tail(
+    app_name: str, *, directory: Path | None = None, max_bytes: int = TAIL_BYTES
+) -> str:
+    """The last `max_bytes` of the app's debug log, for sending to a peer.
+
+    Log exchange is a diagnostic aid and must never break a connection, so a
+    missing or unreadable log yields a placeholder line instead of raising.
+    """
+    path = log_path(app_name, directory=directory)
+    try:
+        with path.open("rb") as file:
+            size = file.seek(0, 2)
+            file.seek(max(0, size - max_bytes))
+            data = file.read(max_bytes)
+    except OSError:
+        return f"(no log available: {path} cannot be read)"
+    return data.decode("utf-8", errors="replace")
+
+
+class PeerLogDialog(QDialog):
+    """Non-modal, read-only viewer for a log received from the peer."""
+
+    def __init__(self, title: str, text: str, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.setWindowTitle(title)
+        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        self.resize(900, 600)
+        view = QPlainTextEdit(self)
+        view.setReadOnly(True)
+        view.setLineWrapMode(QPlainTextEdit.LineWrapMode.NoWrap)
+        view.setPlainText(text)
+        # The most recent entries matter most: start scrolled to the end.
+        view.verticalScrollBar().setValue(view.verticalScrollBar().maximum())
+        layout = QVBoxLayout(self)
+        layout.addWidget(view)
+
+
+def init_logging(app_name: str, *, directory: Path | None = None) -> Path:
+    """Write "remotedesktop" logger output to <log dir>/<app_name>.log.
+
+    Returns the log file path. `directory` exists for tests; the apps use
+    the platformdirs log dir.
+    """
+    log_dir = directory if directory is not None else default_log_dir()
+    log_dir.mkdir(parents=True, exist_ok=True)
+    path = log_path(app_name, directory=directory)
+    handler = logging.handlers.RotatingFileHandler(
+        path, maxBytes=2_000_000, backupCount=3, encoding="utf-8"
+    )
+    handler.setFormatter(
+        logging.Formatter(
+            "%(asctime)s.%(msecs)03d %(levelname)-7s %(name)s  %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+    )
+    logger = logging.getLogger("remotedesktop")
+    logger.addHandler(handler)
+    logger.setLevel(logging.DEBUG)
+    return path

remotedesktop-0.11.0/src/remotedesktop/modal_loop.py

@@ -0,0 +1,103 @@
+"""Keep the Qt event loop serviced during Windows' modal move/size loop.
+
+Dragging (or click-and-holding) a window's title bar puts that window's
+thread into a native modal loop; Qt's event dispatcher stops running, so
+timers, socket reads — and therefore remote-input processing — all stall.
+For the share server that was a deadlock: an injected remote mouse-down on
+the server window's own title bar enters the loop, and the mouse-up that
+would end it sits unread on a socket the frozen event loop never services,
+until someone at the server machine intervenes.
+
+Native WM_TIMER callbacks *are* dispatched inside modal loops, so between
+WM_ENTERSIZEMOVE and WM_EXITSIZEMOVE a SetTimer callback pumps Qt events
+(user input excluded) every few milliseconds. A side benefit: screen
+sharing keeps streaming while the local user drags the server window.
+
+Feed every message from the window's `nativeEvent` to
+`handle_native_event`; the pump is inert off Windows. Tests inject a fake
+`timers` backend so no native timer is ever created.
+"""
+
+import ctypes
+import logging
+import sys
+from collections.abc import Callable
+from ctypes import wintypes
+
+from PySide6.QtCore import QCoreApplication, QEventLoop
+
+_log = logging.getLogger("remotedesktop.modal_loop")
+
+WM_ENTERSIZEMOVE = 0x0231
+WM_EXITSIZEMOVE = 0x0232
+_TIMER_ID = 0x5244  # arbitrary but stable; scoped to the window's hwnd
+_TIMER_INTERVAL_MS = 15  # comfortably under the 33 ms capture tick
+
+
+def _pump_qt() -> None:
+    # Excluding user input keeps re-entrant clicks and keys out of our own
+    # widgets while the native modal loop owns the mouse.
+    QCoreApplication.processEvents(QEventLoop.ProcessEventsFlag.ExcludeUserInputEvents)
+
+
+class _NativeTimers:
+    """SetTimer/KillTimer with a TIMERPROC, which the modal loop dispatches."""
+
+    def __init__(self, callback: Callable[[], None]) -> None:
+        self._user32 = ctypes.windll.user32
+        # The WINFUNCTYPE wrapper must stay referenced for the timer's lifetime.
+        self._proc = ctypes.WINFUNCTYPE(
+            None, wintypes.HWND, wintypes.UINT, ctypes.c_size_t, wintypes.DWORD
+        )(lambda _hwnd, _msg, _timer_id, _tick: callback())
+
+    def start(self, hwnd: int) -> None:
+        self._user32.SetTimer(hwnd, _TIMER_ID, _TIMER_INTERVAL_MS, self._proc)
+
+    def stop(self, hwnd: int) -> None:
+        self._user32.KillTimer(hwnd, _TIMER_ID)
+
+
+class ModalLoopPump:
+    """Runs a native timer that pumps Qt events while a window of ours sits
+    in the modal move/size loop."""
+
+    def __init__(self, *, pump: Callable[[], None] | None = None, timers=None) -> None:
+        self._pump = pump if pump is not None else _pump_qt
+        if timers is None and sys.platform == "win32":
+            timers = _NativeTimers(self._on_timer)
+        self._timers = timers  # None: inert (non-Windows)
+        self._hwnd: int | None = None
+        self._pumping = False
+
+    def handle_native_event(self, event_type, message) -> None:
+        """Call from QWidget.nativeEvent with its arguments verbatim."""
+        if self._timers is None or bytes(event_type) != b"windows_generic_MSG":
+            return
+        msg = wintypes.MSG.from_address(int(message))
+        if msg.message == WM_ENTERSIZEMOVE:
+            self._enter(msg.hWnd or 0)
+        elif msg.message == WM_EXITSIZEMOVE:
+            self._exit()
+
+    def _enter(self, hwnd: int) -> None:
+        if self._hwnd is not None:  # unbalanced enter: replace the old timer
+            self._timers.stop(self._hwnd)
+        self._hwnd = hwnd
+        self._timers.start(hwnd)
+        _log.debug("Modal move/size loop entered — pumping Qt from a native timer")
+
+    def _exit(self) -> None:
+        if self._hwnd is None:
+            return
+        self._timers.stop(self._hwnd)
+        self._hwnd = None
+        _log.debug("Modal move/size loop exited")
+
+    def _on_timer(self) -> None:
+        if self._pumping:  # processEvents can dispatch this timer re-entrantly
+            return
+        self._pumping = True
+        try:
+            self._pump()
+        finally:
+            self._pumping = False

{remotedesktop-0.9.0 → remotedesktop-0.11.0}/src/remotedesktop/performance.py

@@ -8,6 +8,15 @@ 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.
 
+The same machinery doubles as dead-connection detection: once the active
+stream's peer has proven it answers pings, a peer that then goes completely
+silent (no bytes received at all) for `dead_after_seconds` is presumed gone
+and `connectionLost` is emitted, once. A half-open TCP connection is otherwise
+invisible here — an unchanged screen legitimately sends nothing, so a frozen
+last frame looks exactly like a live static desktop. Peers that never answered
+a ping (pre-feature versions) never arm the detector, so they are never
+falsely reported.
+
 Wire messages (JSON, admitted streams only):
     {"type": "ping", "id": <int>, "rtt": <ms, omitted before first measurement>}
     {"type": "pong", "id": <int>}   # pure echo
@@ -21,13 +30,14 @@ All timing uses time.monotonic(), injectable as `clock=` for tests.
 
 import itertools
 import logging
+import math
 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.QtGui import QColor, QPainter, QPaintEvent, QPen, QPolygonF, QShowEvent
 from PySide6.QtWidgets import QVBoxLayout, QWidget
 
 _log = logging.getLogger("remotedesktop.performance")
@@ -46,8 +56,10 @@ class StreamLike(Protocol):
 
 DEFAULT_WINDOW_SECONDS = 120.0
 DEFAULT_INTERVAL_MS = 1000
+DEFAULT_DEAD_AFTER_SECONDS = 10.0
 _PING_PRUNE_SECONDS = 30.0
 _HEARTBEAT_TICKS = 10  # one debug-log line per this many samples
+_GRID_DIVISIONS = 4  # grid cells per axis, i.e. 5 ticks including both ends
 
 
 class MetricSeries:
@@ -93,18 +105,21 @@ class PerformanceMonitor(QObject):
     """
 
     updated = Signal()  # one emit per sample tick
+    connectionLost = Signal(object)  # the active stream whose responsive peer went silent
 
     def __init__(
         self,
         *,
         window_seconds: float = DEFAULT_WINDOW_SECONDS,
         interval_ms: int = DEFAULT_INTERVAL_MS,
+        dead_after_seconds: float = DEFAULT_DEAD_AFTER_SECONDS,
         clock: Callable[[], float] = time.monotonic,
         parent: QObject | None = None,
     ) -> None:
         super().__init__(parent)
         self._clock = clock
         self._window = window_seconds
+        self._dead_after = dead_after_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)
@@ -112,6 +127,12 @@ class PerformanceMonitor(QObject):
         self._streams: list[StreamLike] = []
         self._baselines: dict[StreamLike, tuple[int, int]] = {}
         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
+        # ping (arms the detector), and whether a loss was already reported.
+        self._last_data: float | None = None
+        self._peer_responsive = False
+        self._lost_reported = False
         self._pending: dict[int, float] = {}
         self._ids = itertools.count(1)
         self._last_tick: float | None = None
@@ -124,6 +145,10 @@ class PerformanceMonitor(QObject):
     def window_seconds(self) -> float:
         return self._window
 
+    @property
+    def dead_after_seconds(self) -> float:
+        return self._dead_after
+
     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):
@@ -133,7 +158,7 @@ class PerformanceMonitor(QObject):
         if stream not in self._baselines:
             self._streams.append(stream)
         self._baselines[stream] = (stream.bytes_sent, stream.bytes_received)
-        self._active = stream
+        self._activate(stream)
         if not self._timer.isActive():
             self._last_tick = None
             self._timer.start()
@@ -144,12 +169,18 @@ class PerformanceMonitor(QObject):
         self._streams.remove(stream)
         del self._baselines[stream]
         if self._active is stream:
-            self._active = self._streams[-1] if self._streams else None
+            self._activate(self._streams[-1] if self._streams else None)
         if not self._streams:
             self._timer.stop()
             self._pending.clear()
             self._last_tick = None
 
+    def _activate(self, stream: StreamLike | None) -> None:
+        self._active = stream
+        self._last_data = self._clock() if stream is not None else None
+        self._peer_responsive = False
+        self._lost_reported = False
+
     def reset(self) -> None:
         """Detach everything and clear the graphs (new connection attempt)."""
         for stream in list(self._streams):
@@ -162,9 +193,15 @@ class PerformanceMonitor(QObject):
             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))
+                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.
+                    self._peer_responsive = True
+                    if isinstance(rtt, (int, float)):
+                        self.peer_rtt_ms.add(float(rtt))
             case "pong":
+                if stream is self._active:
+                    self._peer_responsive = True
                 ping_id = message.get("id")
                 if isinstance(ping_id, int):
                     sent = self._pending.pop(ping_id, None)
@@ -178,6 +215,8 @@ class PerformanceMonitor(QObject):
             base_sent, base_received = self._baselines[stream]
             delta_sent += stream.bytes_sent - base_sent
             delta_received += stream.bytes_received - base_received
+            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:
             self.send_bps.add(delta_sent / elapsed)
@@ -194,6 +233,20 @@ class PerformanceMonitor(QObject):
                 ping["rtt"] = rtt
             self._active.send_json(ping)
 
+            if (
+                self._peer_responsive
+                and not self._lost_reported
+                and self._last_data is not None
+                and now - self._last_data > self._dead_after
+            ):
+                self._lost_reported = True
+                _log.warning(
+                    "No data from the peer for %.0f s (pings unanswered) — "
+                    "connection presumed lost",
+                    now - self._last_data,
+                )
+                self.connectionLost.emit(self._active)
+
         self._tick_count += 1
         if self._tick_count % _HEARTBEAT_TICKS == 0:
             _log.debug(
@@ -219,6 +272,30 @@ def format_ms(ms: float) -> str:
     return f"{ms:.1f} ms"
 
 
+def rate_unit(bytes_per_second: float) -> float:
+    """The divisor format_rate will display this value in (B/KB/MB per s),
+    so axis ticks can be computed in the displayed unit and land on round
+    numbers there."""
+    if bytes_per_second >= 1024 * 1024:
+        return 1024.0 * 1024.0
+    if bytes_per_second >= 1024:
+        return 1024.0
+    return 1.0
+
+
+def nice_ceiling(value: float) -> float:
+    """Smallest 1/2/5 x 10^k that is >= value, so axis ticks land on round
+    numbers instead of the raw data maximum."""
+    if value <= 0:
+        return 1.0
+    exponent = math.floor(math.log10(value))
+    for multiplier in (1.0, 2.0, 5.0, 10.0):
+        candidate = multiplier * 10.0**exponent
+        if candidate >= value:
+            return candidate
+    raise AssertionError("unreachable: 10 * 10**floor(log10(v)) >= v")
+
+
 class GraphWidget(QWidget):
     """A rolling line graph over the monitor's window, painted with QPainter.
 
@@ -233,6 +310,7 @@ class GraphWidget(QWidget):
         monitor: PerformanceMonitor,
         format_value: Callable[[float], str],
         *,
+        tick_unit: Callable[[float], float] = lambda _value: 1.0,
         clock: Callable[[], float] = time.monotonic,
         parent: QWidget | None = None,
     ) -> None:
@@ -241,8 +319,12 @@ class GraphWidget(QWidget):
         self._series = series
         self._monitor = monitor
         self._format_value = format_value
+        # Maps the data maximum to the unit format_value displays it in, so
+        # 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
         self._clock = clock
-        self.setMinimumSize(300, 120)
+        self.setMinimumSize(300, 140)  # room for the axis-label rows
 
     def paintEvent(self, event: QPaintEvent) -> None:
         painter = QPainter(self)
@@ -262,12 +344,52 @@ class GraphWidget(QWidget):
                 self.rect(), Qt.AlignmentFlag.AlignCenter, "no data"
             )
             return
-        y_max = max(
+        raw_max = max(
             (value for _l, _c, samples in data for _t, value in samples), default=1.0
         )
-        y_max = max(y_max, 1.0)
+        unit = self._tick_unit(raw_max)
+        y_max = unit * nice_ceiling(raw_max / unit)
+
+        # Y tick labels (with units, via the formatter) size the left margin;
+        # the bottom leaves a row for X tick labels and one for the legend.
+        metrics = painter.fontMetrics()
+        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))
+
+        grid_color = palette.color(palette.ColorRole.Mid)
+        grid_pen = QPen(grid_color, 0, Qt.PenStyle.DotLine)
+        text_color = palette.color(palette.ColorRole.Text)
+        for value, label in zip(y_ticks, y_labels):
+            y = graph.bottom() - graph.height() * (value / y_max)
+            painter.setPen(grid_pen)
+            painter.drawLine(graph.left(), round(y), graph.right(), round(y))
+            painter.setPen(text_color)
+            painter.drawText(
+                graph.left() - 6 - metrics.horizontalAdvance(label),
+                round(y) + metrics.ascent() // 2 - 1,
+                label,
+            )
+        x_label_baseline = graph.bottom() + metrics.ascent() + 4
+        for i in range(_GRID_DIVISIONS + 1):
+            seconds_ago = window * (1 - i / _GRID_DIVISIONS)
+            x = graph.left() + graph.width() * i / _GRID_DIVISIONS
+            painter.setPen(grid_pen)
+            painter.drawLine(round(x), graph.top(), round(x), graph.bottom())
+            label = f"{seconds_ago:g}"
+            width = metrics.horizontalAdvance(label)
+            # Center on the tick, but keep the edge labels inside the graph.
+            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)
+        caption = "seconds ago"
+        painter.drawText(
+            self.rect().right() - 8 - metrics.horizontalAdvance(caption),
+            self.rect().bottom() - 6,
+            caption,
+        )
 
-        graph = self.rect().adjusted(8, 24, -8, -20)
         for label, color, samples in data:
             if not samples:
                 continue
@@ -285,14 +407,8 @@ class GraphWidget(QWidget):
             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),
-        )
+            painter.drawText(round(x), self.rect().bottom() - 6, text)
+            x += metrics.horizontalAdvance(text) + 16
 
 
 class PerformanceTab(QWidget):
@@ -313,6 +429,7 @@ class PerformanceTab(QWidget):
             ],
             monitor,
             format_rate,
+            tick_unit=rate_unit,
         )
         self.ping_graph = GraphWidget(
             "Round-trip time",

{remotedesktop-0.9.0 → remotedesktop-0.11.0}/src/remotedesktop/server.py

@@ -32,6 +32,8 @@ from remotedesktop.discovery import (
     DiscoveryResponder,
 )
 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.preferences import PreferencesTab, load_performance_window_seconds
 from remotedesktop.sharing import ShareServer
@@ -64,6 +66,20 @@ class ServerWindow(QMainWindow):
         self.connection_log = QPlainTextEdit()
         self.connection_log.setReadOnly(True)
         self.connection_log.setMaximumBlockCount(1000)
+        self.get_log_button = QPushButton("Get client log")
+        self.get_log_button.setToolTip(
+            "Ask the most recently connected client to send its debug log"
+        )
+        self.get_log_button.clicked.connect(self._request_client_log)
+        log_tab = QWidget()
+        log_layout = QVBoxLayout(log_tab)
+        log_layout.addWidget(self.get_log_button, alignment=Qt.AlignmentFlag.AlignLeft)
+        log_layout.addWidget(self.connection_log)
+        # While this window sits in Windows' modal move/size loop (title-bar
+        # drag — including one driven by an injected remote click), Qt stops
+        # running; the pump keeps sockets and timers serviced so a remote
+        # mouse-up can still arrive and end the drag instead of deadlocking.
+        self._modal_pump = ModalLoopPump()
         self.restart_button = QPushButton("Restart server")
         self.restart_button.setToolTip(
             "Relaunch this app (e.g. after updating the software). It can be "
@@ -93,7 +109,7 @@ class ServerWindow(QMainWindow):
             "Clients on LAN",
         )
         tabs.addTab(PerformanceTab(self.performance), "Performance")
-        tabs.addTab(self.connection_log, "Connection log")
+        tabs.addTab(log_tab, "Connection log")
         tabs.addTab(PreferencesTab(self._settings, self.performance), "Preferences")
         self.setCentralWidget(tabs)
 
@@ -111,11 +127,13 @@ class ServerWindow(QMainWindow):
             paired=paired,
             clipboard=self._clipboard,
             performance=self.performance,
+            log_provider=lambda: read_log_tail("server"),
             parent=self,
         )
         self.share_server.status.connect(self.log)
         self.share_server.clientCountChanged.connect(self._update_summary)
         self.share_server.peerEvent.connect(self._record_peer)
+        self.share_server.logReceived.connect(self._show_client_log)
         self._listening = self.share_server.listen(connect_port)
 
         self.responder: DiscoveryResponder | None = None
@@ -220,6 +238,17 @@ class ServerWindow(QMainWindow):
         self.close()
         QApplication.quit()
 
+    def _request_client_log(self) -> None:
+        self.share_server.request_log()
+
+    def _show_client_log(self, client_name: str, text: str) -> None:
+        title = f'Log from client "{client_name}"' if client_name else "Log from client"
+        PeerLogDialog(title, text, self).show()
+
+    def nativeEvent(self, event_type, message):
+        self._modal_pump.handle_native_event(event_type, message)
+        return super().nativeEvent(event_type, message)
+
     def _ask_approval(self, client_id: str, client_name: str) -> bool:
         box = QMessageBox(
             QMessageBox.Icon.Question,