remotedesktop 1.5.0__tar.gz → 1.6.0__tar.gz

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/CLAUDE.md

@@ -76,6 +76,7 @@ Managed with `uv` (hatchling build backend, src layout):
 - **Auto-reconnect** (`app.py`): a session that *was connected* and drops retries `client.connect_to` with exponential backoff (base `reconnect_base_seconds=2.0` kwarg — tests inject ~0.05 — doubling to a 30 s cap), driven by a per-session single-shot QTimer. `ShareClient.connectionFailed` exists because **Qt emits `disconnected` only for sockets that reached ConnectedState** — refused/unreachable attempts fire `errorOccurred` with the socket back in UnconnectedState. The active-timer guard dedupes the errorOccurred+disconnected double-fire. Denial cancels until a manual activation; tab close/forget/quit cancel; retries bypass `_connect_session` on purpose (no perf reset, no tab steal, no inventory attempt spam). **Open session tabs persist** (`open_sessions` JSON in Settings, written on connect/rename/close) and are restored + reconnected at startup with `auto_reconnect` pre-armed, so a not-yet-available server is retried on the backoff loop; deliberately closed tabs are not restored. While no session exists, a non-closable "Server" placeholder tab (instructions) sits at index 0 and swaps with the first session's tab.
 - **Menus & shortcuts contract** (`app.py` `_build_menus`, `viewer.py`): File/View/Help menu bar; shortcuts Ctrl+W (close session tab), Ctrl+Q (quit), F5 (rescan), F11 (fullscreen). While a viewer shows a frame it **accepts `ShortcutOverride`** so every key forwards to the remote machine — **F11 is the single reserved local key**. Shortcut actions are also `addAction`-ed on the window so they fire with the menu bar hidden (fullscreen). Keep every menu/action as an attribute — PySide6 gives Python ownership of `addMenu`/`addAction` (and `QAction.menu()`) wrappers, and a GC'd local deletes the C++ object. Fullscreen hides menu/status bars, dock, and tab bar and restores them (including pre-fullscreen dock visibility) on exit; `closeEvent` exits fullscreen before persisting layout. Window geometry AND dock layout persist (`window_state.save_state`/`restore_state`, key `main_window_state`; the dock needs its objectName).
 - **Privacy toggles**: Preferences' "Sync clipboard" checkbox (`clipboard_sync_enabled`, default on) drives `ClipboardSync.enabled` — while off, local copies aren't sent and peer payloads aren't applied. View-only sharing is the "view" mode of the Screen sharing radios (`ShareServer.set_input_allowed` — a server-side drop, no wire change, that releases held input when switched off). Quitting with ≥1 viewer connected asks for confirmation (declining resets `_quitting`); restart shuts sharing down first so it never double-prompts.
