remotedesktop 0.17.0__tar.gz → 0.18.0__tar.gz

{remotedesktop-0.17.0 → remotedesktop-0.18.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` 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.
+- **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). The caption buttons (min/max/close) are the exception — their tracking loop dispatches only mouse messages, so no timer can pump inside it; the pump instead performs those via its `caption_action` callback on press and consumes the message (nativeEvent must return True when `handle_native_event` does), so DefWindowProc's button tracking never starts. 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.17.0 → remotedesktop-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.17.0
+Version: 0.18.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.17.0 → remotedesktop-0.18.0}/src/remotedesktop/__init__.py

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

{remotedesktop-0.17.0 → remotedesktop-0.18.0}/src/remotedesktop/modal_loop.py

@@ -17,9 +17,18 @@ 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.
 
+The caption buttons (minimize/maximize/close) are the exception: their
+tracking loop dispatches only mouse messages, so no timer — and therefore
+no pump — can run inside it, and a remote click on the server's own
+minimize button deadlocked just like the title-bar drag once did. Those
+presses are instead handled here directly (`caption_action` callback) and
+the message is consumed, so DefWindowProc's button tracking never starts:
+the action happens on press, for local and remote clicks alike.
+
 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.
+`handle_native_event` and consume the message when it returns True; the
+pump is inert off Windows. Tests inject a fake `timers` backend so no
+native timer is ever created.
 """
 
 import ctypes
@@ -33,9 +42,15 @@ from PySide6.QtCore import QCoreApplication, QEventLoop
 _log = logging.getLogger("remotedesktop.modal_loop")
 
 WM_NCLBUTTONDOWN = 0x00A1
+WM_NCLBUTTONUP = 0x00A2
 WM_CAPTURECHANGED = 0x0215
 WM_ENTERSIZEMOVE = 0x0231
 WM_EXITSIZEMOVE = 0x0232
+# WM_NCLBUTTONDOWN/-UP hit-test codes for the caption buttons.
+HTMINBUTTON = 8
+HTMAXBUTTON = 9
+HTCLOSE = 20
+_CAPTION_BUTTONS = (HTMINBUTTON, HTMAXBUTTON, HTCLOSE)
 _TIMER_ID = 0x5244  # arbitrary but stable; scoped to the window's hwnd
 _TIMER_INTERVAL_MS = 15  # comfortably under the 33 ms capture tick
 
@@ -65,21 +80,49 @@ class _NativeTimers:
 
 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:
+    in the modal move/size loop, and short-circuits caption-button clicks
+    (whose tracking loop the timer cannot penetrate) to `caption_action`."""
+
+    def __init__(
+        self,
+        *,
+        pump: Callable[[], None] | None = None,
+        caption_action: Callable[[int], None] | None = None,
+        timers=None,
+    ) -> None:
         self._pump = pump if pump is not None else _pump_qt
+        self._caption_action = caption_action
         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."""
+    def handle_native_event(self, event_type, message) -> bool:
+        """Call from QWidget.nativeEvent with its arguments verbatim.
+
+        Returns True when the message was handled here and must be consumed
+        (returned True from nativeEvent) instead of reaching DefWindowProc.
+        """
         if self._timers is None or bytes(event_type) != b"windows_generic_MSG":
-            return
+            return False
         msg = wintypes.MSG.from_address(int(message))
+        # Minimize/maximize/close presses must never reach DefWindowProc:
+        # its caption-button tracking loop dispatches only mouse messages,
+        # so no timer can pump Qt inside it, and a remote press deadlocks
+        # exactly like the title-bar drag once did. Perform the action on
+        # press and swallow the message (the matching -UP too).
+        if (
+            self._caption_action is not None
+            and msg.message in (WM_NCLBUTTONDOWN, WM_NCLBUTTONUP)
+            and msg.wParam in _CAPTION_BUTTONS
+        ):
+            if msg.message == WM_NCLBUTTONDOWN:
+                _log.debug(
+                    "Caption button %d pressed — handled without native tracking", msg.wParam
+                )
+                self._caption_action(int(msg.wParam))
+            return True
         # 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
@@ -90,6 +133,7 @@ class ModalLoopPump:
             self._enter(msg.hWnd or 0)
         elif msg.message in (WM_CAPTURECHANGED, WM_EXITSIZEMOVE):
             self._exit()
+        return False
 
     def _enter(self, hwnd: int) -> None:
         if self._hwnd == hwnd:  # NCLBUTTONDOWN then ENTERSIZEMOVE: already armed

{remotedesktop-0.17.0 → remotedesktop-0.18.0}/src/remotedesktop/server.py

@@ -7,7 +7,7 @@ import sqlite3
 import sys
 import time
 
-from PySide6.QtCore import QProcess, Qt
+from PySide6.QtCore import QProcess, Qt, QTimer
 from PySide6.QtGui import QCloseEvent, QShowEvent
 from PySide6.QtWidgets import (
     QAbstractItemView,
@@ -37,7 +37,7 @@ from remotedesktop.discovery import (
 )
 from remotedesktop.inventory import ConnectionInventory, InventoryTab
 from remotedesktop.logs import PeerLogDialog, read_log_tail
-from remotedesktop.modal_loop import ModalLoopPump
+from remotedesktop.modal_loop import HTCLOSE, HTMAXBUTTON, HTMINBUTTON, ModalLoopPump
 from remotedesktop.performance import PerformanceMonitor, PerformanceTab, format_ms, format_rate
 from remotedesktop.preferences import PreferencesTab, load_performance_window_seconds
 from remotedesktop.sharing import ShareServer
@@ -167,7 +167,9 @@ class ServerWindow(QMainWindow):
         # 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()
+        # Caption-button presses (minimize/maximize/close) are handled by
+        # the pump directly — their native tracking loop cannot be pumped.
+        self._modal_pump = ModalLoopPump(caption_action=self._on_caption_button)
         self.restart_button = QPushButton("Restart server")
         self.restart_button.setToolTip(
             "Relaunch this app (e.g. after updating the software). It can be "
@@ -339,8 +341,22 @@ class ServerWindow(QMainWindow):
         title = f'Log from client "{client_name}"' if client_name else "Log from client"
         PeerLogDialog(title, text, self).show()
 
+    def _on_caption_button(self, hit_code: int) -> None:
+        # Deferred: the action (especially close) must not run inside the
+        # native message handler that reported the press.
+        if hit_code == HTMINBUTTON:
+            action = self.showMinimized
+        elif hit_code == HTMAXBUTTON:
+            action = self.showNormal if self.isMaximized() else self.showMaximized
+        elif hit_code == HTCLOSE:
+            action = self.close
+        else:
+            return
+        QTimer.singleShot(0, action)
+
     def nativeEvent(self, event_type, message):
-        self._modal_pump.handle_native_event(event_type, message)
+        if self._modal_pump.handle_native_event(event_type, message):
+            return True, 0
         return super().nativeEvent(event_type, message)
 
     def _ask_approval(self, client_id: str, client_name: str) -> bool:

{remotedesktop-0.17.0 → remotedesktop-0.18.0}/tests/test_modal_loop.py

@@ -8,10 +8,13 @@ import ctypes
 from ctypes import wintypes
 
 from remotedesktop.modal_loop import (
+    HTMAXBUTTON,
+    HTMINBUTTON,
     WM_CAPTURECHANGED,
     WM_ENTERSIZEMOVE,
     WM_EXITSIZEMOVE,
     WM_NCLBUTTONDOWN,
+    WM_NCLBUTTONUP,
     ModalLoopPump,
 )
 
@@ -27,14 +30,19 @@ class FakeTimers:
         self.calls.append(("stop", hwnd))
 
 
-def native_message(message_id, hwnd=0xBEEF):
+def native_message(message_id, hwnd=0xBEEF, wparam=0):
     """A wintypes.MSG whose address stands in for Qt's nativeEvent pointer."""
     msg = wintypes.MSG()
     msg.hWnd = hwnd
     msg.message = message_id
+    msg.wParam = wparam
     return msg
 
 
+def send(pump, msg):
+    return pump.handle_native_event(b"windows_generic_MSG", ctypes.addressof(msg))
+
+
 def test_enter_and_exit_bound_the_timer():
     timers = FakeTimers()
     pump = ModalLoopPump(pump=lambda: None, timers=timers)
@@ -102,6 +110,42 @@ def test_capture_change_without_press_is_ignored():
     assert timers.calls == []
 
 
+def test_caption_button_press_is_consumed_and_dispatched():
+    # Min/max/close tracking cannot be pumped (it dispatches only mouse
+    # messages), so the press must be handled directly and swallowed —
+    # the native tracking loop must never start.
+    timers = FakeTimers()
+    actions = []
+    pump = ModalLoopPump(pump=lambda: None, caption_action=actions.append, timers=timers)
+    assert send(pump, native_message(WM_NCLBUTTONDOWN, wparam=HTMINBUTTON)) is True
+    assert actions == [HTMINBUTTON]
+    assert timers.calls == []  # no tracking, so nothing to pump
+    assert send(pump, native_message(WM_NCLBUTTONUP, wparam=HTMINBUTTON)) is True
+    assert actions == [HTMINBUTTON]  # the release performs nothing extra
+    assert send(pump, native_message(WM_NCLBUTTONDOWN, wparam=HTMAXBUTTON)) is True
+    assert actions == [HTMINBUTTON, HTMAXBUTTON]
+
+
+def test_title_bar_press_still_arms_the_pump_not_the_caption_action():
+    timers = FakeTimers()
+    actions = []
+    pump = ModalLoopPump(pump=lambda: None, caption_action=actions.append, timers=timers)
+    # HTCAPTION (2): a title-bar press is not a caption button — the pump
+    # arms as before and the message passes through to DefWindowProc.
+    assert send(pump, native_message(WM_NCLBUTTONDOWN, wparam=2)) is False
+    assert actions == []
+    assert timers.calls == [("start", 0xBEEF)]
+
+
+def test_caption_buttons_pass_through_without_a_caption_action():
+    timers = FakeTimers()
+    pump = ModalLoopPump(pump=lambda: None, timers=timers)
+    # No handler installed: behave exactly as before (arm the pump, don't
+    # consume) so the buttons keep working for pump users without one.
+    assert send(pump, native_message(WM_NCLBUTTONDOWN, wparam=HTMINBUTTON)) is False
+    assert timers.calls == [("start", 0xBEEF)]
+
+
 def test_timer_callback_pumps_but_never_reentrantly():
     pumped = []
     pump = ModalLoopPump(pump=lambda: pumped.append(True) or pump._on_timer(), timers=FakeTimers())

{remotedesktop-0.17.0 → remotedesktop-0.18.0}/tests/test_server_window.py

@@ -75,6 +75,33 @@ def test_native_size_move_messages_drive_the_modal_pump(qapp, credentials, tmp_p
         window.close()
 
 
+def test_caption_button_press_minimizes_without_native_tracking(qapp, credentials, tmp_path):
+    import ctypes
+    from ctypes import wintypes
+
+    from shiboken6 import VoidPtr
+
+    from remotedesktop.modal_loop import HTMINBUTTON, WM_NCLBUTTONDOWN, ModalLoopPump
+    from test_modal_loop import FakeTimers
+
+    window = make_window(credentials, tmp_path)
+    try:
+        timers = FakeTimers()
+        window._modal_pump = ModalLoopPump(
+            pump=lambda: None, caption_action=window._on_caption_button, timers=timers
+        )
+        msg = wintypes.MSG()
+        msg.hWnd, msg.message, msg.wParam = 0xBEEF, WM_NCLBUTTONDOWN, HTMINBUTTON
+        result = window.nativeEvent(b"windows_generic_MSG", VoidPtr(ctypes.addressof(msg)))
+        assert result[0] is True  # consumed: DefWindowProc's tracking never starts
+        assert timers.calls == []  # and the pump never needed to arm
+        for _ in range(5):
+            qapp.processEvents()  # the deferred action runs on the event loop
+        assert window.isMinimized()
+    finally:
+        window.close()
+
+
 def test_window_listens_and_is_discoverable(qapp, credentials, tmp_path):
     window = make_window(credentials, tmp_path)
     try:

{remotedesktop-0.17.0 → remotedesktop-0.18.0}/tools/make_demo_gifs.py

@@ -38,8 +38,9 @@ from remotedesktop import client as client_module
 
 SCREEN_W, SCREEN_H = 1280, 800
 GIF_WIDTH = 900
-CAPTURE_INTERVAL = 0.15  # seconds per frame, also the GIF frame duration
-TOTAL_SECONDS = 11.0
+CAPTURE_INTERVAL = 0.18  # seconds per frame, also the GIF frame duration
+TOTAL_SECONDS = 26.5
+_GIF_COLORS = 96  # adaptive-palette size; the UI + fake desktop quantize well
 _CODE_LINES = [
     "def changed_bands(previous, current):",
     '    """Bands of `current` that differ from `previous`."""',
@@ -190,7 +191,9 @@ def to_gif_frame(window) -> Image.Image:
 
 
 def save_gif(frames: list[Image.Image], path: Path) -> None:
-    quantized = [f.convert("P", palette=Image.Palette.ADAPTIVE, colors=128) for f in frames]
+    quantized = [
+        f.convert("P", palette=Image.Palette.ADAPTIVE, colors=_GIF_COLORS) for f in frames
+    ]
     quantized[0].save(
         path,
         save_all=True,
@@ -251,13 +254,16 @@ def main() -> None:
         server_tabs = server_window.centralWidget()
         assert isinstance(client_tabs, QTabWidget) and isinstance(server_tabs, QTabWidget)
 
+        # The live remote-screen section is the product's whole point, so it
+        # gets the lion's share of the runtime (~19 s of streaming before
+        # the brief Performance-tab detour, plus the closing shot).
         script = [
             (0.8, lambda: client_window.discovery_panel.refresh()),
             (2.0, lambda: client_window.discovery_panel.serverActivated.emit(info)),
-            (6.8, lambda: client_tabs.setCurrentIndex(tab_index(client_tabs, "Performance"))),
-            (7.2, lambda: server_tabs.setCurrentIndex(tab_index(server_tabs, "Performance"))),
-            (9.2, lambda: client_tabs.setCurrentIndex(tab_index(client_tabs, "Remote Screen"))),
-            (9.6, lambda: server_tabs.setCurrentIndex(tab_index(server_tabs, "Status"))),
+            (21.2, lambda: client_tabs.setCurrentIndex(tab_index(client_tabs, "Performance"))),
+            (21.6, lambda: server_tabs.setCurrentIndex(tab_index(server_tabs, "Performance"))),
+            (23.6, lambda: client_tabs.setCurrentIndex(tab_index(client_tabs, "Remote Screen"))),
+            (24.0, lambda: server_tabs.setCurrentIndex(tab_index(server_tabs, "Status"))),
         ]
         client_frames: list[Image.Image] = []
         server_frames: list[Image.Image] = []