remotedesktop 0.9.0__tar.gz → 0.10.0__tar.gz

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

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

{remotedesktop-0.9.0 → remotedesktop-0.10.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.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.9.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.9.0 → remotedesktop-0.10.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,

{remotedesktop-0.9.0 → remotedesktop-0.10.0}/src/remotedesktop/sharing.py

@@ -78,6 +78,7 @@ class ShareServer(QObject):
     clientCountChanged = Signal(int)
     status = Signal(str)
     peerEvent = Signal(dict)  # {key, event, name, address, detail} for the inventory
+    logReceived = Signal(str, str)  # (client name, log text) answering request_log
 
     def __init__(
         self,
@@ -89,10 +90,12 @@ class ShareServer(QObject):
         injector: InputInjector | None = None,
         clipboard=None,
         performance: PerformanceMonitor | None = None,
+        log_provider: Callable[[], str] | None = None,
         parent: QObject | None = None,
     ) -> None:
         super().__init__(parent)
         self._performance = performance
+        self._log_provider = log_provider
         self._approve_client = approve_client
         self._paired = paired if paired is not None else PairedClients(db.connect(default_db_path()))
         self._fps = fps
@@ -217,6 +220,21 @@ class ShareServer(QObject):
                 self.status.emit(f"Clipboard update received from {_peer(stream.socket)}")
                 self._clipboard.apply(message)
             return
+        if message.get("type") == "log_request":
+            # Same admission rule as input/clipboard: pre-auth peers get nothing.
+            if stream in self._streams:
+                self._send_log(stream)
+            return
+        if message.get("type") == "log":
+            if stream in self._streams:
+                text = str(message.get("text", ""))
+                name = self._stream_key.get(stream, ("", "", ""))[1]
+                self.status.emit(
+                    f'Received log from "{name or _peer(stream.socket)}" '
+                    f"({len(text) // 1024} KB)"
+                )
+                self.logReceived.emit(name, text)
+            return
         if message.get("type") == "keyframe":
             # The client lost sync with the delta stream (e.g. a band failed
             # to decode) and wants a full frame to rebuild its canvas.
@@ -407,6 +425,27 @@ class ShareServer(QObject):
         for stream in self._streams:
             stream.send_json(message)
 
+    def request_log(self) -> None:
+        """Ask the most recently admitted client to send its debug log
+        (delivered via `logReceived`)."""
+        if not self._streams:
+            self.status.emit("No connected client to request a log from")
+            return
+        stream = self._streams[-1]
+        self.status.emit(f"Requesting the log of the client at {_peer(stream.socket)}")
+        stream.send_json({"type": "log_request"})
+
+    def _send_log(self, stream: MessageStream) -> None:
+        text = (
+            self._log_provider()
+            if self._log_provider is not None
+            else "(no log available on the server)"
+        )
+        self.status.emit(
+            f"Log requested by {_peer(stream.socket)} — sending {len(text) // 1024} KB"
+        )
+        stream.send_json({"type": "log", "text": text})
+
     def _drop(self, stream: MessageStream) -> None:
         # Detach from the monitor before the deferred delete below, so it
         # never samples a deleted stream (idempotent for never-admitted ones).
@@ -520,6 +559,7 @@ class ShareClient(QObject):
     disconnected = Signal()
     frameReceived = Signal(QImage)
     status = Signal(str)
+    logReceived = Signal(str)  # server log text answering request_log
 
     def __init__(
         self,
@@ -528,10 +568,14 @@ class ShareClient(QObject):
         known_servers: KnownServers | None = None,
         clipboard=None,
         performance: PerformanceMonitor | None = None,
+        log_provider: Callable[[], str] | None = None,
         parent: QObject | None = None,
     ) -> None:
         super().__init__(parent)
         self._performance = performance
+        self._log_provider = log_provider
+        if performance is not None:
+            performance.connectionLost.connect(self._on_connection_lost)
         self._client_id, self._name = identity or load_client_identity(
             db.connect(default_db_path())
         )
@@ -587,6 +631,15 @@ class ShareClient(QObject):
             self.status.emit("Sending local clipboard to server")
             self._stream.send_json({"type": "clipboard", **payload})
 
+    def request_log(self) -> None:
+        """Ask the connected server to send its debug log (delivered via
+        `logReceived`)."""
+        if self._socket.state() != QSslSocket.SocketState.ConnectedState:
+            self.status.emit("Not connected — cannot request the server's log")
+            return
+        self.status.emit("Requesting the server's log")
+        self._stream.send_json({"type": "log_request"})
+
     def _on_ssl_errors(self, errors) -> None:
         # Self-signed server certificate is expected; identity is pinned instead.
         self.status.emit(
@@ -620,6 +673,22 @@ class ShareClient(QObject):
             hello["token"] = self._server_token
         self._stream.send_json(hello)
 
+    def _on_connection_lost(self, stream) -> None:
+        # The window shares one monitor across successive ShareClient
+        # instances, so only the owner of the silent stream may react. (The
+        # None check is for the type checker: the signal is only connected
+        # when a monitor exists.)
+        if stream is not self._stream or self._performance is None:
+            return
+        self.status.emit(
+            "Connection lost: no data from the server for "
+            f"{self._performance.dead_after_seconds:.0f} s — disconnecting"
+        )
+        # A half-open socket never emits disconnected on its own; abort() is
+        # silent too, so run the disconnect path explicitly.
+        self._socket.abort()
+        self._on_disconnected()
+
     def _on_disconnected(self) -> None:
         if self._performance is not None:
             self._performance.remove_stream(self._stream)
@@ -670,6 +739,20 @@ class ShareClient(QObject):
             case "ping" | "pong":
                 if self._performance is not None:
                     self._performance.handle_message(self._stream, message)
+            case "log_request":
+                text = (
+                    self._log_provider()
+                    if self._log_provider is not None
+                    else "(no log available on the client)"
+                )
+                self.status.emit(
+                    f"Server requested this client's log — sending {len(text) // 1024} KB"
+                )
+                self._stream.send_json({"type": "log", "text": text})
+            case "log":
+                text = str(message.get("text", ""))
+                self.status.emit(f"Received the server's log ({len(text) // 1024} KB)")
+                self.logReceived.emit(text)
 
     def _on_frame(self, data: bytes) -> None:
         # Full frame — PNG keyframe or (legacy servers) JPEG; sniffed from

{remotedesktop-0.9.0 → remotedesktop-0.10.0}/tests/test_client_window.py

@@ -26,6 +26,29 @@ def make_share_server(credentials, tmp_path, *, approve=lambda *_: True):
     return server
 
 
+def test_get_server_log_button_needs_a_connection(qapp, tmp_path):
+    window = make_window(tmp_path)
+    try:
+        window.get_log_button.click()
+        assert "no server to request a log from" in window.connection_log.toPlainText()
+    finally:
+        window.close()
+
+
+def test_received_server_log_opens_a_viewer_dialog(qapp, tmp_path):
+    from remotedesktop.logs import PeerLogDialog
+
+    window = make_window(tmp_path)
+    try:
+        window._show_server_log("some log text")
+        dialog = window.findChild(PeerLogDialog)
+        assert dialog is not None
+        assert "Log from server" in dialog.windowTitle()
+        dialog.close()
+    finally:
+        window.close()
+
+
 def test_window_starts_disconnected(qapp, tmp_path):
     window = make_window(tmp_path)
     assert window.statusBar().currentMessage() == "Not connected"

{remotedesktop-0.9.0 → remotedesktop-0.10.0}/tests/test_logs.py

@@ -21,3 +21,21 @@ def test_init_logging_writes_formatted_records(tmp_path):
         for handler in list(root.handlers):
             root.removeHandler(handler)
             handler.close()
+
+
+def test_read_log_tail_returns_recent_content(tmp_path):
+    (tmp_path / "server.log").write_text("early line\nrecent line\n", encoding="utf-8")
+    text = logs.read_log_tail("server", directory=tmp_path)
+    assert "early line" in text and "recent line" in text
+
+
+def test_read_log_tail_keeps_only_the_end_of_a_big_log(tmp_path):
+    (tmp_path / "client.log").write_bytes(b"OLD" * 1000 + b"NEWEST")
+    text = logs.read_log_tail("client", directory=tmp_path, max_bytes=100)
+    assert len(text) == 100
+    assert text.endswith("NEWEST")
+
+
+def test_read_log_tail_without_a_log_file_reports_instead_of_failing(tmp_path):
+    text = logs.read_log_tail("server", directory=tmp_path)
+    assert "no log available" in text

remotedesktop-0.10.0/tests/test_modal_loop.py

@@ -0,0 +1,68 @@
+"""The pump must start its native timer exactly for the span of the modal
+move/size loop, and its timer callback must never re-enter the Qt pump.
+
+All tests inject a fake timer backend, so no real Win32 timer is created.
+"""
+
+import ctypes
+from ctypes import wintypes
+
+from remotedesktop.modal_loop import WM_ENTERSIZEMOVE, WM_EXITSIZEMOVE, ModalLoopPump
+
+
+class FakeTimers:
+    def __init__(self):
+        self.calls = []
+
+    def start(self, hwnd):
+        self.calls.append(("start", hwnd))
+
+    def stop(self, hwnd):
+        self.calls.append(("stop", hwnd))
+
+
+def native_message(message_id, hwnd=0xBEEF):
+    """A wintypes.MSG whose address stands in for Qt's nativeEvent pointer."""
+    msg = wintypes.MSG()
+    msg.hWnd = hwnd
+    msg.message = message_id
+    return msg
+
+
+def test_enter_and_exit_bound_the_timer():
+    timers = FakeTimers()
+    pump = ModalLoopPump(pump=lambda: None, timers=timers)
+    enter, exit_ = native_message(WM_ENTERSIZEMOVE), native_message(WM_EXITSIZEMOVE)
+    pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(enter))
+    assert timers.calls == [("start", 0xBEEF)]
+    pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(exit_))
+    assert timers.calls == [("start", 0xBEEF), ("stop", 0xBEEF)]
+
+
+def test_exit_without_enter_is_ignored():
+    timers = FakeTimers()
+    pump = ModalLoopPump(pump=lambda: None, timers=timers)
+    exit_ = native_message(WM_EXITSIZEMOVE)
+    pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(exit_))
+    assert timers.calls == []
+
+
+def test_other_messages_and_event_types_are_ignored():
+    timers = FakeTimers()
+    pump = ModalLoopPump(pump=lambda: None, timers=timers)
+    other = native_message(0x000F)  # WM_PAINT
+    pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(other))
+    # A non-Windows event type must not even be parsed as a MSG pointer.
+    pump.handle_native_event(b"xcb_generic_event_t", 0)
+    assert timers.calls == []
+
+
+def test_timer_callback_pumps_but_never_reentrantly():
+    pumped = []
+    pump = ModalLoopPump(pump=lambda: pumped.append(True) or pump._on_timer(), timers=FakeTimers())
+    # The pump callable above simulates processEvents dispatching our own
+    # WM_TIMER again mid-pump; the guard must swallow that inner call.
+    pump._on_timer()
+    assert pumped == [True]
+    pump._on_timer()  # guard resets between ticks
+    assert pumped == [True, True]

