remotedesktop 0.12.0__tar.gz → 0.13.0__tar.gz

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/CLAUDE.md

@@ -47,7 +47,7 @@ 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.
+- **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` from `WM_NCLBUTTONDOWN` (a press-and-hold that never moves blocks in DefWindowProc's click tracking without ever sending `WM_ENTERSIZEMOVE`) until `WM_CAPTURECHANGED`/`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.

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.12.0
+Version: 0.13.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.12.0 → remotedesktop-0.13.0}/src/remotedesktop/__init__.py

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

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/src/remotedesktop/frames.py

@@ -23,6 +23,11 @@ from PySide6.QtCore import QBuffer
 from PySide6.QtGui import QImage, QPainter
 
 BAND_HEIGHT = 64
+# PNG is lossless at any "quality" — the setting only picks the zlib effort.
+# 80 encodes a 4K frame ~35% faster than the default for ~20% more bytes;
+# encoding happens on the GUI thread every tick, so time matters more than
+# size on a LAN.
+PNG_QUALITY = 80
 _HEADER_LEN = struct.Struct(">I")
 
 
@@ -63,7 +68,7 @@ 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))
+        png = encode_image(image.copy(0, y, image.width(), h), "PNG", PNG_QUALITY)
         entries.append({"y": y, "h": h, "len": len(png)})
         blobs.append(png)
     header = json.dumps({"w": image.width(), "h": image.height(), "bands": entries}).encode()
@@ -71,11 +76,15 @@ def encode_delta(image: QImage, bands: list[tuple[int, int]]) -> bytes:
 
 
 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).
+    """Patch a delta payload onto `canvas`, in place.
+
+    Returns the patched image (`canvas` itself), or None — with the canvas
+    untouched — if the payload is malformed or was produced for a different
+    frame size (the caller should then wait for the next keyframe). Every
+    band is decoded before any is painted, so a payload that goes bad
+    halfway never leaves a half-patched canvas. Painting in place skips a
+    full-frame copy per delta; QImage's copy-on-write still protects any
+    other holder of the image.
     """
     try:
         (header_len,) = _HEADER_LEN.unpack_from(payload)
@@ -86,16 +95,18 @@ def apply_delta(canvas: QImage, payload: bytes) -> QImage | None:
         return None
     if not size_ok:
         return None
-    image = canvas.copy()
-    painter = QPainter(image)
+    decoded: list[tuple[int, QImage]] = []
     offset = _HEADER_LEN.size + header_len
+    for y, h, length in bands:
+        band = QImage.fromData(payload[offset : offset + length])
+        offset += length
+        if band.isNull() or band.height() != h:
+            return None
+        decoded.append((y, band))
+    painter = QPainter(canvas)
     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
+        for y, band in decoded:
             painter.drawImage(0, y, band)
     finally:
         painter.end()
-    return image
+    return canvas

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/src/remotedesktop/inventory.py

