remotedesktop 1.7.0__tar.gz → 1.9.1__tar.gz

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/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.
+- **Screen capture** (`app.py`): the dock's "Screen capture" group (Copy / Save…, viewer-role UI hidden with the panel) and the matching File-menu actions (`copy_capture_action`/`save_capture_action`, same handlers) capture the current session tab's last frame at full server resolution (`ViewerWidget.frame_image()` — the lock overlay is display-only and never part of it). Copy goes through `ClipboardSync.copy_image`, which records the content signature *before* setting the clipboard so the capture is never echoed to peers, and works with sync disabled (the preference governs syncing, not local copies). Save is `QFileDialog.getSaveFileName` (tests monkeypatch it) defaulting to `Pictures\<server> <timestamp>.png`, PNG only. All four widgets enable only while the current tab shows a frame — `_update_capture_actions()`, called from tab change, `_on_frame` (unconditionally: auto-reconnect refills a cleared viewer without `_connect_session`), and every `viewer.clear` path (connect/denied/approval-pending/disconnect).
 - **Reduce visual effects while sharing** (`visual_effects.py`): animations/fades are a burst of changed frames for the lossless pipeline, so while the preference is on (default on, `reduce_effects_enabled`, `load_reduce_effects_enabled`) **and ≥1 viewer is connected**, `MainWindow` applies `VisualEffectsReducer` and restores it when the last viewer leaves (driven by `SharingTab.viewerCountChanged`; explicit safety-net restore in `closeEvent`). The reduced set: SPI_SETUIEFFECTS off, drop shadows off, client-area + min/max animations off, submenu delay lowered to 50 ms (never raised). All via `SystemParametersInfo` **without** SPIF_UPDATEINIFILE — session-scoped, never persisted, self-heals at logoff; knobs already at the reduced value are left untouched so the user's own choices are never "restored" over. The backend (`SpiBackend`) is injectable — **tests must always inject `FakeSpiBackend`** (the preference defaults on, so a real reducer in a test would change the host's actual Windows settings; `make_window` in `tests/test_main_window.py` injects it for every window test, and real-backend tests may only read).
 - **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.
@@ -90,6 +91,7 @@ Managed with `uv` (hatchling build backend, src layout):
 - 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.
