remotedesktop 0.8.0__tar.gz → 0.10.0__tar.gz

{remotedesktop-0.8.0 → remotedesktop-0.10.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.8.0 → remotedesktop-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.8.0
+Version: 0.10.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.8.0 → remotedesktop-0.10.0}/src/remotedesktop/__init__.py

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

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

@@ -23,7 +23,8 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
-from remotedesktop import db, logs, window_state
+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
@@ -93,6 +94,7 @@ 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)
@@ -119,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)
@@ -194,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
@@ -203,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)
@@ -247,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)
@@ -264,7 +289,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.10.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.10.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.10.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.8.0 → remotedesktop-0.10.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
@@ -46,6 +55,7 @@ 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
 
@@ -93,18 +103,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 +125,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 +143,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 +156,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 +167,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 +191,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 +213,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 +231,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(

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

@@ -22,7 +22,7 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
-from remotedesktop import db, logs, tls, window_state
+from remotedesktop import db, icon, logs, tls, window_state
 from remotedesktop.autostart import Autostart
 from remotedesktop.clipboard import ClipboardSync
 from remotedesktop.config import PairedClients, Settings, default_config_dir, default_db_path
@@ -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
@@ -52,6 +54,7 @@ class ServerWindow(QMainWindow):
     ) -> None:
         super().__init__()
         self.setWindowTitle("Remote Desktop Server")
+        self.setWindowIcon(icon.app_icon("server"))
         self._name = socket.gethostname()
 
         self._summary = QLabel(alignment=Qt.AlignmentFlag.AlignCenter)
@@ -63,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 "
@@ -92,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)
 
@@ -110,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
@@ -219,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,
@@ -246,7 +276,9 @@ class ServerWindow(QMainWindow):
 
 def main() -> None:  # pragma: no cover - runs the Qt event loop
     log_path = logs.init_logging("server")
+    icon.set_windows_app_id("remotedesktop.server")
     app = QApplication(sys.argv)
+    app.setWindowIcon(icon.app_icon("server"))
     window = ServerWindow()
     window.log(f"Detailed log: {log_path}")
     window.show()