@@ -1,218 +1,221 @@
-"""A running inventory of every peer this app has seen on the LAN.
-
-Both apps keep one `ConnectionInventory`: the server records every client that
-connects or attempts to, the client records every server it discovers or tries
-to reach. `InventoryTab` shows it as a table and, optionally, a button to act
-on the selected peer (revoke a client / forget a server). Persisted in SQLite,
-so it answers "who is using this on the LAN, and who tried?" across restarts.
-"""
-
-import sqlite3
-import time
-from collections.abc import Callable
-from dataclasses import astuple, dataclass, fields
-
-from PySide6.QtCore import Qt, QObject, Signal
-from PySide6.QtWidgets import (
-    QAbstractItemView,
-    QHeaderView,
-    QPushButton,
-    QTableWidget,
-    QTableWidgetItem,
-    QVBoxLayout,
-    QWidget,
-)
-
-from remotedesktop import db
-
-# Event -> the state to display for the peer after it happens.
-_EVENT_STATE = {
-    "discovered": "discovered",
-    "attempt": "connecting",
-    "connected": "connected",
-    "authenticated": "connected (token)",
-    "paired": "connected (paired)",
-    "denied": "denied",
-    "refused": "refused",
-    "disconnected": "disconnected",
-    "revoked": "revoked",
-    "forgotten": "forgotten",
-    "error": "error",
-}
-
-
-@dataclass
-class PeerRecord:
-    key: str
-    name: str
-    address: str
-    detail: str
-    first_seen: str
-    last_seen: str
-    attempts: int
-    state: str
-    last_event: str
-
-
-class ConnectionInventory(QObject):
-    """Peers seen on the LAN, backed by SQLite so it persists across restarts.
-
-    Pass a `sqlite3.Connection` from `db.connect`; omit it for an in-memory
-    database that lives only as long as the object (used by tests).
-    """
-
-    changed = Signal()
-
-    _COLUMNS = [f.name for f in fields(PeerRecord)]
-
-    def __init__(
-        self,
-        connection: sqlite3.Connection | None = None,
-        table: str = "peers",
-        parent: QObject | None = None,
-    ) -> None:
-        super().__init__(parent)
-        if table not in db.PEER_TABLES:
-            raise ValueError(f"unknown inventory table: {table!r}")
-        self._table = table
-        self._peers: dict[str, PeerRecord] = {}
-        self._db = connection if connection is not None else db.connect(None)
-        self._load()
-
-    @staticmethod
-    def _now() -> str:
-        return time.strftime("%Y-%m-%d %H:%M:%S")
-
-    def _load(self) -> None:
-        try:
-            rows = self._db.execute(f"SELECT {', '.join(self._COLUMNS)} FROM {self._table}")
-            for row in rows:
-                record = PeerRecord(*row)
-                self._peers[record.key] = record
-        except sqlite3.Error:
-            self._peers.clear()
-
-    def _save(self, record: PeerRecord) -> None:
-        placeholders = ", ".join("?" for _ in self._COLUMNS)
-        updates = ", ".join(f"{c}=excluded.{c}" for c in self._COLUMNS if c != "key")
-        try:
-            self._db.execute(
-                f"INSERT INTO {self._table} ({', '.join(self._COLUMNS)}) "
-                f"VALUES ({placeholders}) ON CONFLICT(key) DO UPDATE SET {updates}",
-                astuple(record),
-            )
-            self._db.commit()
-        except sqlite3.Error:
-            pass  # persistence failure must never break connectivity
-
-    def record(
-        self,
-        key: str,
-        event: str,
-        *,
-        name: str = "",
-        address: str = "",
-        detail: str = "",
-    ) -> None:
-        now = self._now()
-        record = self._peers.get(key)
-        if record is None:
-            record = PeerRecord(key, name, address, detail, now, now, 0, "", "")
-            self._peers[key] = record
-        record.last_seen = now
-        if name:
-            record.name = name
-        if address:
-            record.address = address
-        if detail:
-            record.detail = detail
-        if event == "attempt":
-            record.attempts += 1
-        record.state = _EVENT_STATE.get(event, event)
-        record.last_event = event
-        self._save(record)
-        self.changed.emit()
-
-    def peers(self) -> list[PeerRecord]:
-        return sorted(self._peers.values(), key=lambda r: r.last_seen, reverse=True)
-
-
-class InventoryTab(QWidget):
-    """Table view of a ConnectionInventory, refreshed as it changes.
-
-    If `action_label`/`action_callback` are given, a button below the table is
-    enabled when a row is selected and calls `action_callback(peer_key)`.
-    """
-
-    _COLUMNS = ["Name", "Address", "Identifier", "State", "Attempts", "First seen", "Last seen"]
-
-    def __init__(
-        self,
-        inventory: ConnectionInventory,
-        action_label: str | None = None,
-        action_callback: Callable[[str], None] | None = None,
-        parent: QWidget | None = None,
-    ) -> None:
-        super().__init__(parent)
-        self._inventory = inventory
-        self._action_callback = action_callback
-        self._table = QTableWidget(0, len(self._COLUMNS))
-        self._table.setHorizontalHeaderLabels(self._COLUMNS)
-        self._table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
-        self._table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
-        self._table.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
-        self._table.verticalHeader().setVisible(False)
-        self._table.horizontalHeader().setSectionResizeMode(
-            QHeaderView.ResizeMode.ResizeToContents
-        )
-        self._table.horizontalHeader().setStretchLastSection(True)
-        layout = QVBoxLayout(self)
-        layout.addWidget(self._table)
-
-        self._action_button: QPushButton | None = None
-        if action_label and action_callback:
-            self._action_button = QPushButton(action_label)
-            self._action_button.setEnabled(False)
-            self._action_button.clicked.connect(self._on_action)
-            self._table.itemSelectionChanged.connect(self._on_selection_changed)
-            layout.addWidget(self._action_button)
-
-        inventory.changed.connect(self.refresh)
-        self.refresh()
-
-    def _selected_key(self) -> str | None:
-        row = self._table.currentRow()
-        if row < 0:
-            return None
-        item = self._table.item(row, 0)
-        return item.data(Qt.ItemDataRole.UserRole) if item is not None else None
-
-    def _on_selection_changed(self) -> None:
-        if self._action_button is not None:
-            self._action_button.setEnabled(self._selected_key() is not None)
-
-    def _on_action(self) -> None:
-        key = self._selected_key()
-        if key and self._action_callback is not None:
-            self._action_callback(key)
-
-    def refresh(self) -> None:
-        peers = self._inventory.peers()
-        self._table.setRowCount(len(peers))
-        for row, peer in enumerate(peers):
-            values = [
-                peer.name or "(unknown)",
-                peer.address,
-                peer.detail,
-                peer.state,
-                str(peer.attempts),
-                peer.first_seen,
-                peer.last_seen,
-            ]
-            for column, value in enumerate(values):
-                item = QTableWidgetItem(value)
-                if column == 0:
-                    item.setData(Qt.ItemDataRole.UserRole, peer.key)
-                self._table.setItem(row, column, item)
-        if self._action_button is not None:
-            self._action_button.setEnabled(self._selected_key() is not None)
+"""A running inventory of every peer this app has seen on the LAN.
+
+Both apps keep one `ConnectionInventory`: the server records every client that
+connects or attempts to, the client records every server it discovers or tries
+to reach. `InventoryTab` shows it as a table and, optionally, a button to act
+on the selected peer (revoke a client / forget a server). Persisted in SQLite,
+so it answers "who is using this on the LAN, and who tried?" across restarts.
+"""
+
+import sqlite3
+import time
+from collections.abc import Callable
+from dataclasses import astuple, dataclass, fields
+
+from PySide6.QtCore import Qt, QObject, Signal
+from PySide6.QtWidgets import (
+    QAbstractItemView,
+    QHeaderView,
+    QPushButton,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from remotedesktop import db
+
+# Event -> the state to display for the peer after it happens.
+_EVENT_STATE = {
+    "discovered": "discovered",
+    "attempt": "connecting",
+    "connected": "connected",
+    "authenticated": "connected (token)",
+    "paired": "connected (paired)",
+    "denied": "denied",
+    "refused": "refused",
+    "disconnected": "disconnected",
+    "revoked": "revoked",
+    "forgotten": "forgotten",
+    "error": "error",
+}
+
+
+@dataclass
+class PeerRecord:
+    key: str
+    name: str
+    address: str
+    detail: str
+    first_seen: str
+    last_seen: str
+    attempts: int
+    state: str
+    last_event: str
+
+
+class ConnectionInventory(QObject):
+    """Peers seen on the LAN, backed by SQLite so it persists across restarts.
+
+    Pass a `sqlite3.Connection` from `db.connect`; omit it for an in-memory
+    database that lives only as long as the object (used by tests).
+    """
+
+    changed = Signal()
+
+    _COLUMNS = [f.name for f in fields(PeerRecord)]
+
+    def __init__(
+        self,
+        connection: sqlite3.Connection | None = None,
+        table: str = "peers",
+        parent: QObject | None = None,
+    ) -> None:
+        super().__init__(parent)
+        if table not in db.PEER_TABLES:
+            raise ValueError(f"unknown inventory table: {table!r}")
+        self._table = table
+        self._peers: dict[str, PeerRecord] = {}
+        self._db = connection if connection is not None else db.connect(None)
+        self._load()
+
+    @staticmethod
+    def _now() -> str:
+        return time.strftime("%Y-%m-%d %H:%M:%S")
+
+    def _load(self) -> None:
+        try:
+            rows = self._db.execute(f"SELECT {', '.join(self._COLUMNS)} FROM {self._table}")
+            for row in rows:
+                record = PeerRecord(*row)
+                self._peers[record.key] = record
+        except sqlite3.Error:
+            self._peers.clear()
+
+    def _save(self, record: PeerRecord) -> None:
+        placeholders = ", ".join("?" for _ in self._COLUMNS)
+        updates = ", ".join(f"{c}=excluded.{c}" for c in self._COLUMNS if c != "key")
+        try:
+            self._db.execute(
+                f"INSERT INTO {self._table} ({', '.join(self._COLUMNS)}) "
+                f"VALUES ({placeholders}) ON CONFLICT(key) DO UPDATE SET {updates}",
+                astuple(record),
+            )
+            self._db.commit()
+        except sqlite3.Error:
+            pass  # persistence failure must never break connectivity
+
+    def record(
+        self,
+        key: str,
+        event: str,
+        *,
+        name: str = "",
+        address: str = "",
+        detail: str = "",
+    ) -> None:
+        now = self._now()
+        record = self._peers.get(key)
+        if record is None:
+            record = PeerRecord(key, name, address, detail, now, now, 0, "", "")
+            self._peers[key] = record
+        record.last_seen = now
+        if name:
+            record.name = name
+        if address:
+            record.address = address
+        if detail:
+            record.detail = detail
+        if event == "attempt":
+            record.attempts += 1
+        record.state = _EVENT_STATE.get(event, event)
+        record.last_event = event
+        self._save(record)
+        self.changed.emit()
+
+    def peers(self) -> list[PeerRecord]:
+        return sorted(self._peers.values(), key=lambda r: r.last_seen, reverse=True)
+
+
+class InventoryTab(QWidget):
+    """Table view of a ConnectionInventory, refreshed as it changes.
+
+    If `action_label`/`action_callback` are given, a button below the table is
+    enabled when a row is selected and calls `action_callback(peer_key)`.
+    """
+
+    _COLUMNS = ["Name", "Address", "Identifier", "State", "Attempts", "First seen", "Last seen"]
+
+    def __init__(
+        self,
+        inventory: ConnectionInventory,
+        action_label: str | None = None,
+        action_callback: Callable[[str], None] | None = None,
+        parent: QWidget | None = None,
+    ) -> None:
+        super().__init__(parent)
+        self._inventory = inventory
+        self._action_callback = action_callback
+        # One extra headerless column on the right: with stretchLastSection it
+        # absorbs the leftover width, so the data columns (including "Last
+        # seen") stay sized to their contents.
+        self._table = QTableWidget(0, len(self._COLUMNS) + 1)
+        self._table.setHorizontalHeaderLabels(self._COLUMNS + [""])
+        self._table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
+        self._table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
+        self._table.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
+        self._table.verticalHeader().setVisible(False)
+        self._table.horizontalHeader().setSectionResizeMode(
+            QHeaderView.ResizeMode.ResizeToContents
+        )
+        self._table.horizontalHeader().setStretchLastSection(True)
+        layout = QVBoxLayout(self)
+        layout.addWidget(self._table)
+
+        self._action_button: QPushButton | None = None
+        if action_label and action_callback:
+            self._action_button = QPushButton(action_label)
+            self._action_button.setEnabled(False)
+            self._action_button.clicked.connect(self._on_action)
+            self._table.itemSelectionChanged.connect(self._on_selection_changed)
+            layout.addWidget(self._action_button)
+
+        inventory.changed.connect(self.refresh)
+        self.refresh()
+
+    def _selected_key(self) -> str | None:
+        row = self._table.currentRow()
+        if row < 0:
+            return None
+        item = self._table.item(row, 0)
+        return item.data(Qt.ItemDataRole.UserRole) if item is not None else None
+
+    def _on_selection_changed(self) -> None:
+        if self._action_button is not None:
+            self._action_button.setEnabled(self._selected_key() is not None)
+
+    def _on_action(self) -> None:
+        key = self._selected_key()
+        if key and self._action_callback is not None:
+            self._action_callback(key)
+
+    def refresh(self) -> None:
+        peers = self._inventory.peers()
+        self._table.setRowCount(len(peers))
+        for row, peer in enumerate(peers):
+            values = [
+                peer.name or "(unknown)",
+                peer.address,
+                peer.detail,
+                peer.state,
+                str(peer.attempts),
+                peer.first_seen,
+                peer.last_seen,
+            ]
+            for column, value in enumerate(values):
+                item = QTableWidgetItem(value)
+                if column == 0:
+                    item.setData(Qt.ItemDataRole.UserRole, peer.key)
+                self._table.setItem(row, column, item)
+        if self._action_button is not None:
+            self._action_button.setEnabled(self._selected_key() is not None)

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/src/remotedesktop/modal_loop.py

@@ -8,10 +8,14 @@ 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.
+Native WM_TIMER callbacks *are* dispatched inside modal loops, so from the
+non-client mouse press (WM_NCLBUTTONDOWN — a press-and-hold that never
+moves blocks in DefWindowProc's click tracking without ever sending
+WM_ENTERSIZEMOVE) until the tracking loop releases mouse capture
+(WM_CAPTURECHANGED, or WM_EXITSIZEMOVE after an actual drag), 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
@@ -28,6 +32,8 @@ from PySide6.QtCore import QCoreApplication, QEventLoop
 
 _log = logging.getLogger("remotedesktop.modal_loop")
 
+WM_NCLBUTTONDOWN = 0x00A1
+WM_CAPTURECHANGED = 0x0215
 WM_ENTERSIZEMOVE = 0x0231
 WM_EXITSIZEMOVE = 0x0232
 _TIMER_ID = 0x5244  # arbitrary but stable; scoped to the window's hwnd
@@ -74,24 +80,32 @@ class ModalLoopPump:
         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:
+        # WM_ENTERSIZEMOVE alone is not enough: a press-and-hold on the title
+        # bar that never moves blocks the thread inside DefWindowProc's click
+        # tracking WITHOUT ever sending WM_ENTERSIZEMOVE, so the pump must
+        # arm on the non-client press itself. The tracking loop takes mouse
+        # capture, so WM_CAPTURECHANGED marks its end whether or not a drag
+        # (and its WM_EXITSIZEMOVE) ever happened.
+        if msg.message in (WM_NCLBUTTONDOWN, WM_ENTERSIZEMOVE):
             self._enter(msg.hWnd or 0)
-        elif msg.message == WM_EXITSIZEMOVE:
+        elif msg.message in (WM_CAPTURECHANGED, WM_EXITSIZEMOVE):
             self._exit()
 
     def _enter(self, hwnd: int) -> None:
+        if self._hwnd == hwnd:  # NCLBUTTONDOWN then ENTERSIZEMOVE: already armed
+            return
         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")
+        _log.debug("Native mouse tracking started — 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")
+        _log.debug("Native mouse tracking ended")
 
     def _on_timer(self) -> None:
         if self._pumping:  # processEvents can dispatch this timer re-entrantly

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/src/remotedesktop/performance.py

@@ -438,14 +438,15 @@ class PerformanceTab(QWidget):
             format_rate,
             tick_unit=rate_unit,
         )
