remotedesktop 0.4.0__tar.gz → 0.6.0__tar.gz

{remotedesktop-0.4.0 → remotedesktop-0.6.0}/CLAUDE.md

@@ -8,7 +8,7 @@ A Python client/server remote desktop GUI application (PySide6) for Windows comp
 
 - **Autodiscovery and connection** of servers on the LAN.
 - **In scope:** desktop screen, keyboard, mouse, and clipboard.
-- **Out of scope:** shared drives, devices, and multimedia (e.g., audio).
+- **Out of scope:** shared drives, devices, and multimedia (e.g., audio). Smooth playback of fast-changing full-screen content (video, games) is a non-goal: the screen transfer is lossless and optimized for mostly-static desktop work, not for video bandwidth.
 - **Two GUI apps:** a client and a server, each run on its respective computer.
 - **Trust model:** on first connection, the user on the server side must explicitly permit the client. After that, the client may reconnect whenever the server is running without further approval.
 - **Constraint:** does not use Windows RDP and does not rely on any Microsoft-based authentication.
@@ -39,10 +39,10 @@ Managed with `uv` (hatchling build backend, src layout):
 - The client-side remote desktop view is a widget, `ViewerWidget` in `src/remotedesktop/viewer.py`, hosted as `ClientWindow`'s central widget. Screen display and keyboard/mouse/clipboard forwarding belong in this widget, not in the window.
 - **Autodiscovery** (`src/remotedesktop/discovery.py`) is a stdlib-only UDP probe/response protocol, deliberately not mDNS: the client broadcasts a JSON probe to `DISCOVERY_PORT` (48653) and servers reply with `{name, port}`; datagrams with the wrong magic/version/type are dropped. The server runs a `DiscoveryResponder` thread while its window is open; the client's `DiscoveryPanel` (dock in `ClientWindow`) calls the blocking `discover_servers()` on a worker thread and delivers results to the GUI via a queued signal. `DEFAULT_CONNECT_PORT` (48654) is reserved for the future desktop connection.
 - Discovery tests run over loopback with ephemeral ports (`bind_host`/`discovery_port`/`broadcast_hosts` parameters exist for this), so they never touch the real LAN or fixed ports.
-- **Screen sharing** (`sharing.py` + `protocol.py`) runs entirely on the Qt event loop — no threads or locks. `MessageStream` frames messages over a QTcpSocket (4-byte length + kind byte; JSON control messages or JPEG frames; malformed input aborts the socket). `ShareServer` owns one QTimer that grabs the primary screen via `QScreen.grabWindow(0)`, JPEG-encodes once, and fans out to all clients, skipping clients whose send buffer is backlogged; the timer only runs while clients are connected. `ShareClient` decodes frames to QImage for the viewer.
+- **Screen sharing** (`sharing.py` + `protocol.py` + `frames.py`) runs entirely on the Qt event loop — no threads or locks. `MessageStream` frames messages over a QTcpSocket (4-byte length + kind byte; JSON control messages, full frames, or inter-frame deltas; malformed input aborts the socket). `ShareServer` owns one QTimer that grabs the primary screen at full resolution via `_capture()` (a seam tests override to drive deterministic frame content) and fans out to all clients, skipping clients whose send buffer is backlogged; the timer only runs while clients are connected. **Frame transfer is lossless and inter-frame compressed** (`frames.py`): consecutive captures are diffed in 64-row bands (memoryview compares), and only changed bands ship as PNG in a delta payload the client patches onto its previous frame; an unchanged screen sends nothing. Full PNG keyframes go to clients that just joined, just recovered from a send backlog, or requested one (a `{"type": "keyframe"}` message — sent when a delta fails to apply, so desync self-heals). The capability is negotiated via `"delta": true` in the client hello; clients without it (0.5.0) get full JPEG frames every tick because they force-decode frames as JPEG — never send them PNG. Each variant (legacy JPEG / keyframe PNG / delta) is encoded at most once per tick and shared across clients. `ShareClient` decodes/patches to QImage for the viewer, which displays it scaled with a cached `SmoothTransformation` copy (full resolution is always delivered; scaling happens client-side only).
 - **All persistence is one SQLite database** (`db.py`): `db.connect(path)` opens the DB and ensures every table (`settings`, `paired_clients`, `known_servers`, and the inventory tables). The file lives at `config.default_db_path()` — `platformdirs.user_data_dir("remotedesktop")` (`%LOCALAPPDATA%\remotedesktop\remotedesktop.db` on Windows). **Use `platformdirs` for any new data location; don't hardcode `%APPDATA%`.** Every store (`Settings`, `PairedClients`, `KnownServers`, `ConnectionInventory`) takes a `sqlite3.Connection`; the GUIs open one connection per window and share it. Both window classes take a `connection=` keyword so tests inject a temp-file DB and never touch the real one (see `tests/test_client_window.py` / `test_server_window.py`). Tests pass `db.connect(tmp_path/"x.db")` (or omit for in-memory), and use **separate DB files for the server and client** since they model different machines.
 - **Trust model plumbing** (`config.py`): the client has a stable UUID identity (`load_client_identity`, in the `settings` table) and the server maps each approved client-id to a token (`PairedClients`). `ShareServer` takes an `approve_client(client_id, name) -> bool` callback; `ServerWindow` implements it as a modal QMessageBox. Tests inject stores backed by a temp DB and explicit identities so they never touch real data or prompt.