+- **Theme preference** (`preferences.py`): a three-radio group in Preferences — follow the Windows light/dark setting (default) / Light / Dark — persisted as `THEME_KEY` (`"system"`/`"light"`/`"dark"`, `load_theme` falls back to system on junk). `apply_theme` drives `QStyleHints.setColorScheme` (`unsetColorScheme` for system, so OS-side switches keep applying); the radios apply live and `MainWindow.__init__` re-applies the persisted choice before building widgets. Tests that set a non-system theme must restore with `apply_theme(THEME_SYSTEM)` — the color scheme is process-global QApplication state.
 - **Two `PerformanceMonitor`s, never one**: `MainWindow.client_performance` (viewing sessions) and `server_performance` (the SharingTab's viewers). `ShareServer.close()` resets its monitor, so sharing a monitor across roles would wipe the other role's graphs. The Performance tab has "Client (viewer)"/"Server (sharing)" sub-tabs (`MainWindow.performance_pages`) — but only for roles that can produce data: the client sub-tab exists only with the viewer role, the server one only while actually serving (`_update_performance_tabs`, driven from the viewer toggle and `sharingChanged`; both off shows an enable-a-role hint). `PreferencesTab` takes the list of monitors and applies the history-window setting to all.
 - **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. **Scan robustness**: probes are re-sent every `_PROBE_INTERVAL` (0.3 s) for the whole scan window (a lost broadcast only delays discovery), ICMP port-unreachable resets never abort the scan (Windows `SIO_UDP_CONNRESET` ioctl + `ConnectionResetError` → continue), and the panel passes `client._broadcast_hosts()` — 255.255.255.255 plus every up non-loopback interface's directed broadcast, because Windows routes the limited broadcast out only one interface (VPN/virtual adapters made scans come up empty). A sharing instance runs a `DiscoveryResponder` thread while sharing is enabled; the `DiscoveryPanel` (dock in `MainWindow`) calls the blocking `discover_servers()` on a worker thread and delivers results to the GUI via a queued signal. With `auto_scan=True` (the app; tests default to False and never broadcast) it scans **once at startup only** — further scans happen only on manual Refresh/F5 (deliberately no periodic background scanning; the user asked for this), guarded against overlapping scans and preserving the selection across repopulation; it also has a Connect button, a right-click Connect menu, and an empty-state hint. The "(this computer)" entry is not connectable (Connect disabled, activation swallowed, plus a `MainWindow._on_server_activated` guard). `DEFAULT_CONNECT_PORT` is 48654. An instance that shares and scans discovers itself — `DiscoveryPanel`'s `is_self=` callable labels that entry "(this computer)" (never hidden).
 - 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.
@@ -87,6 +88,7 @@ Managed with `uv` (hatchling build backend, src layout):
 - **Revoking access**: `InventoryTab` takes an optional `(action_label, action_callback)`; each row gets its own button labeled `action_label` (in the trailing stretch column) whose callback receives that row's peer key. "Client history" wires "Revoke" → `SharingTab.revoke_client(client_id)` (via `ShareServer.revoke_client` while sharing — removes the token via `PairedClients.revoke`, disconnects any live stream with a `denied: access revoked`, and `_drop` emits a "revoked" peer event; a `_revoked` set distinguishes it from a plain disconnect — or directly via `PairedClients.revoke` while not sharing). "Server history" wires "Forget" → `KnownServers.forget(key)` + disconnect + `ConnectionInventory.remove(key)`. **Both delete the peer's row from the table and the DB outright** (`MainWindow._record_server_peer` turns a "revoked" event into a `remove`); a rescan or new connection attempt records the peer afresh. After either, the next connection needs a fresh approval. The roles use *separate tables* (`server_peers` / `client_peers`, selected via the `table=` arg) so they don't commingle; `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.
+- **Remote cursor shape** (`cursor_shape.py`): the captured frame never contains the mouse pointer (DXGI duplication and BitBlt both exclude it), so the client mirrors the server's cursor on its *local* cursor instead. `ShareServer` takes an opt-in `cursor_probe=` callable (the `clipboard=` pattern — only the GUI passes one, `SharingTab` wires `current_cursor_shape`: GetCursorInfo compared against the shared standard IDC_* handles; custom cursors → "arrow", not showing → "hidden"). The probe is polled each broadcast tick and `{"type": "cursor", "shape": ...}` is sent on change only, plus once to each just-admitted stream. `ShareClient.cursorShapeChanged` → `ViewerWidget.set_remote_cursor` maps names to Qt cursors (unknown names → arrow); `clear()` unsets the cursor. Peers without the feature never send / silently ignore the message.
 - **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 a sharing instance this deadlocked when a *remote* click grabbed the window's own title bar (the mouse-up sat unread on the socket). `MainWindow.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 app passes `logs.read_log_tail("remotedesktop")`, capped at `logs.TAIL_BYTES`); a missing provider/file answers with a placeholder rather than hanging the requester. The Connection log group on the Connections tab has both buttons — "Get server log" asks the server of the current session tab, "Get client log" asks the most recently admitted viewer; the reply opens a `logs.PeerLogDialog`.
 - **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.

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 1.5.0
+Version: 1.6.0
 Summary: Remote desktop app for Windows computers on the same LAN, with autodiscovery. View other computers and optionally share this one — screen, keyboard, mouse, and clipboard, without RDP or Microsoft authentication.
 Project-URL: Homepage, https://github.com/jamesabel/remotedesktop
 Project-URL: Repository, https://github.com/jamesabel/remotedesktop

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/src/remotedesktop/__init__.py

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

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/src/remotedesktop/app.py

@@ -52,8 +52,10 @@ from remotedesktop.modal_loop import HTCLOSE, HTMAXBUTTON, HTMINBUTTON, ModalLoo
 from remotedesktop.performance import PerformanceMonitor, PerformanceTab
 from remotedesktop.preferences import (
     PreferencesTab,
+    apply_theme,
     load_clipboard_sync_enabled,
     load_performance_window_seconds,
+    load_theme,
     load_viewer_enabled,
 )
 from remotedesktop.server import SharingTab, ViewersTable
@@ -136,6 +138,9 @@ class MainWindow(QMainWindow):
         # The viewer (client) role is opt-out: a dedicated server turns it
         # off and loses the client-side UI (Server tab, discovery, history).
         self._viewer_enabled = load_viewer_enabled(self._settings)
+        # Restore the persisted theme before any widgets are built, so the
+        # window never flashes in the wrong scheme.
+        apply_theme(load_theme(self._settings))
         # One monitor per role: ShareServer.close() resets its monitor, so
         # toggling sharing must not share a monitor with the viewing sessions
         # (and vice versa for _connect_session's reset).
@@ -996,6 +1001,7 @@ class MainWindow(QMainWindow):
         client.denied.connect(lambda reason, s=session: self._on_denied(s, reason))
         client.disconnected.connect(lambda s=session: self._on_disconnected(s))
         client.frameReceived.connect(lambda image, s=session: self._on_frame(s, image))
+        client.cursorShapeChanged.connect(lambda shape, s=session: s.viewer.set_remote_cursor(shape))
         client.logReceived.connect(lambda text, s=session: self._show_server_log(s.name, text))
         client.connectionFailed.connect(lambda _reason, s=session: self._schedule_reconnect(s))
         self._sessions.append(session)

remotedesktop-1.6.0/src/remotedesktop/cursor_shape.py

@@ -0,0 +1,89 @@
+"""Identify the shape of the mouse cursor currently shown (server side).
+
+The captured frame deliberately contains no mouse pointer (both DXGI desktop
+duplication and GDI BitBlt exclude it), so what the viewer's user sees over
+the remote screen is their own local cursor. This module lets the server
+report what shape that cursor should be — an I-beam over text, the resize
+arrows over a window edge, and so on: GetCursorInfo returns the current
+cursor handle, and the standard cursors are shared handles identical to what
+LoadCursor(NULL, IDC_*) returns, so a plain handle comparison identifies
+them. Custom application cursors fall back to "arrow"; a cursor that is not
+showing at all reports "hidden".
+
+On non-Windows platforms `current_cursor_shape()` returns None (the app
+targets Windows).
+"""
+
+import ctypes
+import sys
+from ctypes import wintypes
+
+_IS_WINDOWS = sys.platform == "win32"
+
+_CURSOR_SHOWING = 0x1
+
+# Standard cursor resource ids (winuser.h IDC_*) -> wire shape names. These
+# names are the protocol vocabulary: ViewerWidget maps them to Qt cursors.
+_IDC_SHAPES = {
+    32512: "arrow",  # IDC_ARROW
+    32513: "ibeam",  # IDC_IBEAM
+    32514: "wait",  # IDC_WAIT
+    32515: "cross",  # IDC_CROSS
+    32516: "uparrow",  # IDC_UPARROW
+    32642: "size_nwse",  # IDC_SIZENWSE (diagonal resize ↘)
+    32643: "size_nesw",  # IDC_SIZENESW (diagonal resize ↗)
+    32644: "size_we",  # IDC_SIZEWE (horizontal resize)
+    32645: "size_ns",  # IDC_SIZENS (vertical resize)
+    32646: "size_all",  # IDC_SIZEALL
+    32648: "no",  # IDC_NO
+    32649: "hand",  # IDC_HAND
+    32650: "appstarting",  # IDC_APPSTARTING
+    32651: "help",  # IDC_HELP
+}
+
+SHAPE_NAMES = frozenset(_IDC_SHAPES.values()) | {"hidden"}
+
+
+if _IS_WINDOWS:
+
+    class _CURSORINFO(ctypes.Structure):
+        _fields_ = [
+            ("cbSize", wintypes.DWORD),
+            ("flags", wintypes.DWORD),
+            ("hCursor", ctypes.c_void_p),
+            ("ptScreenPos", wintypes.POINT),
+        ]
+
+
+_handle_shapes: dict[int, str] | None = None
+
+
+def _standard_handles() -> dict[int, str]:
+    """HCURSOR -> shape name for every standard cursor (loaded once; the
+    handles are shared and stable for the lifetime of the process)."""
+    global _handle_shapes
+    if _handle_shapes is None:
+        user32 = ctypes.windll.user32
+        user32.LoadCursorW.restype = ctypes.c_void_p
+        user32.LoadCursorW.argtypes = (ctypes.c_void_p, ctypes.c_void_p)
+        _handle_shapes = {}
+        for resource, name in _IDC_SHAPES.items():
+            # MAKEINTRESOURCE: the id passed as the pointer-sized name arg.
+            handle = user32.LoadCursorW(None, ctypes.c_void_p(resource))
+            if handle:
+                _handle_shapes[handle] = name
+    return _handle_shapes
+
+
+def current_cursor_shape() -> str | None:
+    """The current cursor's shape name, "hidden" while no cursor is showing,
+    or None when it cannot be determined (non-Windows, API failure)."""
+    if not _IS_WINDOWS:
+        return None
+    info = _CURSORINFO()
+    info.cbSize = ctypes.sizeof(_CURSORINFO)
+    if not ctypes.windll.user32.GetCursorInfo(ctypes.byref(info)):
+        return None
+    if not info.flags & _CURSOR_SHOWING:
+        return "hidden"
+    return _standard_handles().get(info.hCursor or 0, "arrow")

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/src/remotedesktop/preferences.py

@@ -1,15 +1,18 @@
 """The Preferences tab: user-adjustable settings.
 
-Performance-history length and the clipboard-sync opt-out persist in
-`Settings` (the shared SQLite settings table, injectable in tests like every
-other store); the start-at-login option reads and writes the Windows Run
-registry key via `Autostart`. The clipboard toggle applies live to the
-shared `ClipboardSync` (the `clipboard=` opt-in collaborator pattern).
+Performance-history length, the clipboard-sync opt-out, and the theme choice
+persist in `Settings` (the shared SQLite settings table, injectable in tests
+like every other store); the start-at-login option reads and writes the
+Windows Run registry key via `Autostart`. The clipboard toggle applies live
+to the shared `ClipboardSync` (the `clipboard=` opt-in collaborator
+pattern). The theme radios (follow-OS / light / dark) apply live via
+`apply_theme`; `MainWindow` re-applies the persisted choice at startup.
 """
 
 from collections.abc import Sequence
 
-from PySide6.QtCore import Signal
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QGuiApplication
 from PySide6.QtWidgets import (
     QCheckBox,
     QFormLayout,
@@ -34,12 +37,37 @@ PERFORMANCE_WINDOW_KEY = "performance_window_seconds"
 DEFAULT_PERFORMANCE_WINDOW_SECONDS = 120
 CLIPBOARD_SYNC_KEY = "clipboard_sync_enabled"
 VIEWER_KEY = "viewer_enabled"
+THEME_KEY = "theme"
+THEME_SYSTEM = "system"  # follow the OS light/dark setting
+THEME_LIGHT = "light"
+THEME_DARK = "dark"
+_THEMES = (THEME_SYSTEM, THEME_LIGHT, THEME_DARK)
 
 
 def load_clipboard_sync_enabled(settings: Settings) -> bool:
     return settings.get(CLIPBOARD_SYNC_KEY, "1") != "0"
 
 
+def load_theme(settings: Settings) -> str:
+    value = settings.get(THEME_KEY, THEME_SYSTEM)
+    return value if value in _THEMES else THEME_SYSTEM
+
+
+def apply_theme(theme: str) -> None:
+    """Apply a theme app-wide; Qt's windows11 style restyles live.
+
+    THEME_SYSTEM unsets the override so the app follows the OS light/dark
+    setting again (including future OS-side switches).
+    """
+    hints = QGuiApplication.styleHints()
+    if theme == THEME_LIGHT:
+        hints.setColorScheme(Qt.ColorScheme.Light)
+    elif theme == THEME_DARK:
+        hints.setColorScheme(Qt.ColorScheme.Dark)
+    else:
+        hints.unsetColorScheme()
+
+
 def load_viewer_enabled(settings: Settings) -> bool:
     return settings.get(VIEWER_KEY, "1") != "0"
 
@@ -120,6 +148,25 @@ class PreferencesTab(QWidget):
         sharing_layout.setContentsMargins(0, 0, 0, 0)
         for radio in self._mode_radios.values():
             sharing_layout.addWidget(radio)
+        # Theme: an explicit light/dark override, or follow the OS setting.
+        self.theme_system_radio = QRadioButton("Follow the Windows light/dark setting")
+        self.theme_light_radio = QRadioButton("Light")
+        self.theme_dark_radio = QRadioButton("Dark")
+        self._theme_radios = {
+            THEME_SYSTEM: self.theme_system_radio,
+            THEME_LIGHT: self.theme_light_radio,
+            THEME_DARK: self.theme_dark_radio,
+        }
+        self._theme_radios[load_theme(settings)].setChecked(True)
+        for theme, radio in self._theme_radios.items():
+            radio.toggled.connect(
+                lambda checked, t=theme: checked and self._on_theme_changed(t)
+            )
+        theme_box = QWidget()
+        theme_layout = QVBoxLayout(theme_box)
+        theme_layout.setContentsMargins(0, 0, 0, 0)
+        for radio in self._theme_radios.values():
+            theme_layout.addWidget(radio)
         self.restart_button = QPushButton("Restart app")
         self.restart_button.setToolTip(
             "Relaunch this app (e.g. after updating the software). It can be "
@@ -135,6 +182,7 @@ class PreferencesTab(QWidget):
         layout = QFormLayout(self)
         layout.addRow("Client (viewer)", self.viewer_checkbox)
         layout.addRow("Server (sharing)", sharing_box)
+        layout.addRow("Theme", theme_box)
         layout.addRow("Performance history", self.history_minutes)
         layout.addRow(self.clipboard_checkbox)
         layout.addRow(self.autostart_checkbox)
@@ -163,6 +211,17 @@ class PreferencesTab(QWidget):
         )
         self.viewerModeChanged.emit(checked)
 
+    def _on_theme_changed(self, theme: str) -> None:
+        self._settings.set(THEME_KEY, theme)
+        apply_theme(theme)
+        self.statusMessage.emit(
+            {
+                THEME_SYSTEM: "Theme follows the Windows light/dark setting",
+                THEME_LIGHT: "Theme set to light",
+                THEME_DARK: "Theme set to dark",
+            }[theme]
+        )
+
     def _on_clipboard_toggled(self, checked: bool) -> None:
         self._settings.set(CLIPBOARD_SYNC_KEY, "1" if checked else "0")
         if self._clipboard is not None:

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/src/remotedesktop/server.py

@@ -28,6 +28,7 @@ from PySide6.QtWidgets import (
 
 from remotedesktop import __version__, compat, tls
 from remotedesktop.config import PairedClients, Settings, default_config_dir
+from remotedesktop.cursor_shape import current_cursor_shape
 from remotedesktop.discovery import (
     DEFAULT_CONNECT_PORT,
     DISCOVERY_PORT,
@@ -274,6 +275,7 @@ class SharingTab(QWidget):
             credentials=self._credentials,
             paired=self._paired,
             clipboard=self._clipboard,
+            cursor_probe=current_cursor_shape,
             performance=self._performance,
             log_provider=lambda: read_log_tail("remotedesktop"),
             input_allowed=self._settings.get(ALLOW_INPUT_KEY, "1") != "0",

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/src/remotedesktop/sharing.py

@@ -116,6 +116,7 @@ class ShareServer(QObject):
         fps: int = DEFAULT_FPS,
         injector: InputInjector | None = None,
         clipboard=None,
+        cursor_probe: Callable[[], str | None] | None = None,
         performance: PerformanceMonitor | None = None,
         log_provider: Callable[[], str] | None = None,
         input_allowed: bool = True,
@@ -132,6 +133,10 @@ class ShareServer(QObject):
         self._clipboard = clipboard
         if clipboard is not None:
             clipboard.changed.connect(self._broadcast_clipboard)
+        # Opt-in like clipboard: only the GUI passes a probe, so plain
+        # sharing tests never poll (or depend on) the host's real cursor.
+        self._cursor_probe = cursor_probe
+        self._cursor_shape: str | None = None  # last shape sent to viewers
         self._streams: list[MessageStream] = []
         self._all_streams: set[MessageStream] = set()
         self._controllers: set[MessageStream] = set()
@@ -237,6 +242,7 @@ class ShareServer(QObject):
         self._needs_keyframe.clear()
         self._viewer_info.clear()
         self._previous_frame = None
+        self._cursor_shape = None
         if self._dxgi is not None:
             self._dxgi.close()
             self._dxgi = None
@@ -468,6 +474,7 @@ class ShareServer(QObject):
         stream.send_json(welcome)
         self._needs_keyframe.add(stream)  # its first frame must be a full one
         self._streams.append(stream)
+        self._broadcast_cursor(new_stream=stream)  # start with the right cursor
         if self._performance is not None:
             self._performance.add_stream(stream)
         self.clientCountChanged.emit(len(self._streams))
@@ -637,9 +644,30 @@ class ShareServer(QObject):
             _log.info("DXGI capture unavailable — using grabWindow until it recovers")
         return image
 
+    def _broadcast_cursor(self, new_stream: MessageStream | None = None) -> None:
+        """Tell viewers what shape their local cursor should mirror: everyone
+        when the server's cursor changed shape, plus a just-admitted stream
+        that still needs the current shape.
+
+        The message is tiny and shape changes are rare next to frames, so it
+        is sent even to backlogged streams (like clipboard updates).
+        """
+        if self._cursor_probe is None:
+            return
+        shape = self._cursor_probe()
+        if shape is None:
+            return
+        if shape != self._cursor_shape:
+            self._cursor_shape = shape
+            for stream in self._streams:
+                stream.send_json({"type": "cursor", "shape": shape})
+        elif new_stream is not None:
+            new_stream.send_json({"type": "cursor", "shape": shape})
+
     def _broadcast_frame(self) -> None:
         if not self._streams:
             return
+        self._broadcast_cursor()  # polled at the frame rate, sent on change
         image = self._capture()
         if image is None:
             self.status.emit("Screen capture failed (null image)")
@@ -711,6 +739,10 @@ class ShareClient(QObject):
     # emits it only for sockets that actually reached ConnectedState.
     connectionFailed = Signal(str)
     frameReceived = Signal(QImage)
+    # The server's cursor changed shape (a cursor_shape.py name, e.g.
+    # "size_we"); the viewer mirrors it on the local cursor. Servers without
+    # the feature (pre-1.6) simply never emit it.
+    cursorShapeChanged = Signal(str)
     status = Signal(str)
     logReceived = Signal(str)  # server log text answering request_log
 
@@ -907,6 +939,10 @@ class ShareClient(QObject):
                 if self._clipboard is not None:
                     self.status.emit("Clipboard update received from server")
                     self._clipboard.apply(message)
+            case "cursor":
+                # Too frequent for the status log; unknown names are the
+                # viewer's problem (it falls back to the arrow).
+                self.cursorShapeChanged.emit(str(message.get("shape", "")) or "arrow")
             case "ping" | "pong":
                 if self._performance is not None:
                     self._performance.handle_message(self._stream, message)

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/src/remotedesktop/viewer.py

@@ -9,23 +9,52 @@ forwarded.
 
 from PySide6.QtCore import QEvent, QPointF, QRectF, QSize, Qt, Signal
 from PySide6.QtGui import (
+    QColor,
+    QCursor,
     QFocusEvent,
     QImage,
     QKeyEvent,
     QMouseEvent,
     QPaintEvent,
     QPainter,
+    QPalette,
     QPixmap,
     QWheelEvent,
 )
 from PySide6.QtWidgets import QWidget
 
+# Frame-outline shades: light gray on a dark theme, dark gray on a light one,
+# so the border contrasts with the app background on either side of the edge.
+_BORDER_ON_DARK = QColor(170, 170, 170)
+_BORDER_ON_LIGHT = QColor(110, 110, 110)
+
 _BUTTON_NAMES = {
     Qt.MouseButton.LeftButton: "left",
     Qt.MouseButton.RightButton: "right",
     Qt.MouseButton.MiddleButton: "middle",
 }
 
+# Wire cursor-shape names (cursor_shape.py on the server side) -> the local
+# cursor mirroring the remote one. Names this map doesn't know (a newer
+# server's vocabulary) fall back to the arrow.
+_CURSOR_SHAPES = {
+    "arrow": Qt.CursorShape.ArrowCursor,
+    "ibeam": Qt.CursorShape.IBeamCursor,
+    "wait": Qt.CursorShape.WaitCursor,
+    "cross": Qt.CursorShape.CrossCursor,
+    "uparrow": Qt.CursorShape.UpArrowCursor,
+    "size_nwse": Qt.CursorShape.SizeFDiagCursor,
+    "size_nesw": Qt.CursorShape.SizeBDiagCursor,
+    "size_we": Qt.CursorShape.SizeHorCursor,
+    "size_ns": Qt.CursorShape.SizeVerCursor,
+    "size_all": Qt.CursorShape.SizeAllCursor,
+    "no": Qt.CursorShape.ForbiddenCursor,
+    "hand": Qt.CursorShape.PointingHandCursor,
+    "appstarting": Qt.CursorShape.BusyCursor,
+    "help": Qt.CursorShape.WhatsThisCursor,
+    "hidden": Qt.CursorShape.BlankCursor,
+}
+
 
 class ViewerWidget(QWidget):
     """Displays the remote desktop screen scaled to fit, and forwards mouse and
@@ -101,8 +130,14 @@ class ViewerWidget(QWidget):
         self._message = message
         self._pressed_buttons.clear()
         self._pressed_keys.clear()
+        self.unsetCursor()  # a disconnected viewer shows the normal cursor
         self.update()
 
+    def set_remote_cursor(self, shape: str) -> None:
+        """Mirror the server's cursor shape on the local cursor (the frame
+        itself never contains the pointer — screen capture excludes it)."""
+        self.setCursor(QCursor(_CURSOR_SHAPES.get(shape, Qt.CursorShape.ArrowCursor)))
+
     def _display_rect(self) -> QRectF:
         """Rectangle the frame occupies, centered and aspect-preserved."""
         assert self._frame is not None
@@ -257,3 +292,12 @@ class ViewerWidget(QWidget):
                 )
             self._scaled.setDevicePixelRatio(dpr)
         painter.drawPixmap(rect.topLeft(), self._scaled)
+        # Thin outline marking where the remote screen ends and the app
+        # background begins (they can otherwise blend together).
+        painter.setPen(self._border_color())
+        painter.drawRect(rect.adjusted(0, 0, -1, -1))
+
+    def _border_color(self) -> QColor:
+        """Outline shade for the current theme (follows the window background)."""
+        window = self.palette().color(QPalette.ColorRole.Window)
+        return _BORDER_ON_DARK if window.lightness() < 128 else _BORDER_ON_LIGHT

remotedesktop-1.6.0/tests/test_cursor_shape.py

@@ -0,0 +1,20 @@
+import sys
+
+import pytest
+
+from remotedesktop.cursor_shape import SHAPE_NAMES, current_cursor_shape
+from remotedesktop.viewer import _CURSOR_SHAPES
+
+
+def test_every_wire_name_has_a_client_side_cursor():
+    # The server's vocabulary and the viewer's map must stay in sync, or a
+    # shape would silently degrade to the arrow.
+    assert SHAPE_NAMES <= set(_CURSOR_SHAPES)
+
+
+@pytest.mark.skipif(sys.platform != "win32", reason="Windows cursor API")
+def test_current_cursor_shape_reports_a_known_name():
+    shape = current_cursor_shape()
+    # None only when GetCursorInfo fails (e.g. no interactive desktop).
+    if shape is not None:
+        assert shape in SHAPE_NAMES

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/tests/test_input.py

@@ -238,6 +238,21 @@ def test_release_when_frame_vanished_mid_drag(qapp):
     assert [e["pressed"] for e in events] == [True]
 
 
+def test_viewer_mirrors_remote_cursor_shape(qapp):
+    viewer = ViewerWidget()
+    viewer.set_remote_cursor("size_we")
+    assert viewer.cursor().shape() == Qt.CursorShape.SizeHorCursor
+    viewer.set_remote_cursor("hidden")
+    assert viewer.cursor().shape() == Qt.CursorShape.BlankCursor
+    # A name from a newer server's vocabulary falls back to the arrow.
+    viewer.set_remote_cursor("lasso")
+    assert viewer.cursor().shape() == Qt.CursorShape.ArrowCursor
+    # Disconnecting restores the normal local cursor.
+    viewer.set_remote_cursor("size_ns")
+    viewer.clear()
+    assert viewer.cursor().shape() == Qt.CursorShape.ArrowCursor
+
+
 def test_viewer_paints_message_and_frame(qapp):
     viewer = ViewerWidget()
     viewer.resize(400, 400)

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/tests/test_main_window.py

@@ -60,6 +60,19 @@ def make_share_server(credentials, tmp_path, *, approve=lambda *_: True, db_name
     return server
 
 
+def test_persisted_theme_is_applied_at_startup(qapp, tmp_path):
+    from remotedesktop.preferences import THEME_KEY, THEME_SYSTEM, apply_theme
+
+    Settings(db.connect(tmp_path / "app.db")).set(THEME_KEY, "dark")
+    window = make_window(tmp_path)
+    try:
+        assert qapp.styleHints().colorScheme() == Qt.ColorScheme.Dark
+        assert window.preferences_tab.theme_dark_radio.isChecked()
+    finally:
+        window.close()
+        apply_theme(THEME_SYSTEM)  # don't leak a dark palette into other tests
+
+
 def test_get_server_log_button_needs_a_connection(qapp, tmp_path):
     window = make_window(tmp_path)
     try:

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/tests/test_preferences.py

@@ -92,6 +92,37 @@ def test_clipboard_toggle_persists_and_applies_live(qapp, tmp_path):
     assert not load_clipboard_sync_enabled(settings)
 
 
+def test_theme_defaults_and_invalid_fall_back(tmp_path):
+    from remotedesktop.preferences import THEME_KEY, THEME_SYSTEM, load_theme
+
+    settings = Settings(db.connect(tmp_path / "prefs.db"))
+    assert load_theme(settings) == THEME_SYSTEM
+    settings.set(THEME_KEY, "sepia")
+    assert load_theme(settings) == THEME_SYSTEM
+
+
+def test_theme_radio_persists_and_applies_live(qapp, tmp_path):
+    from PySide6.QtCore import Qt
+
+    from remotedesktop.preferences import THEME_KEY, THEME_SYSTEM, apply_theme
+
+    settings = Settings(db.connect(tmp_path / "prefs.db"))
+    tab = PreferencesTab(settings, PerformanceMonitor(), autostart=make_autostart())
+    assert tab.theme_system_radio.isChecked()  # default: follow the OS
+    messages = []
+    tab.statusMessage.connect(messages.append)
+    try:
+        tab.theme_dark_radio.setChecked(True)
+        assert settings.get(THEME_KEY) == "dark"
+        assert qapp.styleHints().colorScheme() == Qt.ColorScheme.Dark
+        assert any("dark" in m for m in messages)
+        # A fresh tab (restart) reads the persisted choice.
+        tab2 = PreferencesTab(settings, PerformanceMonitor(), autostart=make_autostart())
+        assert tab2.theme_dark_radio.isChecked()
+    finally:
+        apply_theme(THEME_SYSTEM)  # don't leak a dark palette into other tests
+
+
 def test_sharing_mode_radios_reflect_persisted_state_and_emit(qapp, tmp_path):
     settings = Settings(db.connect(tmp_path / "prefs.db"))
     settings.set("server_enabled", "1")

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/tests/test_sharing.py

@@ -23,7 +23,14 @@ def pump(qapp, condition, timeout=10.0):
 
 
 def make_server(
-    credentials, tmp_path, *, approve, injector=None, clipboard=None, log_provider=None
+    credentials,
+    tmp_path,
+    *,
+    approve,
+    injector=None,
+    clipboard=None,
+    cursor_probe=None,
+    log_provider=None,
 ):
     # The server is a distinct "machine" from the client -> its own database.
     server = ShareServer(
@@ -32,6 +39,7 @@ def make_server(
         paired=PairedClients(db.connect(tmp_path / "server.db")),
         injector=injector,
         clipboard=clipboard,
+        cursor_probe=cursor_probe,
         log_provider=log_provider,
     )
     assert server.listen(0)
@@ -99,6 +107,33 @@ def test_first_connection_prompts_pairs_and_streams(qapp, credentials, tmp_path)
         server.close()
 
 
+def test_cursor_shape_sent_on_admission_and_on_change_only(qapp, credentials, tmp_path):
+    shape = ["size_we"]
+    server = make_server(
+        credentials, tmp_path, approve=lambda *_: True, cursor_probe=lambda: shape[0]
+    )
+    client = make_client(tmp_path)
+    shapes: list[str] = []
+    client.cursorShapeChanged.connect(shapes.append)
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        # A just-admitted viewer gets the current shape without waiting for
+        # a change.
+        pump(qapp, lambda: shapes)
+        assert shapes == ["size_we"]
+        shape[0] = "ibeam"
+        pump(qapp, lambda: len(shapes) >= 2)
+        # Give the broadcast timer a few more ticks: the probe is polled at
+        # the frame rate but must send only on change, never per tick.
+        deadline = time.monotonic() + 0.2
+        while time.monotonic() < deadline:
+            qapp.processEvents()
+        assert shapes == ["size_we", "ibeam"]
+    finally:
+        client.close()
+        server.close()
+
+
 def test_reconnect_uses_token_without_prompting(qapp, credentials, tmp_path):
     prompts = []
     # Keep one server (same port) so the client's stored "host:port" token matches.

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/tests/test_smoke.py

@@ -69,3 +69,38 @@ def test_viewer_scales_frames_in_device_pixels(qapp) -> None:
     assert viewer._scaled.devicePixelRatio() == dpr
     assert viewer._scaled.size().width() == round(320 * dpr)
     assert viewer._scaled.size().height() == round(240 * dpr)
+
+
+def test_viewer_draws_border_around_frame(qapp) -> None:
+    from PySide6.QtGui import QImage
+    from PySide6.QtCore import Qt
+
+    viewer = ViewerWidget()
+    viewer.resize(320, 240)
+    frame = QImage(640, 480, QImage.Format.Format_RGB32)  # same 4:3 aspect: fills the widget
+    frame.fill(Qt.GlobalColor.white)
+    viewer.show_frame(frame)
+    grabbed = viewer.grab().toImage()
+    # The frame edge is outlined so it stands out from the app background;
+    # the interior stays untouched remote content.
+    assert grabbed.pixelColor(0, 0) != Qt.GlobalColor.white
+    assert (
+        grabbed.pixelColor(grabbed.width() // 2, grabbed.height() // 2)
+        == Qt.GlobalColor.white
+    )
+
+
+def test_viewer_border_color_follows_theme(qapp) -> None:
+    from PySide6.QtGui import QColor, QPalette
+
+    viewer = ViewerWidget()
+    palette = viewer.palette()
+    palette.setColor(QPalette.ColorRole.Window, QColor(30, 30, 30))
+    viewer.setPalette(palette)
+    dark_theme_border = viewer._border_color()
+    palette.setColor(QPalette.ColorRole.Window, QColor(240, 240, 240))
+    viewer.setPalette(palette)
+    light_theme_border = viewer._border_color()
+    # Light outline on a dark theme, dark outline on a light theme.
+    assert dark_theme_border.lightness() > 128
+    assert light_theme_border.lightness() < 128

{remotedesktop-1.5.0 → remotedesktop-1.6.0}/uv.lock

@@ -557,7 +557,7 @@ wheels = [
 
 [[package]]
 name = "pyship"
-version = "0.7.4"
+version = "0.7.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "attrs" },
@@ -577,7 +577,7 @@ dependencies = [
     { name = "wheel-inspect" },
 ]
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/23/c5e21fb5a2f3c5071f2adfdb2b9f69ebc55fc1227cfbc6338b09f443b4e8/pyship-0.7.4-py3-none-any.whl", hash = "sha256:b479d17bc87223adbee3624619f44843d34ae55e3c2dbaf285d67e8a92a81124", size = 66282, upload-time = "2026-07-19T17:49:36.674Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/4d/195e7e4a44134e7cad54f35e995ad8cf9f2dd75ca0d221e0bcb2705cd73c/pyship-0.7.5-py3-none-any.whl", hash = "sha256:539db5c9c6aa2cb83dd935f98b7eacd883cad6519a50a4066a872f76318add65", size = 66792, upload-time = "2026-07-19T22:30:31.336Z" },
 ]
 
 [[package]]