+- **Lock-screen notice** (`session_lock.py`): the Windows lock screen / secure desktop (also UAC, Ctrl+Alt+Del) can be neither captured nor injected into by a user-mode process, so remote unlock is impossible by design (documented in the readme; the assumption is the server machine is physically reachable to sign in). `ShareServer` takes an opt-in `lock_probe=` callable (the `cursor_probe=` pattern — only the GUI wires `is_session_locked`, which reads OpenInputDesktop failure as "secure desktop has input"). Polled each broadcast tick; `{"type": "session_lock", "locked": bool}` is sent on change, plus to just-admitted streams while locked (unlocked is the assumed start state, so it's never sent on admission). While locked the server drops remote input with a once-per-lock-episode status line ("Ignoring remote input while the session is locked"). `ShareClient.sessionLockChanged` → `ViewerWidget.set_session_locked`: the viewer dims whatever it shows under `viewer.LOCKED_MESSAGE`; `clear()` resets it (so reconnects start unlocked). Peers without the feature never send / silently ignore the message. Sharing tests inject a fake `lock_probe` — the default None means plain tests never poll the host's real desktop.
 - **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.7.0 → remotedesktop-1.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 1.7.0
+Version: 1.9.1
 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
@@ -77,6 +77,7 @@ one-click *Forget* / *Revoke*, and the live connection log.
 - ⌨️🖱️ **Full input control** — mouse, wheel, and keyboard forwarding that is safe against interruptions: anything still held down is released on the server if the viewer loses focus or disconnects, so no stuck keys. Prefer eyes-only? Choose *Shared, view only* and sharing becomes view-only, switchable live.
 - 🖼️ **View your way** — each connection scales to fit or shows the remote screen at 1:1 pixels with panning, and F11 goes full screen. While you type into a remote session every key is forwarded — F11 is the one key that stays local.
 - 📋 **Two-way clipboard** — text and images copied on either machine appear on the other; a Preferences toggle turns syncing off entirely.
+- 📸 **Screen captures** — grab the remote screen at its full resolution and copy it to the clipboard or save it as a PNG, from the *Screen capture* panel buttons or the File menu.
 - 🔒 **TLS + approve-once pairing** — every connection is encrypted; the server user approves a new client once, after which it reconnects with a stored token and no prompt.
 - 📊 **Built-in performance monitoring** — live bandwidth and round-trip-time graphs with window statistics (mean/min/max/p99/jitter), plus a per-viewer table on the server.
 - 🔁 **Robust connections** — dead connections are detected within seconds, and dropped sessions reconnect automatically with backoff; a server restart heals by itself, no clicks needed. Connections that were open when the app closed are restored on the next start.
@@ -139,6 +140,28 @@ access can be revoked at any time from the *Connections* tab. There is
 no dependency
 on Windows RDP or any Microsoft-based authentication.
 
+## The Windows lock screen
+
+**A locked computer cannot be viewed or unlocked remotely.** The lock
+screen, the PIN/password prompt, and UAC elevation prompts run on a
+separate *secure desktop* that Windows deliberately walls off from
+ordinary applications: nothing running as the signed-in user may capture
+it or type into it, so no software can read or fill in a credential
+prompt. This app intentionally runs as the signed-in user — no admin
+rights, no system service — so it sits on the application side of that
+wall (remote-access products that can show the login screen install a
+privileged Windows service to cross it).
+
+What happens instead: when the shared computer locks, viewers stay
+connected and see a clear *"The remote computer is locked"* notice over
+the last frame, and any input they send is ignored until the computer is
+unlocked. The working assumption is that you (or someone nearby) can get
+to the shared computer to sign it in; once its desktop is unlocked,
+streaming and control resume on their own. If that round trip is a
+nuisance, keep the shared computer signed in while you work on it
+remotely — for example by lengthening its lock/sleep timeout in Windows
+settings.
+
 ## How it works
 
 All of this is pure Python — the GUI is PySide6 (Qt), and the two places

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/readme.md

@@ -53,6 +53,7 @@ one-click *Forget* / *Revoke*, and the live connection log.
 - ⌨️🖱️ **Full input control** — mouse, wheel, and keyboard forwarding that is safe against interruptions: anything still held down is released on the server if the viewer loses focus or disconnects, so no stuck keys. Prefer eyes-only? Choose *Shared, view only* and sharing becomes view-only, switchable live.
 - 🖼️ **View your way** — each connection scales to fit or shows the remote screen at 1:1 pixels with panning, and F11 goes full screen. While you type into a remote session every key is forwarded — F11 is the one key that stays local.
 - 📋 **Two-way clipboard** — text and images copied on either machine appear on the other; a Preferences toggle turns syncing off entirely.
+- 📸 **Screen captures** — grab the remote screen at its full resolution and copy it to the clipboard or save it as a PNG, from the *Screen capture* panel buttons or the File menu.
 - 🔒 **TLS + approve-once pairing** — every connection is encrypted; the server user approves a new client once, after which it reconnects with a stored token and no prompt.
 - 📊 **Built-in performance monitoring** — live bandwidth and round-trip-time graphs with window statistics (mean/min/max/p99/jitter), plus a per-viewer table on the server.
 - 🔁 **Robust connections** — dead connections are detected within seconds, and dropped sessions reconnect automatically with backoff; a server restart heals by itself, no clicks needed. Connections that were open when the app closed are restored on the next start.
@@ -115,6 +116,28 @@ access can be revoked at any time from the *Connections* tab. There is
 no dependency
 on Windows RDP or any Microsoft-based authentication.
 
+## The Windows lock screen
+
+**A locked computer cannot be viewed or unlocked remotely.** The lock
+screen, the PIN/password prompt, and UAC elevation prompts run on a
+separate *secure desktop* that Windows deliberately walls off from
+ordinary applications: nothing running as the signed-in user may capture
+it or type into it, so no software can read or fill in a credential
+prompt. This app intentionally runs as the signed-in user — no admin
+rights, no system service — so it sits on the application side of that
+wall (remote-access products that can show the login screen install a
+privileged Windows service to cross it).
+
+What happens instead: when the shared computer locks, viewers stay
+connected and see a clear *"The remote computer is locked"* notice over
+the last frame, and any input they send is ignored until the computer is
+unlocked. The working assumption is that you (or someone nearby) can get
+to the shared computer to sign it in; once its desktop is unlocked,
+streaming and control resume on their own. If that round trip is a
+nuisance, keep the shared computer signed in while you work on it
+remotely — for example by lengthening its lock/sleep timeout in Windows
+settings.
+
 ## How it works
 
 All of this is pure Python — the GUI is PySide6 (Qt), and the two places

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/src/remotedesktop/__init__.py

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

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/src/remotedesktop/app.py

@@ -12,16 +12,19 @@ tray menu. Only one instance runs per user session (`single_instance`)."""
 
 import json
 import logging
+import re
 import sqlite3
 import sys
 import time
+from pathlib import Path
 
-from PySide6.QtCore import QObject, QProcess, Qt, QTimer, Signal
-from PySide6.QtGui import QCloseEvent, QKeySequence
+from PySide6.QtCore import QObject, QProcess, QStandardPaths, Qt, QTimer, Signal
+from PySide6.QtGui import QCloseEvent, QImage, QKeySequence
 from PySide6.QtNetwork import QNetworkInterface
 from PySide6.QtWidgets import (
     QApplication,
     QDockWidget,
+    QFileDialog,
     QFrame,
     QGroupBox,
     QHBoxLayout,
@@ -314,11 +317,35 @@ class MainWindow(QMainWindow):
         # through, and the roles are changed only in Preferences.
         self.client_role_button = self._make_role_button()
         self.server_role_button = self._make_role_button()
+        # Screen capture of the current session tab (the last received frame
+        # at the server's full resolution). Buttons live in the dock; the
+        # same handlers back the File-menu actions. Enabled only while the
+        # current tab shows a frame (_update_capture_actions).
+        self.copy_capture_button = QPushButton("Copy")
+        self.copy_capture_button.setToolTip(
+            "Copy a screen capture of the current session to the clipboard"
+        )
+        self.copy_capture_button.clicked.connect(self._copy_screen_capture)
+        self.save_capture_button = QPushButton("Save…")
+        self.save_capture_button.setToolTip(
+            "Save a screen capture of the current session to a file"
+        )
+        self.save_capture_button.clicked.connect(self._save_screen_capture)
+        # Nothing to capture until a session tab shows a frame.
+        self.copy_capture_button.setEnabled(False)
+        self.save_capture_button.setEnabled(False)
+        self._capture_group = QGroupBox("Screen capture")
+        # Stacked, not side by side: the dock is narrow and its width is
+        # what the panel/server list gets — height is the cheaper dimension.
+        capture_layout = QVBoxLayout(self._capture_group)
+        capture_layout.addWidget(self.copy_capture_button)
+        capture_layout.addWidget(self.save_capture_button)
         dock_body = QWidget()
         self._dock_layout = QVBoxLayout(dock_body)
         self._dock_layout.addWidget(self.client_role_button)
         self._dock_layout.addWidget(self.server_role_button)
         self._dock_layout.addWidget(self.discovery_panel)
+        self._dock_layout.addWidget(self._capture_group)
         # A permanent trailing spacer: it takes the leftover height while
         # the discovery panel is hidden (keeping the indicators pinned to
         # the top), and collapses to nothing while the panel is visible
@@ -326,6 +353,7 @@ class MainWindow(QMainWindow):
         self._dock_layout.addStretch(0)
         if not self._viewer_enabled:
             self.discovery_panel.hide()
+            self._capture_group.hide()
         self._update_dock_layout()
         # No title bar at all: the contents are self-explanatory, and the
         # View menu ("Panel") is the way to show or hide it — a blank header
@@ -417,6 +445,15 @@ class MainWindow(QMainWindow):
         self.close_tab_action.triggered.connect(self._close_current_session_tab)
         self.close_tab_action.setEnabled(False)  # startup tab is a fixed tab
         self._file_menu.addSeparator()
+        # Same handlers as the dock's Screen capture buttons; enabled state
+        # is kept in sync with them (_update_capture_actions).
+        self.copy_capture_action = self._file_menu.addAction("Copy screen &capture")
+        self.copy_capture_action.triggered.connect(self._copy_screen_capture)
+        self.copy_capture_action.setEnabled(False)
+        self.save_capture_action = self._file_menu.addAction("&Save screen capture…")
+        self.save_capture_action.triggered.connect(self._save_screen_capture)
+        self.save_capture_action.setEnabled(False)
+        self._file_menu.addSeparator()
         self.quit_action = self._file_menu.addAction("&Quit")
         self.quit_action.setShortcut(QKeySequence("Ctrl+Q"))
         self.quit_action.triggered.connect(self._quit)
@@ -537,7 +574,7 @@ class MainWindow(QMainWindow):
         """Give the dock's leftover height to the panel or the spacer."""
         panel_visible = self._viewer_enabled
         self._dock_layout.setStretch(2, 1 if panel_visible else 0)  # panel
-        self._dock_layout.setStretch(3, 0 if panel_visible else 1)  # spacer
+        self._dock_layout.setStretch(4, 0 if panel_visible else 1)  # spacer
 
     def _update_role_indicators(self) -> None:
         self.client_role_button.setChecked(self._viewer_enabled)
@@ -560,8 +597,10 @@ class MainWindow(QMainWindow):
             if placeholder_index != -1:
                 self._tabs.removeTab(placeholder_index)
             self.discovery_panel.hide()
+            self._capture_group.hide()
         else:
             self.discovery_panel.show()
+            self._capture_group.show()
             self._ensure_placeholder()
             self._tabs.setCurrentIndex(0)
             if self._auto_scan:
@@ -581,6 +620,74 @@ class MainWindow(QMainWindow):
         self.fullscreen_action.setEnabled(session is not None)
         self.actual_size_action.setEnabled(session is not None)
         self.actual_size_action.setChecked(session.actual_size if session else False)
+        self._update_capture_actions()
+
+    # ------------------------------------------------------ screen capture
+
+    def _update_capture_actions(self) -> None:
+        """Capture is possible while the current tab shows a frame; the dock
+        buttons and the File-menu actions enable and disable together."""
+        session = self._session_for_page(self._tabs.currentWidget())
+        available = session is not None and session.viewer.has_frame
+        for action in (
+            self.copy_capture_button,
+            self.save_capture_button,
+            self.copy_capture_action,
+            self.save_capture_action,
+        ):
+            action.setEnabled(available)
+
+    def _current_capture(self) -> tuple[ServerSession, QImage] | None:
+        """The current tab's session and its full-resolution frame, or None
+        (the handlers can fire with no frame via QAction.trigger())."""
+        session = self._session_for_page(self._tabs.currentWidget())
+        if session is None:
+            return None
+        image = session.viewer.frame_image()
+        if image is None:
+            return None
+        return session, image
+
+    def _copy_screen_capture(self) -> None:
+        capture = self._current_capture()
+        if capture is None:
+            return
+        session, image = capture
+        # copy_image does not echo to peers: sending the server a capture of
+        # its own screen (or spamming viewers) would be pure waste.
+        self._clipboard.copy_image(image)
+        self.log(
+            f"Screen capture of {session.name} "
+            f"({image.width()}x{image.height()}) copied to the clipboard"
+        )
+
+    def _save_screen_capture(self) -> None:
+        capture = self._current_capture()
+        if capture is None:
+            return
+        session, image = capture
+        # Default: Pictures\<server> 2026-07-20 143059.png (the server name
+        # is a hostname, but sanitize for safety — it came off the wire).
+        name = re.sub(r'[<>:"/\\|?*]', "_", session.name).strip() or "server"
+        stamp = time.strftime("%Y-%m-%d %H%M%S")
+        directory = QStandardPaths.writableLocation(
+            QStandardPaths.StandardLocation.PicturesLocation
+        )
+        default = str(Path(directory) / f"{name} {stamp}.png") if directory else f"{name} {stamp}.png"
+        path, _filter = QFileDialog.getSaveFileName(
+            self, "Save screen capture", default, "PNG image (*.png)"
+        )
+        if not path:
+            return  # cancelled
+        if not path.lower().endswith(".png"):
+            path += ".png"
+        if image.save(path, "PNG"):  # ty: ignore[no-matching-overload]
+            self.log(
+                f"Screen capture of {session.name} "
+                f"({image.width()}x{image.height()}) saved to {path}"
+            )
+        else:
+            self.log(f"Could not save the screen capture to {path}")
 
     def _close_current_session_tab(self) -> None:
         session = self._session_for_page(self._tabs.currentWidget())
@@ -1040,6 +1147,7 @@ class MainWindow(QMainWindow):
         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.sessionLockChanged.connect(lambda locked, s=session: s.viewer.set_session_locked(locked))
         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)