-- **Status/debug logging is a feature**: `ShareServer`, `ShareClient`, and `DiscoveryPanel` emit human-readable `status` signals for every connection phase, and both windows show them in a timestamped "Connection log" pane. When adding connection behavior, emit a status message for each new phase or failure path — there's a test asserting the server's phase messages.
+- **Status/debug logging is a feature**: `ShareServer`, `ShareClient`, and `DiscoveryPanel` emit human-readable `status` signals for every connection phase, and both windows show them in a timestamped "Connection log" pane. When adding connection behavior, emit a status message for each new phase or failure path — there's a test asserting the server's phase messages. Everything the panes show is also written to a rotating debug log file (`logs.py`; `logs.init_logging("client"/"server")` is called only by each app's `main()`, under `platformdirs.user_log_dir("remotedesktop")` — `%LOCALAPPDATA%\remotedesktop\Logs\{client,server}.log` on Windows). Lower-level detail (socket state changes, protocol aborts, frame-drop/backlog, discovery datagram drops) goes straight to `logging.getLogger("remotedesktop.*")` at debug/warning level — silent failure paths should log there even when a status message would be too noisy. Library code and tests never call `init_logging`; without a handler those loggers are no-ops.
 - **Connection inventory** (`inventory.py`): both windows have a tab (server: "Clients on LAN"; client: "Servers on LAN") backed by a `ConnectionInventory` — one `PeerRecord` per peer with attempts count, current state, first/last seen. The server drives it from `ShareServer.peerEvent` (a structured `{key, event, name, address, detail}` signal emitted alongside the status strings at each phase — keep both in sync when adding phases). The client drives it from `ClientWindow`'s own handlers (discovered servers from `DiscoveryPanel.serversFound`, plus attempt/connected/denied/disconnected). Server peers key by client-id; client peers key by `host:port`. **Persisted in SQLite** and reloaded on startup, so it survives restarts.
 - **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.

{remotedesktop-0.4.0 → remotedesktop-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.4.0
+Version: 0.6.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
@@ -36,6 +36,12 @@ Connections are made to the desktop screen, keyboard, mouse, and clipboard.
 Other connections are not provided, such as shared drives, devices, or
 multimedia (e.g., audio).
 
+The screen transfer is optimized for ordinary desktop work — documents,
+code, terminals — where most of the screen is static between frames: it is
+lossless (pixel-exact at full resolution) and only changed screen regions
+are transmitted. Smooth playback of fast-changing full-screen content, such
+as video or games, is a non-goal.
+
 The client and server are PySide6 (Qt) GUI apps, each run on its respective
 computer. The client requests connection to the server, and for the initial
 connection the user on the server side must permit the connection. After

{remotedesktop-0.4.0 → remotedesktop-0.6.0}/readme.md

@@ -17,6 +17,12 @@ Connections are made to the desktop screen, keyboard, mouse, and clipboard.
 Other connections are not provided, such as shared drives, devices, or
 multimedia (e.g., audio).
 
+The screen transfer is optimized for ordinary desktop work — documents,
+code, terminals — where most of the screen is static between frames: it is
+lossless (pixel-exact at full resolution) and only changed screen regions
+are transmitted. Smooth playback of fast-changing full-screen content, such
+as video or games, is a non-goal.
+
 The client and server are PySide6 (Qt) GUI apps, each run on its respective
 computer. The client requests connection to the server, and for the initial
 connection the user on the server side must permit the connection. After

{remotedesktop-0.4.0 → remotedesktop-0.6.0}/src/remotedesktop/__init__.py

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

{remotedesktop-0.4.0 → remotedesktop-0.6.0}/src/remotedesktop/client.py

@@ -1,6 +1,7 @@
 """Client GUI application: discovers servers on the LAN, connects to one,
 and shows its desktop in a viewer widget."""
 
+import logging
 import sqlite3
 import sys
 import threading
@@ -22,7 +23,7 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
-from remotedesktop import db, window_state
+from remotedesktop import db, logs, window_state
 from remotedesktop.clipboard import ClipboardSync
 from remotedesktop.config import KnownServers, Settings, default_db_path, load_client_identity
 from remotedesktop.discovery import DISCOVERY_PORT, ServerInfo, discover_servers
@@ -30,6 +31,8 @@ from remotedesktop.inventory import ConnectionInventory, InventoryTab
 from remotedesktop.sharing import ShareClient
 from remotedesktop.viewer import ViewerWidget
 
+_log = logging.getLogger("remotedesktop.client")
+
 
 class DiscoveryPanel(QWidget):
     """Scans the LAN for servers and lists them for the user to pick."""
@@ -83,7 +86,9 @@ class DiscoveryPanel(QWidget):
 
 
 class ClientWindow(QMainWindow):
-    def __init__(self, *, connection: sqlite3.Connection | None = None) -> None:
+    def __init__(
+        self, *, connection: sqlite3.Connection | None = None, auto_scan: bool = True
+    ) -> None:
         super().__init__()
         self.setWindowTitle("Remote Desktop Client")
         # Tests inject a connection to a temp database; the app uses the default.
@@ -128,8 +133,14 @@ class ClientWindow(QMainWindow):
         self._settings = Settings(self._db)
         window_state.restore_geometry(self, self._settings, window_state.CLIENT_GEOMETRY_KEY)
         self.log("Client started")
+        # Tests pass auto_scan=False so window tests never broadcast on the LAN.
+        if auto_scan:
+            self.discovery_panel.refresh()
 
     def log(self, message: str) -> None:
+        # Everything shown in the Connection log pane also goes to the debug
+        # log file (when main() enabled it), so it survives the window.
+        _log.info(message)
         self.connection_log.appendPlainText(f"{time.strftime('%H:%M:%S')}  {message}")
 
     def _forget_server(self, key: str) -> None:
@@ -180,6 +191,7 @@ class ClientWindow(QMainWindow):
         self._client = client
         client.status.connect(self.log)
         client.connected.connect(self._on_connected)
+        client.approvalPending.connect(self._on_approval_pending)
         client.denied.connect(self._on_denied)
         client.disconnected.connect(self._on_disconnected)
         client.frameReceived.connect(self._on_frame)
@@ -187,6 +199,15 @@ class ClientWindow(QMainWindow):
         self.statusBar().showMessage(f"Connecting to {server.name} ({server.host}:{server.port}) …")
         client.connect_to(server.host, server.port)
 
+    def _on_approval_pending(self) -> None:
+        self.viewer.clear(
+            f"Waiting for approval — someone at {self._server_name} "
+            "must allow this connection"
+        )
+        self.statusBar().showMessage(
+            f"Waiting for the user on {self._server_name} to approve this computer …"
+        )
+
     def _on_connected(self, server_name: str) -> None:
         self._server_name = server_name or self._server_name
         self._connected = True
@@ -234,10 +255,11 @@ class ClientWindow(QMainWindow):
 
 
 def main() -> None:  # pragma: no cover - runs the Qt event loop
+    log_path = logs.init_logging("client")
     app = QApplication(sys.argv)
-    window = ClientWindow()
+    window = ClientWindow()  # auto_scan starts the first LAN scan
+    window.log(f"Detailed log: {log_path}")
     window.show()
-    window.discovery_panel.refresh()
     raise SystemExit(app.exec())
 
 

{remotedesktop-0.4.0 → remotedesktop-0.6.0}/src/remotedesktop/discovery.py

@@ -6,12 +6,15 @@ whose magic, protocol version, or type don't match are ignored.
 """
 
 import json
+import logging
 import socket
 import threading
 import time
 from collections.abc import Sequence
 from dataclasses import dataclass
 
+_log = logging.getLogger("remotedesktop.discovery")
+
 DISCOVERY_PORT = 48653
 DEFAULT_CONNECT_PORT = 48654
 
@@ -101,11 +104,13 @@ class DiscoveryResponder:
             except OSError:
                 return
             if _parse(data, "probe") is None:
+                _log.debug("Ignoring non-probe datagram (%d bytes) from %s", len(data), sender)
                 continue
+            _log.debug("Probe from %s — sending reply", sender)
             try:
                 self._socket.sendto(self._reply, sender)
-            except OSError:
-                pass
+            except OSError as error:
+                _log.warning("Could not reply to probe from %s: %s", sender, error)
 
 
 def discover_servers(
@@ -126,8 +131,10 @@ def discover_servers(
         for host in broadcast_hosts:
             try:
                 sock.sendto(probe, (host, discovery_port))
-            except OSError:
-                pass
+            except OSError as error:
+                # A failed broadcast means the scan quietly finds nothing —
+                # worth a record when diagnosing "no servers found".
+                _log.warning("Probe broadcast to %s:%d failed: %s", host, discovery_port, error)
         deadline = time.monotonic() + timeout
         while (remaining := deadline - time.monotonic()) > 0:
             sock.settimeout(remaining)
@@ -137,10 +144,13 @@ def discover_servers(
                 break
             message = _parse(data, "reply")
             if message is None:
+                _log.debug("Ignoring non-reply datagram (%d bytes) from %s", len(data), host)
                 continue
             name = message.get("name")
             port = message.get("port")
             if not isinstance(name, str) or not isinstance(port, int):
+                _log.debug("Ignoring malformed reply from %s: %r", host, message)
                 continue
             found.setdefault((host, port), ServerInfo(name=name, host=host, port=port))
+    _log.debug("Discovery scan finished: %d server(s) found", len(found))
     return list(found.values())

remotedesktop-0.6.0/src/remotedesktop/frames.py

@@ -0,0 +1,101 @@
+"""Inter-frame compression for the screen stream.
+
+Consecutive captures are compared in horizontal bands (BAND_HEIGHT rows,
+adjacent changed bands merged); only changed bands are encoded and shipped
+in a delta payload, which the client patches onto its previous frame. Bands
+keep the comparison and the crop cheap: a band is a contiguous byte range of
+the image, so diffing is a C-speed memoryview compare.
+
+Delta bands and keyframes for delta-capable clients are PNG — lossless, so
+the client's canvas is pixel-identical to the capture and patches never
+accumulate artifacts. (Legacy clients still get JPEG full frames: 0.5.0
+force-decodes frames as JPEG, so they must never see PNG.)
+
+Delta payload wire format: 4-byte big-endian header length, a JSON header
+{"w", "h", "bands": [{"y", "h", "len"}, ...]}, then the bands' PNG bytes
+concatenated in order.
+"""
+
+import json
+import struct
+
+from PySide6.QtCore import QBuffer
+from PySide6.QtGui import QImage, QPainter
+
+BAND_HEIGHT = 64
+_HEADER_LEN = struct.Struct(">I")
+
+
+def encode_image(image: QImage, image_format: str = "PNG", quality: int = -1) -> bytes:
+    buffer = QBuffer()
+    buffer.open(QBuffer.OpenModeFlag.WriteOnly)
+    image.save(buffer, image_format, quality)  # ty: ignore[no-matching-overload]
+    return bytes(buffer.data())  # ty: ignore[invalid-argument-type]
+
+
+def changed_bands(previous: QImage, current: QImage) -> list[tuple[int, int]] | None:
+    """Bands of `current` that differ from `previous`, as (y, height) pairs.
+
+    Adjacent changed bands are merged. Returns None when the images are not
+    comparable (different size or format) — the caller must fall back to a
+    full frame.
+    """
+    if previous.size() != current.size() or previous.format() != current.format():
+        return None
+    prev_bits = previous.constBits()
+    cur_bits = current.constBits()
+    stride = current.bytesPerLine()
+    height = current.height()
+    bands: list[tuple[int, int]] = []
+    y = 0
+    while y < height:
+        h = min(BAND_HEIGHT, height - y)
+        if prev_bits[y * stride : (y + h) * stride] != cur_bits[y * stride : (y + h) * stride]:
+            if bands and bands[-1][0] + bands[-1][1] == y:
+                bands[-1] = (bands[-1][0], bands[-1][1] + h)
+            else:
+                bands.append((y, h))
+        y += h
+    return bands
+
+
+def encode_delta(image: QImage, bands: list[tuple[int, int]]) -> bytes:
+    entries = []
+    blobs = []
+    for y, h in bands:
+        png = encode_image(image.copy(0, y, image.width(), h))
+        entries.append({"y": y, "h": h, "len": len(png)})
+        blobs.append(png)
+    header = json.dumps({"w": image.width(), "h": image.height(), "bands": entries}).encode()
+    return _HEADER_LEN.pack(len(header)) + header + b"".join(blobs)
+
+
+def apply_delta(canvas: QImage, payload: bytes) -> QImage | None:
+    """Patch a delta payload onto a copy of `canvas`.
+
+    Returns the patched image, or None if the payload is malformed or was
+    produced for a different frame size (the caller should then wait for
+    the next keyframe).
+    """
+    try:
+        (header_len,) = _HEADER_LEN.unpack_from(payload)
+        header = json.loads(payload[_HEADER_LEN.size : _HEADER_LEN.size + header_len].decode())
+        bands = [(int(b["y"]), int(b["h"]), int(b["len"])) for b in header["bands"]]
+        size_ok = int(header["w"]) == canvas.width() and int(header["h"]) == canvas.height()
+    except (struct.error, UnicodeDecodeError, json.JSONDecodeError, KeyError, TypeError, ValueError):
+        return None
+    if not size_ok:
+        return None
+    image = canvas.copy()
+    painter = QPainter(image)
+    offset = _HEADER_LEN.size + header_len
+    try:
+        for y, h, length in bands:
+            band = QImage.fromData(payload[offset : offset + length])
+            offset += length
+            if band.isNull() or band.height() != h:
+                return None
+            painter.drawImage(0, y, band)
+    finally:
+        painter.end()
+    return image

remotedesktop-0.6.0/src/remotedesktop/logs.py

@@ -0,0 +1,46 @@
+"""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

{remotedesktop-0.4.0 → remotedesktop-0.6.0}/src/remotedesktop/protocol.py

@@ -6,6 +6,7 @@ input aborts the connection.
 """
 
 import json
+import logging
 import struct
 
 from PySide6.QtCore import QObject, Signal
@@ -13,9 +14,12 @@ from PySide6.QtNetwork import QTcpSocket
 
 PROTOCOL_VERSION = 1
 
+_log = logging.getLogger("remotedesktop.protocol")
+
 _HEADER = struct.Struct(">IB")
 _KIND_JSON = 0
 _KIND_FRAME = 1
+_KIND_DELTA = 2  # inter-frame delta (see frames.py); unknown to 0.5.0 peers
 MAX_PAYLOAD = 64 * 1024 * 1024
 
 
@@ -28,6 +32,7 @@ class MessageStream(QObject):
 
     jsonReceived = Signal(dict)
     frameReceived = Signal(bytes)
+    deltaReceived = Signal(bytes)
 
     def __init__(
         self,
@@ -44,8 +49,11 @@ class MessageStream(QObject):
     def send_json(self, message: dict) -> None:
         self._send(_KIND_JSON, json.dumps(message).encode())
 
-    def send_frame(self, jpeg: bytes) -> None:
-        self._send(_KIND_FRAME, jpeg)
+    def send_frame(self, frame: bytes) -> None:
+        self._send(_KIND_FRAME, frame)
+
+    def send_delta(self, payload: bytes) -> None:
+        self._send(_KIND_DELTA, payload)
 
     def _send(self, kind: int, payload: bytes) -> None:
         self.socket.write(_HEADER.pack(len(payload), kind) + payload)
@@ -56,6 +64,15 @@ class MessageStream(QObject):
                 return
             length, kind = _HEADER.unpack(self.socket.peek(_HEADER.size).data())
             if length > self.max_payload:
+                _log.warning(
+                    "Aborting %s:%s: payload of %d bytes (kind=%d) exceeds the "
+                    "%d-byte cap",
+                    self.socket.peerAddress().toString(),
+                    self.socket.peerPort(),
+                    length,
+                    kind,
+                    self.max_payload,
+                )
                 self.socket.abort()
                 return
             if self.socket.bytesAvailable() < _HEADER.size + length:
@@ -65,11 +82,21 @@ class MessageStream(QObject):
             if kind == _KIND_JSON:
                 try:
                     message = json.loads(bytes(payload).decode())
-                except (UnicodeDecodeError, json.JSONDecodeError):
+                except (UnicodeDecodeError, json.JSONDecodeError) as error:
+                    _log.warning(
+                        "Aborting %s:%s: undecodable JSON control message "
+                        "(%d bytes): %s",
+                        self.socket.peerAddress().toString(),
+                        self.socket.peerPort(),
+                        length,
+                        error,
+                    )
                     self.socket.abort()
                     return
                 if isinstance(message, dict):
                     self.jsonReceived.emit(message)
             elif kind == _KIND_FRAME:
                 self.frameReceived.emit(payload)
+            elif kind == _KIND_DELTA:
+                self.deltaReceived.emit(payload)
             # Unknown kinds are skipped so the protocol can grow.

{remotedesktop-0.4.0 → remotedesktop-0.6.0}/src/remotedesktop/server.py

@@ -1,6 +1,7 @@
 """Server GUI application: shares this computer's desktop with permitted
 clients and prompts the user to approve first-time connections."""
 
+import logging
 import socket
 import sqlite3
 import sys
@@ -20,7 +21,7 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
-from remotedesktop import db, tls, window_state
+from remotedesktop import db, 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 +33,8 @@ from remotedesktop.discovery import (
 from remotedesktop.inventory import ConnectionInventory, InventoryTab
 from remotedesktop.sharing import ShareServer
 
+_log = logging.getLogger("remotedesktop.server")
+
 
 class ServerWindow(QMainWindow):
     def __init__(
@@ -119,6 +122,9 @@ class ServerWindow(QMainWindow):
         window_state.restore_geometry(self, self._settings, window_state.SERVER_GEOMETRY_KEY)
 
     def log(self, message: str) -> None:
+        # Everything shown in the Connection log pane also goes to the debug
+        # log file (when main() enabled it), so it survives the window.
+        _log.info(message)
         self.connection_log.appendPlainText(f"{time.strftime('%H:%M:%S')}  {message}")
 
     def _record_peer(self, event: dict) -> None:
@@ -163,12 +169,21 @@ class ServerWindow(QMainWindow):
             self.share_server.revoke_client(client_id)
 
     def _ask_approval(self, client_id: str, client_name: str) -> bool:
-        answer = QMessageBox.question(
-            self,
+        box = QMessageBox(
+            QMessageBox.Icon.Question,
             "Connection request",
             f'Allow "{client_name}" to view this desktop?\n\nClient id: {client_id}',
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            self,
         )
-        return answer == QMessageBox.StandardButton.Yes
+        # The server usually isn't the foreground app when a request arrives,
+        # and Windows won't give focus to a background app's dialog — keep it
+        # on top so it can't sit unnoticed behind other windows.
+        box.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)
+        box.show()
+        box.raise_()
+        box.activateWindow()
+        return box.exec() == QMessageBox.StandardButton.Yes
 
     def closeEvent(self, event: QCloseEvent) -> None:
         window_state.save_geometry(self, self._settings, window_state.SERVER_GEOMETRY_KEY)
@@ -179,8 +194,10 @@ class ServerWindow(QMainWindow):
 
 
 def main() -> None:  # pragma: no cover - runs the Qt event loop
+    log_path = logs.init_logging("server")
     app = QApplication(sys.argv)
     window = ServerWindow()
+    window.log(f"Detailed log: {log_path}")
     window.show()
     raise SystemExit(app.exec())