{remotedesktop-0.9.0 → remotedesktop-0.10.0}/tests/test_performance.py

@@ -216,6 +216,115 @@ def test_old_peer_leaves_rtt_series_empty(qapp, credentials, tmp_path):
         server.close()
 
 
+def arm(monitor: PerformanceMonitor, stream: FakeStream, clock: FakeClock) -> None:
+    """Answer a ping (proving the peer responsive) and tick again so the
+    pong's bytes are observed — the silence deadline starts fresh from here."""
+    monitor._on_tick()
+    stream.bytes_received += 10  # the pong's bytes arriving
+    monitor.handle_message(stream, {"type": "pong", "id": stream.sent[-1]["id"]})
+    clock.advance(1.0)
+    monitor._on_tick()
+
+
+def test_connection_lost_after_responsive_peer_goes_silent(qapp):
+    clock = FakeClock()
+    monitor = PerformanceMonitor(dead_after_seconds=10.0, clock=clock)
+    stream = FakeStream()
+    lost = []
+    monitor.connectionLost.connect(lost.append)
+    monitor.add_stream(stream)
+    arm(monitor, stream, clock)
+    clock.advance(9.0)
+    monitor._on_tick()  # bytes arrived 9 s ago: within the deadline
+    assert lost == []
+    clock.advance(2.0)
+    monitor._on_tick()  # 11 s of silence
+    assert lost == [stream]
+    clock.advance(5.0)
+    monitor._on_tick()  # reported once, not on every subsequent tick
+    assert lost == [stream]
+
+
+def test_incoming_data_defers_connection_lost(qapp):
+    clock = FakeClock()
+    monitor = PerformanceMonitor(dead_after_seconds=10.0, clock=clock)
+    stream = FakeStream()
+    lost = []
+    monitor.connectionLost.connect(lost.append)
+    monitor.add_stream(stream)
+    arm(monitor, stream, clock)
+    for _ in range(4):  # 24 s total, but data keeps arriving every 6 s
+        clock.advance(6.0)
+        stream.bytes_received += 1
+        monitor._on_tick()
+    assert lost == []
+
+
+def test_incoming_ping_also_arms_the_detector(qapp):
+    clock = FakeClock()
+    monitor = PerformanceMonitor(dead_after_seconds=10.0, clock=clock)
+    stream = FakeStream()
+    lost = []
+    monitor.connectionLost.connect(lost.append)
+    monitor.add_stream(stream)
+    monitor.handle_message(stream, {"type": "ping", "id": 1})
+    clock.advance(11.0)
+    monitor._on_tick()
+    assert lost == [stream]
+
+
+def test_silent_legacy_peer_is_never_reported_lost(qapp):
+    # A peer that never answered a ping (pre-0.9 server) must never trip the
+    # detector: its silence on a static screen is indistinguishable from life.
+    clock = FakeClock()
+    monitor = PerformanceMonitor(dead_after_seconds=10.0, clock=clock)
+    stream = FakeStream()
+    lost = []
+    monitor.connectionLost.connect(lost.append)
+    monitor.add_stream(stream)
+    for _ in range(10):
+        clock.advance(60.0)
+        monitor._on_tick()
+    assert lost == []
+
+
+def test_reattaching_a_stream_resets_the_detector(qapp):
+    clock = FakeClock()
+    monitor = PerformanceMonitor(dead_after_seconds=10.0, clock=clock)
+    stream = FakeStream()
+    lost = []
+    monitor.connectionLost.connect(lost.append)
+    monitor.add_stream(stream)
+    arm(monitor, stream, clock)
+    clock.advance(11.0)
+    monitor._on_tick()
+    assert lost == [stream]
+    # A reconnect detaches and reattaches: the new session starts unarmed
+    # with a fresh deadline, so the stale silence is not reported again.
+    monitor.remove_stream(stream)
+    monitor.add_stream(stream)
+    clock.advance(60.0)
+    monitor._on_tick()
+    assert lost == [stream]
+
+
+def test_share_client_drops_the_connection_on_lost_signal(qapp, tmp_path):
+    monitor = PerformanceMonitor()
+    client = ShareClient(
+        identity=IDENTITY,
+        known_servers=KnownServers(db.connect(tmp_path / "client.db")),
+        performance=monitor,
+    )
+    statuses, disconnects = [], []
+    client.status.connect(statuses.append)
+    client.disconnected.connect(lambda: disconnects.append(True))
+    monitor.connectionLost.emit(FakeStream())  # someone else's stream: ignored
+    assert disconnects == []
+    monitor.connectionLost.emit(client._stream)
+    assert disconnects == [True]
+    assert any("Connection lost" in s and "10 s" in s for s in statuses)
+
+
 def test_graph_widgets_render_headless(qapp):
     seeded = PerformanceMonitor()
     seeded.send_bps.add(100.0)