-        # Each line is named for the side that sent the ping, so the same
-        # line has the same name in both apps ("client → server" is the
-        # client-measured round trip on either end).
+        # Each line is a full round trip named for the side that sent the
+        # ping, with the whole loop spelled out — "client → server" alone
+        # read as a one-way leg and had users looking for a "total" line.
+        # One-way legs aren't measurable without synchronized clocks.
         self.ping_graph = GraphWidget(
             "Round-trip time",
             [
-                (f"{local} → {remote}", QColor("#ff9800"), monitor.rtt_ms),
-                (f"{remote} → {local}", QColor("#9c27b0"), monitor.peer_rtt_ms),
+                (f"{local} → {remote} → {local}", QColor("#ff9800"), monitor.rtt_ms),
+                (f"{remote} → {local} → {remote}", QColor("#9c27b0"), monitor.peer_rtt_ms),
             ],
             monitor,
             format_ms,

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/src/remotedesktop/sharing.py

@@ -53,8 +53,12 @@ DEFAULT_FPS = 30
 # Only for full frames to legacy (0.5.0) clients, which force-decode frames
 # as JPEG. Delta-capable clients get lossless PNG keyframes and delta bands.
 JPEG_QUALITY = 70
-# Skip sending to a client whose socket buffer is this far behind.
-_MAX_SEND_BACKLOG = 8 * 1024 * 1024
+# Skip sending to a client whose socket buffer is this far behind. Unsent
+# bytes are queued latency (the client renders them all before showing
+# anything current), so the cap is kept tight: ~160 ms of queue on 100 Mbit
+# WiFi, with headroom above one 4K keyframe (~1 MB) so a fresh keyframe
+# never trips it by itself.
+_MAX_SEND_BACKLOG = 2 * 1024 * 1024
 # Until a client passes the approval handshake it may only send small
 # messages (a hello is well under 1 KB); the cap is lifted on admission.
 _PREAUTH_MAX_PAYLOAD = 64 * 1024
@@ -539,7 +543,7 @@ class ShareServer(QObject):
                 stream.send_frame(legacy_jpeg)
             elif stream in self._needs_keyframe or bands is None:
                 if keyframe_png is None:
-                    keyframe_png = frames.encode_image(image)
+                    keyframe_png = frames.encode_image(image, "PNG", frames.PNG_QUALITY)
                     _log.debug("Keyframe: %d KB PNG", len(keyframe_png) // 1024)
                 stream.send_frame(keyframe_png)
                 self._needs_keyframe.discard(stream)

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/tests/test_frames.py

@@ -1,3 +1,6 @@
+import json
+import struct
+
 from PySide6.QtGui import QColor, QImage, QPainter
 
 from remotedesktop import frames
@@ -54,6 +57,32 @@ def test_delta_round_trip_is_lossless(qapp):
     assert patched.pixelColor(5, 100).name() == "#0000ff"
 
 
+def test_apply_delta_patches_in_place(qapp):
+    base = solid(64, 128, "red")
+    modified = solid(64, 128, "red")
+    fill_rect(modified, 0, 64, 64, 64, "blue")
+    payload = frames.encode_delta(modified, [(64, 64)])
+    patched = frames.apply_delta(base, payload)
+    assert patched is base  # no full-canvas copy per delta
+
+
+def test_bad_band_leaves_the_canvas_untouched(qapp):
+    base = solid(64, 128, "red")
+    # A valid first band followed by an undecodable second band. Nothing may
+    # be painted, or the canvas would be half-patched with no keyframe
+    # recovery covering the first band.
+    good_band = frames.encode_image(solid(64, 64, "blue"))
+    header = json.dumps(
+        {"w": 64, "h": 128, "bands": [
+            {"y": 0, "h": 64, "len": len(good_band)},
+            {"y": 64, "h": 64, "len": 10},
+        ]}
+    ).encode()
+    payload = struct.pack(">I", len(header)) + header + good_band + b"\0" * 10
+    assert frames.apply_delta(base, payload) is None
+    assert base == solid(64, 128, "red")
+
+
 def test_delta_for_a_different_size_is_rejected(qapp):
     modified = solid(64, 128, "blue")
     payload = frames.encode_delta(modified, [(0, 64)])

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/tests/test_inventory.py

@@ -1,113 +1,125 @@
-import pytest
-
-from remotedesktop import db
-from remotedesktop.inventory import ConnectionInventory, InventoryTab
-
-from test_sharing import make_client, make_server, pump
-
-
-def test_unknown_table_is_rejected(qapp):
-    with pytest.raises(ValueError):
-        ConnectionInventory(table="not_a_table")
-
-
-def test_database_errors_never_break_the_inventory(qapp, tmp_path):
-    connection = db.connect(tmp_path / "app.db")
-    connection.close()
-    # Loading from a dead connection yields an empty inventory...
-    inv = ConnectionInventory(connection)
-    assert inv.peers() == []
-    # ...and recording still updates the in-memory state despite save failing.
-    inv.record("peer", "attempt", name="Bob")
-    assert inv.peers()[0].name == "Bob"
-
-
-def test_inventory_tracks_attempts_and_state(qapp):
-    inv = ConnectionInventory()
-    inv.record("c1", "discovered", name="Alice", address="10.0.0.5:48654")
-    inv.record("c1", "attempt", name="Alice")
-    inv.record("c1", "connected", name="Alice")
-    peers = inv.peers()
-    assert len(peers) == 1
-    assert peers[0].name == "Alice"
-    assert peers[0].attempts == 1
-    assert peers[0].state == "connected"
-
-
-def test_inventory_counts_multiple_attempts_and_orders_recent_first(qapp):
-    inv = ConnectionInventory()
-    inv.record("a", "attempt", name="A")
-    inv.record("b", "attempt", name="B")
-    inv.record("a", "attempt", name="A")
-    inv.record("a", "denied", name="A")
-    by_key = {p.key: p for p in inv.peers()}
-    assert by_key["a"].attempts == 2
-    assert by_key["a"].state == "denied"
-    assert by_key["b"].attempts == 1
-
-
-def test_inventory_persists_across_restarts(qapp, tmp_path):
-    path = tmp_path / "app.db"
-    inv = ConnectionInventory(db.connect(path))
-    inv.record("peer", "attempt", name="Bob", address="10.0.0.9:48654")
-    inv.record("peer", "connected", name="Bob")
-
-    # A fresh inventory on the same database sees the earlier peer.
-    reopened = ConnectionInventory(db.connect(path))
-    peers = reopened.peers()
-    assert len(peers) == 1
-    assert peers[0].name == "Bob"
-    assert peers[0].attempts == 1
-    assert peers[0].state == "connected"
-    # And it keeps accumulating rather than starting over.
-    reopened.record("peer", "attempt", name="Bob")
-    assert reopened.peers()[0].attempts == 2
-
-
-def test_inventory_tab_shows_rows(qapp):
-    inv = ConnectionInventory()
-    tab = InventoryTab(inv)
-    assert tab._table.rowCount() == 0
-    inv.record("a", "attempt", name="A", address="host:1")
-    assert tab._table.rowCount() == 1
-    item = tab._table.item(0, 0)
-    assert item is not None and item.text() == "A"
-
-
-def test_inventory_tab_action_button_passes_selected_key(qapp):
-    inv = ConnectionInventory()
-    inv.record("client-42", "connected", name="Bob")
-    acted = []
-    tab = InventoryTab(inv, "Revoke", acted.append)
-    button = tab._action_button
-    assert button is not None
-    # No selection yet -> button disabled and does nothing useful.
-    assert not button.isEnabled()
-    tab._table.selectRow(0)
-    assert button.isEnabled()
-    button.click()
-    assert acted == ["client-42"]
-
-
-def test_server_populates_inventory_via_peer_events(qapp, credentials, tmp_path):
-    server = make_server(credentials, tmp_path, approve=lambda *_: True)
-    inv = ConnectionInventory()
-    server.peerEvent.connect(
-        lambda e: inv.record(
-            e["key"], e["event"], name=e.get("name", ""), address=e.get("address", "")
-        )
-    )
-    client = make_client(tmp_path)
-    connected = []
-    client.connected.connect(connected.append)
-    client.connect_to("127.0.0.1", server.port)
-    try:
-        pump(qapp, lambda: connected)
-        peers = inv.peers()
-        assert len(peers) == 1
-        assert peers[0].name == "test-client"
-        assert peers[0].attempts == 1
-        assert "connected" in peers[0].state  # "connected (paired)"
-    finally:
-        client.close()
-        server.close()
+import pytest
+
+from remotedesktop import db
+from remotedesktop.inventory import ConnectionInventory, InventoryTab
+
+from test_sharing import make_client, make_server, pump
+
+
+def test_unknown_table_is_rejected(qapp):
+    with pytest.raises(ValueError):
+        ConnectionInventory(table="not_a_table")
+
+
+def test_database_errors_never_break_the_inventory(qapp, tmp_path):
+    connection = db.connect(tmp_path / "app.db")
+    connection.close()
+    # Loading from a dead connection yields an empty inventory...
+    inv = ConnectionInventory(connection)
+    assert inv.peers() == []
+    # ...and recording still updates the in-memory state despite save failing.
+    inv.record("peer", "attempt", name="Bob")
+    assert inv.peers()[0].name == "Bob"
+
+
+def test_inventory_tracks_attempts_and_state(qapp):
+    inv = ConnectionInventory()
+    inv.record("c1", "discovered", name="Alice", address="10.0.0.5:48654")
+    inv.record("c1", "attempt", name="Alice")
+    inv.record("c1", "connected", name="Alice")
+    peers = inv.peers()
+    assert len(peers) == 1
+    assert peers[0].name == "Alice"
+    assert peers[0].attempts == 1
+    assert peers[0].state == "connected"
+
+
+def test_inventory_counts_multiple_attempts_and_orders_recent_first(qapp):
+    inv = ConnectionInventory()
+    inv.record("a", "attempt", name="A")
+    inv.record("b", "attempt", name="B")
+    inv.record("a", "attempt", name="A")
+    inv.record("a", "denied", name="A")
+    by_key = {p.key: p for p in inv.peers()}
+    assert by_key["a"].attempts == 2
+    assert by_key["a"].state == "denied"
+    assert by_key["b"].attempts == 1
+
+
+def test_inventory_persists_across_restarts(qapp, tmp_path):
+    path = tmp_path / "app.db"
+    inv = ConnectionInventory(db.connect(path))
+    inv.record("peer", "attempt", name="Bob", address="10.0.0.9:48654")
+    inv.record("peer", "connected", name="Bob")
+
+    # A fresh inventory on the same database sees the earlier peer.
+    reopened = ConnectionInventory(db.connect(path))
+    peers = reopened.peers()
+    assert len(peers) == 1
+    assert peers[0].name == "Bob"
+    assert peers[0].attempts == 1
+    assert peers[0].state == "connected"
+    # And it keeps accumulating rather than starting over.
+    reopened.record("peer", "attempt", name="Bob")
+    assert reopened.peers()[0].attempts == 2
+
+
+def test_inventory_tab_shows_rows(qapp):
+    inv = ConnectionInventory()
+    tab = InventoryTab(inv)
+    assert tab._table.rowCount() == 0
+    inv.record("a", "attempt", name="A", address="host:1")
+    assert tab._table.rowCount() == 1
+    item = tab._table.item(0, 0)
+    assert item is not None and item.text() == "A"
+
+
+def test_inventory_tab_stretches_a_spacer_not_the_last_data_column(qapp):
+    inv = ConnectionInventory()
+    inv.record("a", "attempt", name="A", address="host:1")
+    tab = InventoryTab(inv)
+    spacer = tab._table.columnCount() - 1
+    assert spacer == len(InventoryTab._COLUMNS)  # one extra column on the right
+    header_item = tab._table.horizontalHeaderItem(spacer)
+    assert header_item is not None and header_item.text() == ""
+    assert tab._table.item(0, spacer) is None  # never populated
+    assert tab._table.horizontalHeader().stretchLastSection()
+
+
+def test_inventory_tab_action_button_passes_selected_key(qapp):
+    inv = ConnectionInventory()
+    inv.record("client-42", "connected", name="Bob")
+    acted = []
+    tab = InventoryTab(inv, "Revoke", acted.append)
+    button = tab._action_button
+    assert button is not None
+    # No selection yet -> button disabled and does nothing useful.
+    assert not button.isEnabled()
+    tab._table.selectRow(0)
+    assert button.isEnabled()
+    button.click()
+    assert acted == ["client-42"]
+
+
+def test_server_populates_inventory_via_peer_events(qapp, credentials, tmp_path):
+    server = make_server(credentials, tmp_path, approve=lambda *_: True)
+    inv = ConnectionInventory()
+    server.peerEvent.connect(
+        lambda e: inv.record(
+            e["key"], e["event"], name=e.get("name", ""), address=e.get("address", "")
+        )
+    )
+    client = make_client(tmp_path)
+    connected = []
+    client.connected.connect(connected.append)
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        pump(qapp, lambda: connected)
+        peers = inv.peers()
+        assert len(peers) == 1
+        assert peers[0].name == "test-client"
+        assert peers[0].attempts == 1
+        assert "connected" in peers[0].state  # "connected (paired)"
+    finally:
+        client.close()
+        server.close()

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/tests/test_modal_loop.py

@@ -7,7 +7,13 @@ 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
+from remotedesktop.modal_loop import (
+    WM_CAPTURECHANGED,
+    WM_ENTERSIZEMOVE,
+    WM_EXITSIZEMOVE,
+    WM_NCLBUTTONDOWN,
+    ModalLoopPump,
+)
 
 
 class FakeTimers:
@@ -57,6 +63,45 @@ def test_other_messages_and_event_types_are_ignored():
     assert timers.calls == []
 
 
+def test_click_and_hold_without_drag_is_pumped():
+    # A press-and-hold on the title bar blocks in DefWindowProc's click
+    # tracking without ever sending WM_ENTERSIZEMOVE; the pump must arm on
+    # the press itself and disarm when the tracking loop releases capture.
+    timers = FakeTimers()
+    pump = ModalLoopPump(pump=lambda: None, timers=timers)
+    press = native_message(WM_NCLBUTTONDOWN)
+    release = native_message(WM_CAPTURECHANGED)
+    pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(press))
+    assert timers.calls == [("start", 0xBEEF)]
+    pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(release))
+    assert timers.calls == [("start", 0xBEEF), ("stop", 0xBEEF)]
+
+
+def test_press_followed_by_real_drag_keeps_one_timer():
+    # NCLBUTTONDOWN then ENTERSIZEMOVE (the hold turned into a drag) must not
+    # restart the timer, and either end message stops it exactly once.
+    timers = FakeTimers()
+    pump = ModalLoopPump(pump=lambda: None, timers=timers)
+    for message_id in (WM_NCLBUTTONDOWN, WM_ENTERSIZEMOVE):
+        msg = native_message(message_id)
+        pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(msg))
+    assert timers.calls == [("start", 0xBEEF)]
+    for message_id in (WM_CAPTURECHANGED, WM_EXITSIZEMOVE):
+        msg = native_message(message_id)
+        pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(msg))
+    assert timers.calls == [("start", 0xBEEF), ("stop", 0xBEEF)]
+
+
+def test_capture_change_without_press_is_ignored():
+    # Qt widgets take and release mouse capture during ordinary client-area
+    # clicks; a WM_CAPTURECHANGED with no pump running must do nothing.
+    timers = FakeTimers()
+    pump = ModalLoopPump(pump=lambda: None, timers=timers)
+    msg = native_message(WM_CAPTURECHANGED)
+    pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(msg))
+    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())

{remotedesktop-0.12.0 → remotedesktop-0.13.0}/tests/test_performance.py

@@ -356,14 +356,15 @@ def test_rtt_lines_are_named_for_the_side_that_pings(qapp):
     client_tab = PerformanceTab(monitor, local="client", remote="server")
     server_tab = PerformanceTab(monitor, local="server", remote="client")
     # This side's own measurement (rtt_ms) is listed first; the same physical
-    # measurement carries the same name in both apps.
+    # measurement carries the same name in both apps, and each label spells
+    # out the full loop so it can't be read as a one-way leg.
     assert [label for label, _c, series in client_tab.ping_graph._series] == [
-        "client → server",
-        "server → client",
+        "client → server → client",
+        "server → client → server",
     ]
     assert [label for label, _c, series in server_tab.ping_graph._series] == [
-        "server → client",
-        "client → server",
+        "server → client → server",
+        "client → server → client",
     ]