@@ -1069,6 +1177,7 @@ class MainWindow(QMainWindow):
         if not any(s.connected for s in self._sessions if s is not session):
             self.client_performance.reset()
         session.viewer.clear(f"Connecting to {session.name} …")
+        self._update_capture_actions()  # cleared viewer; tab may already be current
         self._tabs.setCurrentWidget(session.page)
         self._set_session_status(
             session, f"Connecting to {session.name} ({session.key}) …"
@@ -1110,6 +1219,7 @@ class MainWindow(QMainWindow):
             f"Waiting for approval — someone at {session.name} "
             "must allow this connection"
         )
+        self._update_capture_actions()
         self._set_session_status(
             session,
             f"Waiting for the user on {session.name} to approve this computer …",
@@ -1177,6 +1287,7 @@ class MainWindow(QMainWindow):
         session.auto_reconnect = False
         self.client_inventory.record(session.key, "denied", name=session.name)
         session.viewer.clear(f"Connection denied: {reason}")
+        self._update_capture_actions()
         self._set_session_status(session, f"Denied by {session.name}: {reason}")
         self._update_window_title()
 
@@ -1190,6 +1301,7 @@ class MainWindow(QMainWindow):
             self.client_inventory.record(session.key, "disconnected", name=session.name)
             session.viewer.clear("Disconnected")
             self._set_session_status(session, f"Disconnected from {session.name}")
+        self._update_capture_actions()  # a cleared viewer has nothing to capture
         self._update_window_title()
         self._sessions_source.notify()
         if session.auto_reconnect and not session.denied and not self._quitting:
@@ -1272,6 +1384,9 @@ class MainWindow(QMainWindow):
             return
         session.frame_count += 1
         session.viewer.show_frame(image)
+        # Unconditional (not just the first frame): auto-reconnect refills a
+        # cleared viewer without passing through _connect_session.
+        self._update_capture_actions()
         self._set_session_status(
             session,
             f"Viewing {self._server_label(session)} — {image.width()}x{image.height()} — "

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/src/remotedesktop/clipboard.py

@@ -69,6 +69,25 @@ class ClipboardSync(QObject):
             ).decode()
         self.changed.emit(payload)
 
+    def copy_image(self, image: QImage) -> None:
+        """Place an app-generated image (a screen capture) on the local
+        clipboard WITHOUT echoing it to peers: its signature is recorded
+        first, so the asynchronous dataChanged this set fires is ignored —
+        the same mechanism apply() uses. Sending a capture of the server's
+        own screen back to it would be pure waste.
+
+        Deliberately not gated on `enabled`: that preference governs
+        syncing, and this is a local copy.
+        """
+        if image.isNull():
+            return
+        self._last_signature = (None, _image_hash(image))
+        self._applying = True
+        try:
+            self._clipboard.setImage(image)
+        finally:
+            self._applying = False
+
     def apply(self, payload: dict) -> None:
         if not self.enabled:
             return  # peers may still send payloads; they are dropped locally

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/src/remotedesktop/server.py

@@ -29,6 +29,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.session_lock import is_session_locked
 from remotedesktop.discovery import (
     DEFAULT_CONNECT_PORT,
     DISCOVERY_PORT,
@@ -276,6 +277,7 @@ class SharingTab(QWidget):
             paired=self._paired,
             clipboard=self._clipboard,
             cursor_probe=current_cursor_shape,
+            lock_probe=is_session_locked,
             performance=self._performance,
             log_provider=lambda: read_log_tail("remotedesktop"),
             input_allowed=self._settings.get_bool(ALLOW_INPUT_KEY, True),

remotedesktop-1.9.1/src/remotedesktop/session_lock.py

@@ -0,0 +1,46 @@
+"""Detect whether the Windows secure desktop is in control (server side).
+
+While the workstation is locked — and during UAC prompts and the
+Ctrl+Alt+Del screen — Windows switches to a separate "secure desktop" that
+processes running as the signed-in user may neither capture nor inject
+input into. That is a deliberate security boundary (nothing in the user's
+session can read or type into a credential prompt), so remote unlock is
+impossible for this app by design: screen capture yields a stale frame and
+SendInput is silently discarded. The server uses this probe to tell
+viewers what is going on instead of leaving them a frozen screen.
+
+The check: `OpenInputDesktop` fails for an ordinary user process while the
+input desktop is the secure desktop, and succeeds while the user's own
+desktop has input.
+
+On non-Windows platforms `is_session_locked()` returns None (the app
+targets Windows).
+"""
+
+import ctypes
+import sys
+
+_IS_WINDOWS = sys.platform == "win32"
+
+# winuser.h desktop access right — the weakest thing OpenInputDesktop can be
+# asked for, enough to answer "may this process touch the input desktop?".
+_DESKTOP_SWITCHDESKTOP = 0x0100
+
+if _IS_WINDOWS:
+    _user32 = ctypes.windll.user32
+    _user32.OpenInputDesktop.restype = ctypes.c_void_p
+    _user32.OpenInputDesktop.argtypes = (ctypes.c_uint32, ctypes.c_int, ctypes.c_uint32)
+    _user32.CloseDesktop.argtypes = (ctypes.c_void_p,)
+
+
+def is_session_locked() -> bool | None:
+    """True while the secure desktop (lock screen, UAC prompt) has the
+    input, False while the user's own desktop does, or None when it cannot
+    be determined (non-Windows)."""
+    if not _IS_WINDOWS:
+        return None
+    handle = _user32.OpenInputDesktop(0, False, _DESKTOP_SWITCHDESKTOP)
+    if not handle:
+        return True
+    _user32.CloseDesktop(handle)
+    return False

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/src/remotedesktop/sharing.py

@@ -117,6 +117,7 @@ class ShareServer(QObject):
         injector: InputInjector | None = None,
         clipboard=None,
         cursor_probe: Callable[[], str | None] | None = None,
+        lock_probe: Callable[[], bool | None] | None = None,
         performance: PerformanceMonitor | None = None,
         log_provider: Callable[[], str] | None = None,
         input_allowed: bool = True,
@@ -137,6 +138,13 @@ class ShareServer(QObject):
         # 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
+        # Opt-in for the same reason: only the GUI probes the real desktop.
+        # While the session is locked (secure desktop — see session_lock.py)
+        # the screen cannot be captured and injected input is discarded, so
+        # viewers are told and remote input is dropped here.
+        self._lock_probe = lock_probe
+        self._session_locked = False  # last state sent to viewers
+        self._lock_input_reported = False  # one status line per lock episode
         self._streams: list[MessageStream] = []
         self._all_streams: set[MessageStream] = set()
         self._controllers: set[MessageStream] = set()
@@ -243,6 +251,8 @@ class ShareServer(QObject):
         self._viewer_info.clear()
         self._previous_frame = None
         self._cursor_shape = None
+        self._session_locked = False
+        self._lock_input_reported = False
         if self._dxgi is not None:
             self._dxgi.close()
             self._dxgi = None
@@ -475,6 +485,7 @@ class ShareServer(QObject):
         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
+        self._broadcast_lock(new_stream=stream)  # tell it if the session is locked
         if self._performance is not None:
             self._performance.add_stream(stream)
         self.clientCountChanged.emit(len(self._streams))
@@ -490,6 +501,13 @@ class ShareServer(QObject):
             # View-only: the toggle already produced a status line; per-event
             # noise goes nowhere (not even the debug log — it's every move).
             return
+        if self._session_locked:
+            # The secure desktop discards injected input anyway; drop it here
+            # and say so once per lock episode (not per event — it's every move).
+            if not self._lock_input_reported:
+                self._lock_input_reported = True
+                self.status.emit("Ignoring remote input while the session is locked")
+            return
         action = message.get("action")
         x, y = message.get("x"), message.get("y")
         if stream not in self._controllers:
@@ -664,10 +682,40 @@ class ShareServer(QObject):
         elif new_stream is not None:
             new_stream.send_json({"type": "cursor", "shape": shape})
 
+    def _broadcast_lock(self, new_stream: MessageStream | None = None) -> None:
+        """Tell viewers when the session locks or unlocks (secure desktop —
+        see session_lock.py): the screen can no longer be captured and input
+        cannot be injected, so the client shows a notice instead of leaving
+        its user a silently frozen frame.
+
+        Sent on change to everyone, plus to a just-admitted stream while
+        locked (unlocked is every stream's starting assumption).
+        """
+        if self._lock_probe is None:
+            return
+        locked = self._lock_probe()
+        if locked is None:
+            return
+        if locked != self._session_locked:
+            self._session_locked = locked
+            if locked:
+                self.status.emit(
+                    "Session locked — the lock screen cannot be captured or "
+                    "controlled remotely; viewers are notified"
+                )
+            else:
+                self._lock_input_reported = False
+                self.status.emit("Session unlocked — resuming normal streaming")
+            for stream in self._streams:
+                stream.send_json({"type": "session_lock", "locked": locked})
+        elif new_stream is not None and locked:
+            new_stream.send_json({"type": "session_lock", "locked": True})
+
     def _broadcast_frame(self) -> None:
         if not self._streams:
             return
         self._broadcast_cursor()  # polled at the frame rate, sent on change
+        self._broadcast_lock()  # likewise
         image = self._capture()
         if image is None:
             self.status.emit("Screen capture failed (null image)")
@@ -743,6 +791,10 @@ class ShareClient(QObject):
     # "size_we"); the viewer mirrors it on the local cursor. Servers without
     # the feature (pre-1.6) simply never emit it.
     cursorShapeChanged = Signal(str)
+    # The server's session locked (True) or unlocked (False) — the secure
+    # desktop cannot be captured or controlled, so the viewer shows a notice.
+    # Servers without the feature (pre-1.8) simply never emit it.
+    sessionLockChanged = Signal(bool)
     status = Signal(str)
     logReceived = Signal(str)  # server log text answering request_log
 
@@ -943,6 +995,14 @@ class ShareClient(QObject):
                 # 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 "session_lock":
+                locked = bool(message.get("locked"))
+                self.status.emit(
+                    "Server session is locked — sign in at the server machine"
+                    if locked
+                    else "Server session unlocked"
+                )
+                self.sessionLockChanged.emit(locked)
             case "ping" | "pong":
                 if self._performance is not None:
                     self._performance.handle_message(self._stream, message)

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/src/remotedesktop/viewer.py

@@ -34,6 +34,16 @@ _BUTTON_NAMES = {
     Qt.MouseButton.MiddleButton: "middle",
 }
 
+# Shown (over a dimmed last frame) while the server's session is locked: the
+# secure desktop cannot be captured or controlled remotely, so signing in
+# has to happen at the server machine itself.
+LOCKED_MESSAGE = (
+    "The remote computer is locked.\n"
+    "Its sign-in screen cannot be viewed or controlled remotely —\n"
+    "sign in at that computer to continue."
+)
+_LOCK_DIM = QColor(0, 0, 0, 160)
+
 # 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.
@@ -78,6 +88,9 @@ class ViewerWidget(QWidget):
         # display-scaling factor (125-150% on most monitors), blurring text.
         self._scaled: QPixmap | None = None
         self._message = "Not connected"
+        # The server's session is locked (secure desktop): the frame is
+        # stale, so it is dimmed under a LOCKED_MESSAGE notice.
+        self._session_locked = False
         # Buttons/keys currently held, so releases can be forwarded even when
         # they happen outside the frame or when the widget loses focus —
         # otherwise the server would keep them pressed forever.
@@ -91,6 +104,12 @@ class ViewerWidget(QWidget):
     def has_frame(self) -> bool:
         return self._frame is not None
 
+    def frame_image(self) -> QImage | None:
+        """The most recent frame at the server's full resolution (what a
+        screen capture saves/copies), or None while nothing is shown. The
+        display-only lock overlay is never part of it."""
+        return self._frame.toImage() if self._frame is not None else None
+
     def set_actual_size(self, enabled: bool) -> None:
         """Toggle 1:1 device-pixel display (host provides the scrolling)."""
         if self._actual_size == enabled:
@@ -128,11 +147,24 @@ class ViewerWidget(QWidget):
         self._frame = None
         self._scaled = None
         self._message = message
+        self._session_locked = False
         self._pressed_buttons.clear()
         self._pressed_keys.clear()
         self.unsetCursor()  # a disconnected viewer shows the normal cursor
         self.update()
 
+    @property
+    def session_locked(self) -> bool:
+        return self._session_locked
+
+    def set_session_locked(self, locked: bool) -> None:
+        """Dim the view under a lock notice while the server's session is
+        locked (the secure desktop is neither captured nor controllable)."""
+        if self._session_locked == locked:
+            return
+        self._session_locked = locked
+        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)."""
@@ -270,32 +302,37 @@ class ViewerWidget(QWidget):
         painter = QPainter(self)
         painter.fillRect(self.rect(), Qt.GlobalColor.black)
         if self._frame is None:
+            if not self._session_locked:  # the lock notice below says it all
+                painter.setPen(Qt.GlobalColor.white)
+                painter.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter, self._message)
+        else:
+            rect = self._display_rect().toRect()
+            dpr = self.devicePixelRatioF()
+            target = QSize(round(rect.width() * dpr), round(rect.height() * dpr))
+            if (
+                self._scaled is None
+                or self._scaled.size() != target
+                or self._scaled.devicePixelRatio() != dpr
+            ):
+                if self._frame.size() == target:
+                    # Displayed at exactly 1:1 device pixels — no resample at all.
+                    self._scaled = QPixmap(self._frame)
+                else:
+                    self._scaled = self._frame.scaled(
+                        target,
+                        Qt.AspectRatioMode.IgnoreAspectRatio,  # rect is already aspect-correct
+                        Qt.TransformationMode.SmoothTransformation,
+                    )
+                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))
+        if self._session_locked:
+            painter.fillRect(self.rect(), _LOCK_DIM)
             painter.setPen(Qt.GlobalColor.white)
-            painter.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter, self._message)
-            return
-        rect = self._display_rect().toRect()
-        dpr = self.devicePixelRatioF()
-        target = QSize(round(rect.width() * dpr), round(rect.height() * dpr))
-        if (
-            self._scaled is None
-            or self._scaled.size() != target
-            or self._scaled.devicePixelRatio() != dpr
-        ):
-            if self._frame.size() == target:
-                # Displayed at exactly 1:1 device pixels — no resample at all.
-                self._scaled = QPixmap(self._frame)
-            else:
-                self._scaled = self._frame.scaled(
-                    target,
-                    Qt.AspectRatioMode.IgnoreAspectRatio,  # rect is already aspect-correct
-                    Qt.TransformationMode.SmoothTransformation,
-                )
-            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))
+            painter.drawText(self.rect(), Qt.AlignmentFlag.AlignCenter, LOCKED_MESSAGE)
 
     def _border_color(self) -> QColor:
         """Outline shade for the current theme (follows the window background)."""

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/tests/test_clipboard.py

@@ -157,6 +157,30 @@ def test_apply_image_payload_sets_clipboard_image(qapp):
     sync.apply(payload)
 
 
+def test_copy_image_sets_clipboard_without_echoing_to_peers(qapp):
+    clip = qapp.clipboard()
+    sync = ClipboardSync(clip)
+    emitted: list[dict] = []
+    sync.changed.connect(emitted.append)
+    sync.copy_image(_red_image())
+    for _ in range(10):
+        qapp.processEvents()
+    assert clip.image().pixelColor(0, 0).name() == "#ff0000"
+    # An app-generated copy (a screen capture) is never synced to peers.
+    assert emitted == []
+
+
+def test_copy_image_works_with_sync_disabled(qapp):
+    # The Preferences toggle governs syncing; a local capture copy is not sync.
+    clip = qapp.clipboard()
+    sync = ClipboardSync(clip)
+    sync.enabled = False
+    blue = QImage(4, 4, QImage.Format.Format_RGB32)
+    blue.fill(Qt.GlobalColor.blue)
+    sync.copy_image(blue)
+    assert clip.image().pixelColor(0, 0).name() == "#0000ff"
+
+
 def test_apply_ignores_garbage_payloads(qapp):
     clip = qapp.clipboard()
     clip.setText("before")

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/tests/test_input.py

@@ -253,6 +253,62 @@ def test_viewer_mirrors_remote_cursor_shape(qapp):
     assert viewer.cursor().shape() == Qt.CursorShape.ArrowCursor
 
 
+def test_input_dropped_while_session_locked(qapp, credentials, tmp_path):
+    injector = RecordingInjector()
+    locked = [False]
+    server = make_server(
+        credentials,
+        tmp_path,
+        approve=lambda *_: True,
+        injector=injector,
+        lock_probe=lambda: locked[0],
+    )
+    statuses: list[str] = []
+    server.status.connect(statuses.append)
+    client = make_client(tmp_path)
+    lock_states: list[bool] = []
+    client.sessionLockChanged.connect(lock_states.append)
+    connected = []
+    client.connected.connect(connected.append)
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        pump(qapp, lambda: connected)
+        client.send_input({"action": "move", "x": 0.5, "y": 0.25})
+        pump(qapp, lambda: injector.calls)
+        locked[0] = True
+        # The lock notice reaching the client proves the server's own state
+        # flipped before the input below arrives.
+        pump(qapp, lambda: lock_states == [True])
+        injector.calls.clear()
+        client.send_input({"action": "move", "x": 0.1, "y": 0.1})
+        client.send_input({"action": "key", "vk": 65, "pressed": True})
+        pump(qapp, lambda: any("Ignoring remote input" in s for s in statuses))
+        assert injector.calls == []
+        locked[0] = False
+        pump(qapp, lambda: lock_states == [True, False])
+        client.send_input({"action": "move", "x": 0.9, "y": 0.9})
+        pump(qapp, lambda: injector.calls)  # unlocking resumes injection
+    finally:
+        client.close()
+        server.close()
+
+
+def test_viewer_session_lock_overlay(qapp):
+    viewer = ViewerWidget()
+    viewer.resize(400, 400)
+    assert not viewer.session_locked
+    image = QImage(200, 100, QImage.Format.Format_RGB32)
+    image.fill(Qt.GlobalColor.red)
+    viewer.show_frame(image)
+    viewer.set_session_locked(True)
+    assert viewer.session_locked
+    assert not viewer.grab().isNull()  # paints the dimmed-frame notice branch
+    viewer._frame = None
+    assert not viewer.grab().isNull()  # and the no-frame notice branch
+    viewer.clear()  # disconnecting clears the notice with the frame
+    assert not viewer.session_locked
+
+
 def test_viewer_paints_message_and_frame(qapp):
     viewer = ViewerWidget()
     viewer.resize(400, 400)

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/tests/test_main_window.py

@@ -4,6 +4,7 @@ import socket
 import sys
 
 from PySide6.QtCore import QProcess, Qt
+from PySide6.QtGui import QImage
 from PySide6.QtWidgets import QApplication, QListWidgetItem, QMessageBox
 
 from remotedesktop import client as client_module
@@ -360,6 +361,117 @@ def test_forget_server_disconnects_and_forgets(qapp, credentials, tmp_path, monk
         server.close()
 
 
+def _capture_widgets(window):
+    return (
+        window.copy_capture_button,
+        window.save_capture_button,
+        window.copy_capture_action,
+        window.save_capture_action,
+    )
+
+
+def test_capture_buttons_and_actions_follow_frame_availability(qapp, credentials, tmp_path):
+    server = make_share_server(credentials, tmp_path)
+    window = make_window(tmp_path)
+    try:
+        assert not any(w.isEnabled() for w in _capture_widgets(window))
+        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
+        session = window._sessions[0]
+        pump(qapp, lambda: session.viewer.has_frame)
+        assert all(w.isEnabled() for w in _capture_widgets(window))
+        server.close()  # dropping the connection clears the viewer again
+        pump(qapp, lambda: not session.viewer.has_frame)
+        assert not any(w.isEnabled() for w in _capture_widgets(window))
+    finally:
+        window.close()
+        server.close()
+
+
+def test_capture_group_hidden_without_the_viewer_role(qapp, credentials, tmp_path):
+    window = make_window(tmp_path, credentials, serving=True, viewer=False)
+    try:
+        assert window._capture_group.isHidden()
+    finally:
+        window.close()
+
+
+def test_copy_screen_capture_goes_through_clipboard_sync(qapp, credentials, tmp_path):
+    class RecordingSync:
+        def __init__(self):
+            self.images = []
+
+        def copy_image(self, image):
+            self.images.append(image)
+
+    server = make_share_server(credentials, tmp_path)
+    window = make_window(tmp_path)
+    try:
+        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
+        session = window._sessions[0]
+        pump(qapp, lambda: session.viewer.has_frame)
+        # A recording stand-in, so the test never touches the OS clipboard.
+        recorder = RecordingSync()
+        window._clipboard = recorder
+        window.copy_capture_button.click()
+        assert len(recorder.images) == 1
+        assert recorder.images[0].size() == session.viewer.frame_image().size()
+        assert "copied to the clipboard" in window.connection_log.toPlainText()
+    finally:
+        window.close()
+        server.close()
+
+
+def test_save_screen_capture_writes_png(qapp, credentials, tmp_path, monkeypatch):
+    from PySide6.QtWidgets import QFileDialog
+
+    target = tmp_path / "capture.png"
+    dialogs = []
+    monkeypatch.setattr(
+        QFileDialog,
+        "getSaveFileName",
+        staticmethod(
+            lambda parent, title, default, filter: dialogs.append(default)
+            or (str(target), filter)
+        ),
+    )
+    server = make_share_server(credentials, tmp_path)
+    window = make_window(tmp_path)
+    try:
+        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
+        session = window._sessions[0]
+        pump(qapp, lambda: session.viewer.has_frame)
+        window.save_capture_action.trigger()  # the menu path this time
+        assert target.exists()
+        saved = QImage(str(target))
+        assert saved.size() == session.viewer.frame_image().size()
+        # The server's reported name (its hostname, after the on-connect
+        # rename) seeds the default filename.
+        assert dialogs and session.name in dialogs[0]
+        assert f"saved to {target}" in window.connection_log.toPlainText()
+    finally:
+        window.close()
+        server.close()
+
+
+def test_save_screen_capture_cancelled_dialog_saves_nothing(qapp, credentials, tmp_path, monkeypatch):
+    from PySide6.QtWidgets import QFileDialog
+
+    monkeypatch.setattr(
+        QFileDialog, "getSaveFileName", staticmethod(lambda *a, **k: ("", ""))
+    )
+    server = make_share_server(credentials, tmp_path)
+    window = make_window(tmp_path)
+    try:
+        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
+        session = window._sessions[0]
+        pump(qapp, lambda: session.viewer.has_frame)
+        window.save_capture_button.click()
+        assert "saved to" not in window.connection_log.toPlainText()
+    finally:
+        window.close()
+        server.close()
+
+
 def test_version_mismatch_warns_but_still_connects(qapp, credentials, tmp_path, monkeypatch):
     shown = []
     monkeypatch.setattr(QMessageBox, "show", lambda self: shown.append(self.windowTitle()))
@@ -1195,11 +1307,12 @@ def test_role_indicators_are_inert_buttons(qapp, credentials, tmp_path):
 
 
 def test_dock_keeps_indicators_at_the_top_in_both_roles(qapp, credentials, tmp_path):
-    # Layout indexes: 0/1 = indicator buttons, 2 = discovery panel, 3 = spacer.
+    # Layout indexes: 0/1 = indicator buttons, 2 = discovery panel,
+    # 3 = screen-capture group, 4 = spacer.
     window = make_window(tmp_path, credentials, serving=True, viewer=False)
     try:
         assert window._dock_layout.stretch(2) == 0  # hidden panel
-        assert window._dock_layout.stretch(3) == 1  # spacer pins buttons up
+        assert window._dock_layout.stretch(4) == 1  # spacer pins buttons up
         window.show()
         qapp.processEvents()
         # The two indicators sit adjacent at the top, not spread apart.
@@ -1211,14 +1324,14 @@ def test_dock_keeps_indicators_at_the_top_in_both_roles(qapp, credentials, tmp_p
     window = make_window(tmp_path, credentials, db_name="viewer.db")
     try:
         assert window._dock_layout.stretch(2) == 1  # panel takes the height
-        assert window._dock_layout.stretch(3) == 0
+        assert window._dock_layout.stretch(4) == 0
         # Live toggle off: the spacer takes over immediately (this was the
         # spaced-out bug — the spacer only existed for non-viewer startup).
         window.preferences_tab.viewer_checkbox.setChecked(False)
-        assert window._dock_layout.stretch(3) == 1
+        assert window._dock_layout.stretch(4) == 1
         window.preferences_tab.viewer_checkbox.setChecked(True)
         assert window._dock_layout.stretch(2) == 1
-        assert window._dock_layout.stretch(3) == 0
+        assert window._dock_layout.stretch(4) == 0
     finally:
         window.close()
 

remotedesktop-1.9.1/tests/test_session_lock.py

@@ -0,0 +1,18 @@
+import sys
+
+import pytest
+
+from remotedesktop.session_lock import is_session_locked
+
+
+@pytest.mark.skipif(sys.platform != "win32", reason="Windows desktop API")
+def test_is_session_locked_reports_a_bool():
+    # The answer depends on the session running the tests (an interactive
+    # desktop says False; a service-like session may say True) — only the
+    # contract is asserted, not the state.
+    assert is_session_locked() in (True, False)
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="non-Windows returns None")
+def test_is_session_locked_is_none_off_windows():
+    assert is_session_locked() is None

{remotedesktop-1.7.0 → remotedesktop-1.9.1}/tests/test_sharing.py

@@ -30,6 +30,7 @@ def make_server(
     injector=None,
     clipboard=None,
     cursor_probe=None,
+    lock_probe=None,
     log_provider=None,
 ):
     # The server is a distinct "machine" from the client -> its own database.
@@ -40,6 +41,7 @@ def make_server(
         injector=injector,
         clipboard=clipboard,
         cursor_probe=cursor_probe,
+        lock_probe=lock_probe,
         log_provider=log_provider,
     )
     assert server.listen(0)
@@ -134,6 +136,36 @@ def test_cursor_shape_sent_on_admission_and_on_change_only(qapp, credentials, tm
         server.close()
 
 
+def test_session_lock_sent_on_admission_and_on_change_only(qapp, credentials, tmp_path):
+    locked = [True]
+    server = make_server(
+        credentials, tmp_path, approve=lambda *_: True, lock_probe=lambda: locked[0]
+    )
+    client = make_client(tmp_path)
+    states: list[bool] = []
+    client.sessionLockChanged.connect(states.append)
+    statuses: list[str] = []
+    client.status.connect(statuses.append)
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        # A viewer admitted while the session is already locked is told so
+        # immediately (its starting assumption is unlocked).
+        pump(qapp, lambda: states)
+        assert states == [True]
+        assert any("locked — sign in at the server machine" in s for s in statuses)
+        locked[0] = False
+        pump(qapp, lambda: len(states) >= 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 states == [True, False]
+    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.