{remotedesktop-0.9.0 → remotedesktop-0.10.0}/tests/test_server_window.py

@@ -28,6 +28,53 @@ def make_window(credentials, tmp_path, *, discovery_port=None, connect_port=0):
     )
 
 
+def test_get_client_log_button_needs_a_client(qapp, credentials, tmp_path):
+    window = make_window(credentials, tmp_path)
+    try:
+        window.get_log_button.click()
+        assert "No connected client" in window.connection_log.toPlainText()
+    finally:
+        window.close()
+
+
+def test_received_client_log_opens_a_viewer_dialog(qapp, credentials, tmp_path):
+    from remotedesktop.logs import PeerLogDialog
+
+    window = make_window(credentials, tmp_path)
+    try:
+        window._show_client_log("laptop", "some log text")
+        dialog = window.findChild(PeerLogDialog)
+        assert dialog is not None
+        assert 'Log from client "laptop"' == dialog.windowTitle()
+        dialog.close()
+    finally:
+        window.close()
+
+
+def test_native_size_move_messages_drive_the_modal_pump(qapp, credentials, tmp_path):
+    import ctypes
+    from ctypes import wintypes
+
+    from shiboken6 import VoidPtr
+
+    from remotedesktop.modal_loop import WM_ENTERSIZEMOVE, WM_EXITSIZEMOVE, ModalLoopPump
+    from test_modal_loop import FakeTimers
+
+    window = make_window(credentials, tmp_path)
+    try:
+        timers = FakeTimers()
+        window._modal_pump = ModalLoopPump(pump=lambda: None, timers=timers)
+        msg = wintypes.MSG()
+        msg.hWnd, msg.message = 0xBEEF, WM_ENTERSIZEMOVE
+        # Qt hands nativeEvent a void*; VoidPtr is that shape from Python.
+        window.nativeEvent(b"windows_generic_MSG", VoidPtr(ctypes.addressof(msg)))
+        msg.message = WM_EXITSIZEMOVE
+        window.nativeEvent(b"windows_generic_MSG", VoidPtr(ctypes.addressof(msg)))
+        assert timers.calls == [("start", 0xBEEF), ("stop", 0xBEEF)]
+    finally:
+        window.close()
+
+
 def test_window_listens_and_is_discoverable(qapp, credentials, tmp_path):
     window = make_window(credentials, tmp_path)
     try:

{remotedesktop-0.9.0 → remotedesktop-0.10.0}/tests/test_sharing.py

@@ -22,7 +22,9 @@ def pump(qapp, condition, timeout=10.0):
         qapp.processEvents(QEventLoop.ProcessEventsFlag.AllEvents, 50)
 
 
-def make_server(credentials, tmp_path, *, approve, injector=None, clipboard=None):
+def make_server(
+    credentials, tmp_path, *, approve, injector=None, clipboard=None, log_provider=None
+):
     # The server is a distinct "machine" from the client -> its own database.
     server = ShareServer(
         approve_client=approve,
@@ -30,16 +32,18 @@ def make_server(credentials, tmp_path, *, approve, injector=None, clipboard=None
         paired=PairedClients(db.connect(tmp_path / "server.db")),
         injector=injector,
         clipboard=clipboard,
+        log_provider=log_provider,
     )
     assert server.listen(0)
     return server
 
 
-def make_client(tmp_path, *, clipboard=None):
+def make_client(tmp_path, *, clipboard=None, log_provider=None):
     return ShareClient(
         identity=IDENTITY,
         known_servers=KnownServers(db.connect(tmp_path / "client.db")),
         clipboard=clipboard,
+        log_provider=log_provider,
     )
 
 
@@ -537,6 +541,62 @@ def test_oversized_preauth_message_aborts_and_logs(qapp, credentials, tmp_path,
         server.close()
 
 
+def test_client_fetches_the_server_log(qapp, credentials, tmp_path):
+    server = make_server(
+        credentials, tmp_path, approve=lambda *_: True,
+        log_provider=lambda: "SERVER LOG TAIL",
+    )
+    client = make_client(tmp_path)
+    connected, received = [], []
+    client.connected.connect(connected.append)
+    client.logReceived.connect(received.append)
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        pump(qapp, lambda: connected)
+        client.request_log()
+        pump(qapp, lambda: received)
+        assert received == ["SERVER LOG TAIL"]
+    finally:
+        client.close()
+        server.close()
+
+
+def test_server_fetches_the_client_log(qapp, credentials, tmp_path):
+    server = make_server(credentials, tmp_path, approve=lambda *_: True)
+    client = make_client(tmp_path, log_provider=lambda: "CLIENT LOG TAIL")
+    connected, received = [], []
+    client.connected.connect(connected.append)
+    server.logReceived.connect(lambda name, text: received.append((name, text)))
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        pump(qapp, lambda: connected)
+        server.request_log()
+        pump(qapp, lambda: received)
+        assert received == [("test-client", "CLIENT LOG TAIL")]
+    finally:
+        client.close()
+        server.close()
+
+
+def test_log_request_without_a_provider_still_answers(qapp, credentials, tmp_path):
+    # The requesting side must never hang waiting: a peer with no log file
+    # (or none configured) answers with a placeholder.
+    server = make_server(credentials, tmp_path, approve=lambda *_: True)
+    client = make_client(tmp_path)
+    connected, received = [], []
+    client.connected.connect(connected.append)
+    client.logReceived.connect(received.append)
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        pump(qapp, lambda: connected)
+        client.request_log()
+        pump(qapp, lambda: received)
+        assert "no log available" in received[0]
+    finally:
+        client.close()
+        server.close()
+
+
 def test_server_reports_phases_in_status(qapp, credentials, tmp_path):
     server = make_server(credentials, tmp_path, approve=lambda *_: True)
     statuses: list[str] = []

remotedesktop-0.9.0/src/remotedesktop/logs.py

@@ -1,46 +0,0 @@
-"""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
-
-
-def default_log_dir() -> Path:
-    return Path(platformdirs.user_log_dir("remotedesktop", appauthor=False))
-
-
-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_dir / f"{app_name}.log"
-    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