remotedesktop 0.17.0__tar.gz → 0.19.0__tar.gz

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/CLAUDE.md

@@ -47,13 +47,13 @@ Managed with `uv` (hatchling build backend, src layout):
 - **Revoking access**: `InventoryTab` takes an optional `(action_label, action_callback)`; the callback gets the selected peer's key. The server's tab wires "Revoke access" → `ShareServer.revoke_client(client_id)` (removes the token via `PairedClients.revoke`, disconnects any live stream with a `denied: access revoked`, and `_drop` reports state "revoked"; a `_revoked` set distinguishes it from a plain disconnect). The client's tab wires "Forget server" → `KnownServers.forget(key)` + disconnect. After either, the next connection needs a fresh approval. Server and client each use a *separate table* (`server_peers` / `client_peers`, selected via the `table=` arg) so a machine running both apps doesn't commingle them; `peers` is the default table used by tests. `ConnectionInventory` never lets a DB error break connectivity (load/save are wrapped).
 - Sharing tests drive real sockets on the GUI thread by pumping `qapp.processEvents()` until a condition holds (see `pump()` in `tests/test_sharing.py`). Use the `make_server`/`make_client` helpers there and the session-scoped `credentials` fixture (one generated cert reused across tests — generating per test is ~100ms each). Tests exercise the real pairing flow (auto-approve), so there is no "pre-approve" shortcut anymore.
 - **Input forwarding**: `ViewerWidget` captures mouse/keyboard events and emits `inputEvent` dicts with coordinates normalized 0..1 over the *displayed* frame rect (letterboxing is reversed via `_display_rect()`; events outside the frame are dropped). Keys carry the client's `nativeVirtualKey()` — since both ends are Windows, the server injects that VK directly with no key-translation table. The client sends these as `{"type": "input", ...}`; `ShareServer` only injects input from streams that completed the hello/approval handshake.
-- **Modal-loop pump** (`modal_loop.py`): a Windows title-bar drag (or click-and-hold) puts the window's thread into a native modal move/size loop where Qt's dispatcher stops — for the server this deadlocked when a *remote* click grabbed the server window's own title bar (the mouse-up sat unread on the socket). `ServerWindow.nativeEvent` feeds `ModalLoopPump`, which runs a native `SetTimer` from `WM_NCLBUTTONDOWN` (a press-and-hold that never moves blocks in DefWindowProc's click tracking without ever sending `WM_ENTERSIZEMOVE`) until `WM_CAPTURECHANGED`/`WM_EXITSIZEMOVE`, whose callback pumps Qt events (user input excluded). Tests inject a fake `timers` backend — never let them create real Win32 timers.
+- **Modal-loop pump** (`modal_loop.py`): a Windows title-bar drag (or click-and-hold) puts the window's thread into a native modal move/size loop where Qt's dispatcher stops — for the server this deadlocked when a *remote* click grabbed the server window's own title bar (the mouse-up sat unread on the socket). `ServerWindow.nativeEvent` feeds `ModalLoopPump`, which runs a native `SetTimer` from `WM_NCLBUTTONDOWN` (a press-and-hold that never moves blocks in DefWindowProc's click tracking without ever sending `WM_ENTERSIZEMOVE`) until `WM_CAPTURECHANGED`/`WM_EXITSIZEMOVE`, whose callback pumps Qt events (user input excluded). The caption buttons (min/max/close) are the exception — their tracking loop dispatches only mouse messages, so no timer can pump inside it; the pump instead performs those via its `caption_action` callback on press and consumes the message (nativeEvent must return True when `handle_native_event` does), so DefWindowProc's button tracking never starts. Tests inject a fake `timers` backend — never let them create real Win32 timers.
 - **Log exchange**: either side can fetch the peer's debug log over the connection (`{"type": "log_request"}` → `{"type": "log", "text": ...}`, admitted streams only). `ShareServer`/`ShareClient` take a `log_provider=` callable (the windows pass `logs.read_log_tail("server"/"client")`, capped at `logs.TAIL_BYTES`); a missing provider/file answers with a placeholder rather than hanging the requester. Both windows have a "Get client log"/"Get server log" button in the Connection log tab; the reply opens a `logs.PeerLogDialog`. The server requests from the most recently admitted stream.
 - **Injection is isolated behind `InputInjector`** (`input_injection.py`, Windows `SendInput` via ctypes; inert stub off-Windows). ShareServer takes an `injector=` param so tests pass a recording fake — **never let tests construct a real `InputInjector`, or they will move the host's actual mouse/keyboard.** Normalized 0..1 coords map directly to SendInput's 0..65535 absolute range over the primary monitor.
 - **Transport is TLS + a token handshake** (`tls.py`, `sharing.py`, `config.py`). The Qt SSL backend here is Windows **schannel** (no OpenSSL); it does complete server-side TLS with a `cryptography`-generated self-signed cert loaded from PEM (verified), but be wary of schannel-specific quirks if you change the config. The server persists a self-signed cert/key under the config dir (`tls.load_or_create_credentials`; `ShareServer(credentials=...)`, or ephemeral if omitted). The client connects with `connectToHostEncrypted`, ignores the expected self-signed cert errors (`PeerVerifyMode.VerifyNone`), and pins the cert fingerprint **softly** — a change is logged but does *not* block the connection (robustness over strict security, per the trusted-LAN intent). Authentication: on first connect the server user approves and the server issues a random token (`PairedClients.pair`, stored server-side by client-id; client stores it in `KnownServers` keyed by `host:port` with the fingerprint). On reconnect the client sends the token in its hello and is admitted with no prompt; a missing/invalid token just falls back to re-approval (never hard-fails). **Do not reintroduce hard cert-pinning or challenge-response** — the user explicitly wanted robust connections over maximum security.
 - **Performance monitoring** (`performance.py` + `preferences.py`): `PerformanceMonitor` is an opt-in collaborator (`performance=` on `ShareServer`/`ShareClient`, the `clipboard=` pattern — plain sharing tests leave it off). While admitted streams are attached, a 1 s QTimer samples `MessageStream.bytes_sent/bytes_received` counters into rolling `MetricSeries` (bandwidth, aggregated across streams via per-stream baselines) and pings **every** attached stream (each ping id maps to its stream; a pong is honored only on the stream it was sent to). The graphs' RTT series follow only the *active* (most recently admitted) stream; per-stream send/recv/RTT snapshots come from `metrics_for(stream)` and feed the server's Status-tab `ViewersTable` (`server.py`), which joins them with `ShareServer.viewers()` — identity fields (`user`/`host`/`os`) that the client hello reports (`_client_details()`; missing on old clients, shown as dashes). The ping is: `{"type": "ping", "id", "rtt"}` / `{"type": "pong", "id"}` — each side measures its own RTT and piggybacks it on its next ping so both ends graph both directions; peers without the feature ignore pings harmlessly (RTT graphs show "no data"). Ping/pong is admitted-streams-only on the server, like input/clipboard. Both windows have a "Performance" tab (`PerformanceTab`, custom QPainter graphs) that schedules **no paint work while hidden** (gated on `isVisible()`, repaint on `showEvent`) and a "Preferences" tab whose history-window setting persists via the `Settings` store (`performance_window_seconds`, default 120). The monitor's timer runs only while streams are attached; all timing is `time.monotonic()` with an injectable `clock=` for tests — never monkeypatch `time.monotonic` (the test `pump()` helper depends on it).
 - **Clipboard sync is bidirectional** (`clipboard.py` `ClipboardSync`): client copy → server and server copy → all clients, as `{"type": "clipboard", "text"/"image_png"}` messages. It's opt-in — `ShareServer`/`ShareClient` take a `clipboard=` param and do nothing with clipboard if it's None, so only the GUIs (and clipboard tests) enable it; **plain sharing/input tests must leave it off to avoid touching the real OS clipboard.** Echo/loop prevention is by *content signature*, not just a guard flag, because Windows fires `QClipboard.dataChanged` asynchronously (after a flag would be cleared); image signatures hash canonical RGBA pixels so a re-encoded PNG round trip doesn't loop. Server only accepts clipboard from streams past the approval handshake. Tests use a `FakeClipboard(QObject)` with a `changed` signal and recording `apply()` so two independent clipboards exist in one process.
-- The package version lives only in `src/remotedesktop/__init__.py` (`__version__`); hatchling reads it from there (`[tool.hatch.version]`), so bump it in that one place.
+- The package version lives only in `src/remotedesktop/__init__.py` (`__version__`); hatchling reads it from there (`[tool.hatch.version]`), so bump it in that one place. **Versioning is strict semver** (`compat.py`, using the `semver` package): major = client/server compatibility contract, minor = backward-compatible features, patch = bug fixes — bump the major when the wire protocol or behavior breaks older peers. Both sides compare majors on every connection (hello/welcome carry `app_version`) and show a strong warning on mismatch (server status log + ⚠ in the viewers table's Version column; client log + non-modal dialog + status-bar marker) but never block the connection. Peers too old to report a version produce no warning.
 - Widget tests need a `QApplication`; use the session-scoped `qapp` fixture in `tests/conftest.py`.
 
 ## Environment Notes

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/PKG-INFO

@@ -1,7 +1,10 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.17.0
+Version: 0.19.0
 Summary: Remote desktop client/server for Windows computers on the same LAN, with autodiscovery. Provides screen, keyboard, mouse, and clipboard sharing without RDP or Microsoft authentication.
+Project-URL: Homepage, https://github.com/jamesabel/remotedesktop
+Project-URL: Repository, https://github.com/jamesabel/remotedesktop
+Project-URL: PyPI, https://pypi.org/project/remotedesktop/
 Author-email: James Abel <j@abel.co>
 License-Expression: MIT
 License-File: LICENSE
@@ -15,6 +18,7 @@ Requires-Python: >=3.14
 Requires-Dist: cryptography>=49.0.0
 Requires-Dist: platformdirs>=4.10.0
 Requires-Dist: pyside6>=6.11.1
+Requires-Dist: semver>=3.0
 Description-Content-Type: text/markdown
 
 # Remote Desktop
@@ -111,6 +115,16 @@ handshake messages until the server user admits them; access can be revoked
 at any time from the server's *Clients on LAN* tab. There is no dependency
 on Windows RDP or any Microsoft-based authentication.
 
+## Versioning
+
+The apps follow [semantic versioning](https://semver.org): the **major**
+version is the client/server compatibility contract (same major →
+guaranteed to interoperate), **minor** versions add backward-compatible
+features, **patch** versions fix bugs. On every connection each side
+compares its major version with the peer's; a mismatch shows a strong
+warning in both GUIs — connecting is still allowed, but the experience is
+not guaranteed. Keep both computers on the same version for best results.
+
 ## Requirements
 
 - Windows

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/pyproject.toml

@@ -18,8 +18,14 @@ dependencies = [
     "cryptography>=49.0.0",
     "platformdirs>=4.10.0",
     "pyside6>=6.11.1",
+    "semver>=3.0",
 ]
 
+[project.urls]
+Homepage = "https://github.com/jamesabel/remotedesktop"
+Repository = "https://github.com/jamesabel/remotedesktop"
+PyPI = "https://pypi.org/project/remotedesktop/"
+
 [project.gui-scripts]
 remotedesktop-client = "remotedesktop.client:main"
 remotedesktop-server = "remotedesktop.server:main"

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/readme.md

@@ -92,6 +92,16 @@ handshake messages until the server user admits them; access can be revoked
 at any time from the server's *Clients on LAN* tab. There is no dependency
 on Windows RDP or any Microsoft-based authentication.
 
+## Versioning
+
+The apps follow [semantic versioning](https://semver.org): the **major**
+version is the client/server compatibility contract (same major →
+guaranteed to interoperate), **minor** versions add backward-compatible
+features, **patch** versions fix bugs. On every connection each side
+compares its major version with the peer's; a mismatch shows a strong
+warning in both GUIs — connecting is still allowed, but the experience is
+not guaranteed. Keep both computers on the same version for best results.
+
 ## Requirements
 
 - Windows

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/src/remotedesktop/__init__.py

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

remotedesktop-0.19.0/src/remotedesktop/about.py

@@ -0,0 +1,71 @@
+"""The "About" tab, shared by the client and server windows.
+
+Shows the same metadata the PyPI page shows — summary, author, license,
+Python requirement, links — read from the installed package's metadata via
+importlib.metadata, with static fallbacks so the tab still renders in odd
+environments (the version always comes from `remotedesktop.__version__`,
+the single source hatchling packages)."""
+
+from importlib import metadata
+
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QLabel, QVBoxLayout, QWidget
+
+from remotedesktop import __version__, icon
+
+_HOMEPAGE = "https://github.com/jamesabel/remotedesktop"
+_PYPI = "https://pypi.org/project/remotedesktop/"
+_FALLBACKS = {
+    "Summary": (
+        "Remote desktop client/server for Windows computers on the same LAN, "
+        "with autodiscovery. Provides screen, keyboard, mouse, and clipboard "
+        "sharing without RDP or Microsoft authentication."
+    ),
+    "Author-email": "James Abel <j@abel.co>",
+    "License-Expression": "MIT",
+    "Requires-Python": ">=3.14",
+}
+
+
+def _field(name: str) -> str:
+    try:
+        value = metadata.metadata("remotedesktop").get(name)
+    except metadata.PackageNotFoundError:
+        value = None
+    return str(value) if value else _FALLBACKS.get(name, "")
+
+
+class AboutTab(QWidget):
+    """Package metadata as a rich-text page with clickable links."""
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        author = _field("Author-email").replace("<", "&lt;").replace(">", "&gt;")
+        body = QLabel(
+            f"""
+            <h2 style="margin-bottom:2px">Remote Desktop {__version__}</h2>
+            <p>{_field("Summary")}</p>
+            <table cellspacing="4">
+              <tr><td><b>Author</b></td><td>{author}</td></tr>
+              <tr><td><b>License</b></td><td>{_field("License-Expression")}</td></tr>
+              <tr><td><b>Python</b></td><td>{_field("Requires-Python")}</td></tr>
+              <tr><td><b>Package</b></td><td>remotedesktop</td></tr>
+            </table>
+            <p>
+              <a href="{_HOMEPAGE}">GitHub</a> &nbsp;·&nbsp;
+              <a href="{_PYPI}">PyPI</a>
+            </p>
+            """
+        )
+        body.setTextFormat(Qt.TextFormat.RichText)
+        body.setOpenExternalLinks(True)
+        body.setWordWrap(True)
+        body.setTextInteractionFlags(
+            Qt.TextInteractionFlag.TextBrowserInteraction
+        )
+        logo = QLabel()
+        logo.setPixmap(icon.app_icon("client").pixmap(48, 48))
+        layout = QVBoxLayout(self)
+        layout.addWidget(logo)
+        layout.addWidget(body)
+        layout.addStretch(1)

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/src/remotedesktop/client.py

@@ -23,7 +23,8 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
-from remotedesktop import db, icon, logs, window_state
+from remotedesktop import __version__, compat, db, icon, logs, window_state
+from remotedesktop.about import AboutTab
 from remotedesktop.logs import PeerLogDialog, read_log_tail
 from remotedesktop.clipboard import ClipboardSync
 from remotedesktop.config import KnownServers, Settings, default_db_path, load_client_identity
@@ -93,7 +94,7 @@ class ClientWindow(QMainWindow):
         self, *, connection: sqlite3.Connection | None = None, auto_scan: bool = True
     ) -> None:
         super().__init__()
-        self.setWindowTitle("Remote Desktop Client")
+        self.setWindowTitle(f"Remote Desktop Client {__version__}")
         self.setWindowIcon(icon.app_icon("client"))
         # Tests inject a connection to a temp database; the app uses the default.
         self._db = connection if connection is not None else db.connect(default_db_path())
@@ -133,6 +134,7 @@ class ClientWindow(QMainWindow):
         log_layout.addWidget(self.connection_log)
         tabs.addTab(log_tab, "Connection log")
         tabs.addTab(PreferencesTab(self._settings, self.performance), "Preferences")
+        tabs.addTab(AboutTab(), "About")
 
         self.discovery_panel.serverActivated.connect(self._on_server_activated)
         self.discovery_panel.serversFound.connect(self._record_discovered)
@@ -145,6 +147,7 @@ class ClientWindow(QMainWindow):
         self._client: ShareClient | None = None
         self._connected = False
         self._denied = False
+        self._version_mismatch = False
         self._server_name = ""
         self._server_key = ""
         self._frame_count = 0
@@ -196,6 +199,7 @@ class ClientWindow(QMainWindow):
         self._frame_count = 0
         self._connected = False
         self._denied = False
+        self._version_mismatch = False
         self.inventory.record(
             self._server_key, "attempt", name=server.name,
             address=self._server_key, detail=self._server_key,
@@ -230,13 +234,39 @@ class ClientWindow(QMainWindow):
             f"Waiting for the user on {self._server_name} to approve this computer …"
         )
 
+    def _server_label(self) -> str:
+        """The server's name with its app version when it reported one,
+        e.g. 'DEN-PC (0.19.0)' — flagged when its major version differs."""
+        version = self._client.server_app_version if self._client is not None else ""
+        if not version:
+            return self._server_name
+        marker = " ⚠ VERSION MISMATCH" if self._version_mismatch else ""
+        return f"{self._server_name} ({version}{marker})"
+
     def _on_connected(self, server_name: str) -> None:
         self._server_name = server_name or self._server_name
         self._connected = True
+        # Semver policy: matching majors are the compatibility contract. A
+        # mismatch warns loudly (log, dialog, status bar) but never blocks —
+        # the user may still try, with no guarantees.
+        server_version = self._client.server_app_version if self._client is not None else ""
+        warning = compat.mismatch_warning(__version__, server_version, "server")
+        self._version_mismatch = warning is not None
+        if warning:
+            self.log(warning)
+            box = QMessageBox(
+                QMessageBox.Icon.Warning,
+                "Version mismatch",
+                warning,
+                QMessageBox.StandardButton.Ok,
+                self,
+            )
+            box.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+            box.show()  # non-modal: streaming continues behind it
         self.inventory.record(self._server_key, "connected", name=self._server_name)
         self.viewer.setFocus()
         self.statusBar().showMessage(
-            f"Connected to {self._server_name} — waiting for first frame "
+            f"Connected to {self._server_label()} — waiting for first frame "
             "(click the view to control it)"
         )
 
@@ -279,7 +309,7 @@ class ClientWindow(QMainWindow):
         self._frame_count += 1
         self.viewer.show_frame(image)
         self.statusBar().showMessage(
-            f"Viewing {self._server_name} — {image.width()}x{image.height()} — "
+            f"Viewing {self._server_label()} — {image.width()}x{image.height()} — "
             f"{self._frame_count} frames received"
         )
 

remotedesktop-0.19.0/src/remotedesktop/compat.py

@@ -0,0 +1,38 @@
+"""Semantic-version compatibility policy for client/server connections.
+
+The apps follow semver (https://semver.org): the MAJOR version is the
+client/server compatibility contract — two apps with the same major are
+expected to interoperate, different majors may not. MINOR versions add
+backward-compatible features, PATCH versions fix bugs.
+
+On every connection each side compares its own major against the peer's
+(the hello and welcome messages carry `app_version`) and shows a strong
+warning on a mismatch. The connection is still allowed — the user may try —
+but nothing about it is guaranteed. Peers too old to report a version
+(pre-0.19) can't be compared and produce no warning.
+"""
+
+import semver
+
+
+def major_of(version: str) -> int | None:
+    """The semver major of `version`, or None when it isn't valid semver
+    (including the empty string an old peer implies)."""
+    try:
+        return semver.Version.parse(version).major
+    except (ValueError, TypeError):
+        return None
+
+
+def mismatch_warning(mine: str, theirs: str, peer: str) -> str | None:
+    """A strong user-facing warning when the major versions differ, else
+    None. `peer` names the other side ("client" or "server")."""
+    ours, others = major_of(mine), major_of(theirs)
+    if ours is None or others is None or ours == others:
+        return None
+    return (
+        f"WARNING: version mismatch — this app is {mine} but the {peer} is "
+        f"{theirs}. Different major versions are not guaranteed to work "
+        f"together: you can still connect, but features may fail or behave "
+        f"incorrectly. Update both computers to the same version."
+    )

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

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

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

@@ -7,7 +7,7 @@ import sqlite3
 import sys
 import time
 
-from PySide6.QtCore import QProcess, Qt
+from PySide6.QtCore import QProcess, Qt, QTimer
 from PySide6.QtGui import QCloseEvent, QShowEvent
 from PySide6.QtWidgets import (
     QAbstractItemView,
@@ -26,7 +26,8 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
-from remotedesktop import db, icon, logs, tls, window_state
+from remotedesktop import __version__, compat, db, icon, logs, tls, window_state
+from remotedesktop.about import AboutTab
 from remotedesktop.autostart import Autostart
 from remotedesktop.clipboard import ClipboardSync
 from remotedesktop.config import PairedClients, Settings, default_config_dir, default_db_path
@@ -37,7 +38,7 @@ from remotedesktop.discovery import (
 )
 from remotedesktop.inventory import ConnectionInventory, InventoryTab
 from remotedesktop.logs import PeerLogDialog, read_log_tail
-from remotedesktop.modal_loop import ModalLoopPump
+from remotedesktop.modal_loop import HTCLOSE, HTMAXBUTTON, HTMINBUTTON, ModalLoopPump
 from remotedesktop.performance import PerformanceMonitor, PerformanceTab, format_ms, format_rate
 from remotedesktop.preferences import PreferencesTab, load_performance_window_seconds
 from remotedesktop.sharing import ShareServer
@@ -55,14 +56,14 @@ class ViewersTable(QTableWidget):
     """
 
     _COLUMNS = [
-        "Name", "Address", "User", "Computer", "OS", "Send", "Receive",
+        "Name", "Address", "User", "Computer", "OS", "Version", "Send", "Receive",
         "RTT", "RTT mean", "RTT min", "RTT max", "RTT p99", "RTT jitter",
     ]
     # Metric cells change text every tick, so their columns get a constant
     # width (sized to the widest plausible value) instead of
     # ResizeToContents — otherwise the columns visibly jitter each second.
-    _RATE_COLUMNS = (5, 6)  # Send / Receive
-    _MS_COLUMNS = (7, 8, 9, 10, 11, 12)  # RTT latest + window statistics
+    _RATE_COLUMNS = (6, 7)  # Send / Receive
+    _MS_COLUMNS = (8, 9, 10, 11, 12, 13)  # RTT latest + window statistics
     _METRIC_COLUMNS = _RATE_COLUMNS + _MS_COLUMNS
 
     def __init__(self, share_server, performance: PerformanceMonitor, parent=None) -> None:
@@ -98,6 +99,16 @@ class ViewersTable(QTableWidget):
         super().showEvent(event)
         self.refresh()  # catch up on metrics accrued while hidden
 
+    @staticmethod
+    def _version_cell(version: str) -> str:
+        """The viewer's version, flagged when its semver major differs from
+        ours (compatibility is only guaranteed within a major)."""
+        if not version:
+            return "—"
+        if compat.mismatch_warning(__version__, version, "client") is not None:
+            return f"{version} ⚠"
+        return version
+
     def refresh(self) -> None:
         viewers = self._share_server.viewers()
         self.setRowCount(len(viewers))
@@ -111,6 +122,7 @@ class ViewersTable(QTableWidget):
                 viewer["user"] or "—",
                 viewer["host"] or "—",
                 viewer["os"] or "—",
+                self._version_cell(viewer["app_version"]),
                 format_rate(send) if send is not None else "—",
                 format_rate(recv) if recv is not None else "—",
                 format_ms(rtt) if rtt is not None else "—",
@@ -141,7 +153,7 @@ class ServerWindow(QMainWindow):
         autostart: Autostart | None = None,
     ) -> None:
         super().__init__()
-        self.setWindowTitle("Remote Desktop Server")
+        self.setWindowTitle(f"Remote Desktop Server {__version__}")
         self.setWindowIcon(icon.app_icon("server"))
         self._name = socket.gethostname()
 
@@ -167,7 +179,9 @@ class ServerWindow(QMainWindow):
         # drag — including one driven by an injected remote click), Qt stops
         # running; the pump keeps sockets and timers serviced so a remote
         # mouse-up can still arrive and end the drag instead of deadlocking.
-        self._modal_pump = ModalLoopPump()
+        # Caption-button presses (minimize/maximize/close) are handled by
+        # the pump directly — their native tracking loop cannot be pumped.
+        self._modal_pump = ModalLoopPump(caption_action=self._on_caption_button)
         self.restart_button = QPushButton("Restart server")
         self.restart_button.setToolTip(
             "Relaunch this app (e.g. after updating the software). It can be "
@@ -203,6 +217,7 @@ class ServerWindow(QMainWindow):
         )
         tabs.addTab(log_tab, "Connection log")
         tabs.addTab(PreferencesTab(self._settings, self.performance), "Preferences")
+        tabs.addTab(AboutTab(), "About")
         self.setCentralWidget(tabs)
 
         if credentials is None:
@@ -339,8 +354,22 @@ class ServerWindow(QMainWindow):
         title = f'Log from client "{client_name}"' if client_name else "Log from client"
         PeerLogDialog(title, text, self).show()
 
+    def _on_caption_button(self, hit_code: int) -> None:
+        # Deferred: the action (especially close) must not run inside the
+        # native message handler that reported the press.
+        if hit_code == HTMINBUTTON:
+            action = self.showMinimized
+        elif hit_code == HTMAXBUTTON:
+            action = self.showNormal if self.isMaximized() else self.showMaximized
+        elif hit_code == HTCLOSE:
+            action = self.close
+        else:
+            return
+        QTimer.singleShot(0, action)
+
     def nativeEvent(self, event_type, message):
-        self._modal_pump.handle_native_event(event_type, message)
+        if self._modal_pump.handle_native_event(event_type, message):
+            return True, 0
         return super().nativeEvent(event_type, message)
 
     def _ask_approval(self, client_id: str, client_name: str) -> bool:

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/src/remotedesktop/sharing.py

@@ -34,6 +34,7 @@ from PySide6.QtNetwork import (
     QTcpSocket,
 )
 
+from remotedesktop import __version__, compat
 from remotedesktop.config import (
     KnownServers,
     PairedClients,
@@ -298,7 +299,7 @@ class ShareServer(QObject):
             info = dict(self._viewer_info.get(stream, {}))
             info.setdefault("name", "")
             info.setdefault("address", _peer(stream.socket))
-            for field in ("user", "host", "os"):
+            for field in ("user", "host", "os", "app_version"):
                 info.setdefault(field, "")
             info["stream"] = stream
             result.append(info)
@@ -351,7 +352,16 @@ class ShareServer(QObject):
             "user": str(message.get("user", "")),
             "host": str(message.get("host", "")),
             "os": str(message.get("os", "")),
+            "app_version": str(message.get("app_version", "")),
         }
+        # Semver policy: majors must match for guaranteed interoperability.
+        # A mismatch is loudly reported but never blocks the connection.
+        warning = compat.mismatch_warning(
+            __version__, self._viewer_info[stream]["app_version"], "client"
+        )
+        if warning:
+            self.status.emit(warning)
+            _log.warning("%s", warning)
         if isinstance(client_id, str) and client_id:
             self._stream_key[stream] = (client_id, client_name, peer)
             self._emit_peer(stream, "attempt")
@@ -375,7 +385,15 @@ class ShareServer(QObject):
             self.status.emit(f'"{client_name}" authenticated with its paired token')
             self._revoked.discard(client_id)
             self._emit_peer(stream, "authenticated")
-            self._admit(stream, client_name, {"type": "welcome", "name": socket_module.gethostname()})
+            self._admit(
+                stream,
+                client_name,
+                {
+                    "type": "welcome",
+                    "name": socket_module.gethostname(),
+                    "app_version": __version__,
+                },
+            )
             return
 
         if existing:
@@ -411,7 +429,12 @@ class ShareServer(QObject):
         self._admit(
             stream,
             client_name,
-            {"type": "welcome", "name": socket_module.gethostname(), "token": token},
+            {
+                "type": "welcome",
+                "name": socket_module.gethostname(),
+                "token": token,
+                "app_version": __version__,
+            },
         )
 
     def _admit(self, stream: MessageStream, client_name: str, welcome: dict) -> None:
@@ -681,6 +704,7 @@ class ShareClient(QObject):
         self._server_key = ""
         self._server_fingerprint = ""
         self._server_token: str | None = None
+        self.server_app_version = ""
         self._frame_count = 0
         self._last_image: QImage | None = None  # delta patches build on this
         self._socket = QSslSocket(self)
@@ -707,6 +731,7 @@ class ShareClient(QObject):
         self._got_first_frame = False
         self._frame_count = 0
         self._last_image = None
+        self.server_app_version = ""
         self._server_key = f"{host}:{port}"
         record = self._known.get(self._server_key) if self._known else None
         self._server_token = record.get("token") if record else None
@@ -762,6 +787,7 @@ class ShareClient(QObject):
             "client_id": self._client_id,
             "name": self._name,
             "delta": True,  # we understand inter-frame delta messages
+            "app_version": __version__,
             **_client_details(),
         }
         if self._server_token:
@@ -794,6 +820,9 @@ class ShareClient(QObject):
         match message.get("type"):
             case "welcome":
                 name = str(message.get("name", ""))
+                # The server's app version, for display next to its name
+                # (empty from pre-0.19 servers).
+                self.server_app_version = str(message.get("app_version", ""))
                 token = message.get("token")
                 if self._known is not None:
                     if isinstance(token, str):

remotedesktop-0.19.0/tests/test_about.py

@@ -0,0 +1,36 @@
+from PySide6.QtWidgets import QLabel
+
+from remotedesktop import __version__
+from remotedesktop.about import AboutTab
+
+
+def tab_text(tab: AboutTab) -> str:
+    return "\n".join(label.text() for label in tab.findChildren(QLabel))
+
+
+def test_about_tab_shows_pypi_metadata(qapp):
+    tab = AboutTab()
+    text = tab_text(tab)
+    assert f"Remote Desktop {__version__}" in text
+    assert "MIT" in text
+    assert "James Abel" in text
+    assert "3.14" in text
+    assert "https://github.com/jamesabel/remotedesktop" in text
+    assert "https://pypi.org/project/remotedesktop/" in text
+    assert "screen, keyboard, mouse, and clipboard" in text
+
+
+def test_both_windows_have_an_about_tab(qapp, credentials, tmp_path):
+    from test_client_window import make_window as make_client_window
+    from test_server_window import make_window as make_server_window
+
+    server_window = make_server_window(credentials, tmp_path)
+    client_window = make_client_window(tmp_path)
+    try:
+        for window in (server_window, client_window):
+            tabs = window.centralWidget()
+            labels = [tabs.tabText(i) for i in range(tabs.count())]
+            assert labels[-1] == "About"
+    finally:
+        client_window.close()
+        server_window.close()

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/tests/test_client_window.py

@@ -58,6 +58,9 @@ def test_window_starts_disconnected(qapp, tmp_path):
     assert "Performance" in labels and "Preferences" in labels
     assert not window.performance._timer.isActive()  # idle: no periodic work
     assert not window.windowIcon().isNull()
+    from remotedesktop import __version__
+
+    assert window.windowTitle() == f"Remote Desktop Client {__version__}"
     window.close()
 
 
@@ -80,6 +83,10 @@ def test_connect_view_and_disconnect_full_flow(qapp, credentials, tmp_path):
         pump(qapp, lambda: window.viewer.has_frame)
         assert window._connected
         assert "Viewing" in window.statusBar().currentMessage()
+        # The welcome carried the server's app version for display.
+        from remotedesktop import __version__
+
+        assert f"({__version__})" in window.statusBar().currentMessage()
         key = f"127.0.0.1:{server.port}"
         assert window.inventory._peers[key].state == "connected"
 
@@ -179,6 +186,31 @@ def test_forget_server_disconnects_and_forgets(qapp, credentials, tmp_path, monk
         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()))
+    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))
+        pump(qapp, lambda: window.viewer.has_frame)
+        assert not window._version_mismatch  # same build on both ends
+        assert shown == []
+        # Re-run the connected handler as if the server had reported a
+        # different major version.
+        assert window._client is not None
+        window._client.server_app_version = "99.0.0"
+        window._on_connected("box")
+        assert window._version_mismatch
+        assert shown == ["Version mismatch"]  # strong, but non-modal
+        assert "WARNING: version mismatch" in window.connection_log.toPlainText()
+        assert "99.0.0 ⚠ VERSION MISMATCH" in window.statusBar().currentMessage()
+        assert window._connected  # the user may still use the connection
+    finally:
+        window.close()
+        server.close()
+
+
 def test_discovery_panel_lists_scan_results(qapp, monkeypatch):
     info = ServerInfo(name="box", host="10.0.0.7", port=1234)
     monkeypatch.setattr(client_module, "discover_servers", lambda: [info])

remotedesktop-0.19.0/tests/test_compat.py

@@ -0,0 +1,29 @@
+from remotedesktop import __version__
+from remotedesktop.compat import major_of, mismatch_warning
+
+
+def test_major_of_parses_semver():
+    assert major_of("0.18.0") == 0
+    assert major_of("1.2.3") == 1
+    assert major_of("10.0.0-rc.1") == 10
+    assert major_of("") is None
+    assert major_of("banana") is None
+    assert major_of("1.2") is None  # not full semver
+
+
+def test_same_major_or_unknown_produces_no_warning():
+    assert mismatch_warning("1.2.3", "1.9.0", "server") is None
+    assert mismatch_warning("0.18.0", "0.1.0", "client") is None
+    assert mismatch_warning("1.0.0", "", "server") is None  # pre-0.19 peer
+    assert mismatch_warning("", "1.0.0", "server") is None
+    assert mismatch_warning(__version__, __version__, "server") is None
+
+
+def test_major_mismatch_produces_a_strong_warning():
+    warning = mismatch_warning("1.2.3", "2.0.0", "server")
+    assert warning is not None
+    assert "WARNING" in warning
+    assert "1.2.3" in warning and "2.0.0" in warning
+    assert "server" in warning
+    assert "not guaranteed" in warning
+    assert "still connect" in warning  # the user may attempt anyway

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

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

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/tests/test_performance.py

@@ -284,6 +284,9 @@ def test_server_viewers_snapshot_carries_hello_details(qapp, credentials, tmp_pa
         viewer = viewers[0]
         assert viewer["name"] and viewer["user"] and viewer["host"]
         assert viewer["os"].startswith("Windows")
+        from remotedesktop import __version__
+
+        assert viewer["app_version"] == __version__
         assert "127.0.0.1" in viewer["address"]
         # The stream key links the snapshot to per-viewer metrics.
         pump(qapp, lambda: server_perf.metrics_for(viewer["stream"])["rtt_ms"] is not None)

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

@@ -75,6 +75,33 @@ def test_native_size_move_messages_drive_the_modal_pump(qapp, credentials, tmp_p
         window.close()
 
 
+def test_caption_button_press_minimizes_without_native_tracking(qapp, credentials, tmp_path):
+    import ctypes
+    from ctypes import wintypes
+
+    from shiboken6 import VoidPtr
+
+    from remotedesktop.modal_loop import HTMINBUTTON, WM_NCLBUTTONDOWN, ModalLoopPump
+    from test_modal_loop import FakeTimers
+
+    window = make_window(credentials, tmp_path)
+    try:
+        timers = FakeTimers()
+        window._modal_pump = ModalLoopPump(
+            pump=lambda: None, caption_action=window._on_caption_button, timers=timers
+        )
+        msg = wintypes.MSG()
+        msg.hWnd, msg.message, msg.wParam = 0xBEEF, WM_NCLBUTTONDOWN, HTMINBUTTON
+        result = window.nativeEvent(b"windows_generic_MSG", VoidPtr(ctypes.addressof(msg)))
+        assert result[0] is True  # consumed: DefWindowProc's tracking never starts
+        assert timers.calls == []  # and the pump never needed to arm
+        for _ in range(5):
+            qapp.processEvents()  # the deferred action runs on the event loop
+        assert window.isMinimized()
+    finally:
+        window.close()
+
+
 def test_window_listens_and_is_discoverable(qapp, credentials, tmp_path):
     window = make_window(credentials, tmp_path)
     try:
@@ -87,6 +114,9 @@ def test_window_listens_and_is_discoverable(qapp, credentials, tmp_path):
         assert "Performance" in labels and "Preferences" in labels
         assert not window.performance._timer.isActive()  # idle: no periodic work
         assert not window.windowIcon().isNull()
+        from remotedesktop import __version__
+
+        assert window.windowTitle() == f"Remote Desktop Server {__version__}"
     finally:
         window.close()
 
@@ -217,11 +247,14 @@ def test_viewers_table_lists_connected_client_details(qapp, credentials, tmp_pat
             item = window.viewers_table.item(0, column)
             assert item is not None
             row.append(item.text())
-        name, address, user, host, os_info, send, recv, rtt = row[:8]
-        # The hello carried this machine's real login/host/OS details.
+        name, address, user, host, os_info, version, send, recv, rtt = row[:9]
+        # The hello carried this machine's real login/host/OS/version details.
         assert name and user != "—" and host != "—"
         assert "127.0.0.1" in address and "::ffff:" not in address
         assert os_info.startswith("Windows")
+        from remotedesktop import __version__
+
+        assert version == __version__
         # No monitor tick has necessarily run yet; metrics are dashes or values.
         assert send and recv and rtt
         client.close()
@@ -250,7 +283,10 @@ def test_viewers_table_metric_columns_keep_constant_width(qapp):
 
     stream = FakeStream()
     monitor = PerformanceMonitor()
-    viewer = {"name": "n", "address": "a", "user": "u", "host": "h", "os": "o", "stream": stream}
+    viewer = {
+        "name": "n", "address": "a", "user": "u", "host": "h", "os": "o",
+        "app_version": "1.0", "stream": stream,
+    }
     table = ViewersTable(FakeShareServer([viewer]), monitor)
     widths = [table.columnWidth(c) for c in ViewersTable._METRIC_COLUMNS]
     assert all(w > 0 for w in widths)
@@ -268,10 +304,48 @@ def test_viewers_table_metric_columns_keep_constant_width(qapp):
     rtt_series.add(1234.5)
     table.refresh()
     assert [table.columnWidth(c) for c in ViewersTable._METRIC_COLUMNS] == widths
-    send_item = table.item(0, 5)
+    send_item = table.item(0, ViewersTable._RATE_COLUMNS[0])
     assert send_item is not None and send_item.text() == "250.0 MB/s"
 
 
+def test_viewers_table_flags_a_major_version_mismatch(qapp):
+    from PySide6.QtCore import QObject, Signal
+
+    from remotedesktop import __version__
+    from remotedesktop.performance import PerformanceMonitor
+    from remotedesktop.server import ViewersTable
+    from test_performance import FakeStream
+
+    class FakeShareServer(QObject):
+        clientCountChanged = Signal(int)
+
+        def __init__(self, viewers):
+            super().__init__()
+            self._viewers = viewers
+
+        def viewers(self):
+            return self._viewers
+
+    def viewer(version, stream):
+        return {
+            "name": "n", "address": "a", "user": "u", "host": "h", "os": "o",
+            "app_version": version, "stream": stream,
+        }
+
+    same, other, old = FakeStream(), FakeStream(), FakeStream()
+    table = ViewersTable(
+        FakeShareServer([viewer(__version__, same), viewer("99.0.0", other), viewer("", old)]),
+        PerformanceMonitor(),
+    )
+    column = ViewersTable._COLUMNS.index("Version")
+    cells = []
+    for row in range(3):
+        item = table.item(row, column)
+        assert item is not None
+        cells.append(item.text())
+    assert cells == [__version__, "99.0.0 ⚠", "—"]
+
+
 def test_refused_approval_denies_client(qapp, credentials, tmp_path, monkeypatch):
     stub_approval_prompt(monkeypatch, QMessageBox.StandardButton.No)
     window = make_window(credentials, tmp_path)

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/tests/test_sharing.py

@@ -47,6 +47,32 @@ def make_client(tmp_path, *, clipboard=None, log_provider=None):
     )
 
 
+def test_server_status_reports_version_mismatch(qapp, credentials, tmp_path, monkeypatch):
+    # Both ends share this process's __version__, so a real mismatch can't
+    # occur here; patch the policy function to prove the hello wiring emits
+    # its warning into the status log (and never blocks the connection).
+    from remotedesktop import sharing
+
+    monkeypatch.setattr(
+        sharing.compat,
+        "mismatch_warning",
+        lambda mine, theirs, peer: f"WARNING: version mismatch — test ({peer} {theirs})",
+    )
+    server = make_server(credentials, tmp_path, approve=lambda *_: True)
+    statuses = []
+    server.status.connect(statuses.append)
+    client = make_client(tmp_path)
+    connected = []
+    client.connected.connect(connected.append)
+    client.connect_to("127.0.0.1", server.port)
+    try:
+        pump(qapp, lambda: connected)  # still admitted despite the warning
+        assert any("WARNING: version mismatch" in s for s in statuses)
+    finally:
+        client.close()
+        server.close()
+
+
 def test_first_connection_prompts_pairs_and_streams(qapp, credentials, tmp_path):
     prompts = []
     server = make_server(

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

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

{remotedesktop-0.17.0 → remotedesktop-0.19.0}/uv.lock

@@ -348,6 +348,7 @@ dependencies = [
     { name = "cryptography" },
     { name = "platformdirs" },
     { name = "pyside6" },
+    { name = "semver" },
 ]
 
 [package.dev-dependencies]
@@ -362,6 +363,7 @@ requires-dist = [
     { name = "cryptography", specifier = ">=49.0.0" },
     { name = "platformdirs", specifier = ">=4.10.0" },
     { name = "pyside6", specifier = ">=6.11.1" },
+    { name = "semver", specifier = ">=3.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -371,6 +373,15 @@ dev = [
     { name = "pytest-cov", specifier = ">=7.1.0" },
 ]
 
+[[package]]
+name = "semver"
+version = "3.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/d1/d3159231aec234a59dd7d601e9dd9fe96f3afff15efd33c1070019b26132/semver-3.0.4.tar.gz", hash = "sha256:afc7d8c584a5ed0a11033af086e8af226a9c0b206f313e0301f8dd7b6b589602", size = 269730, upload-time = "2025-01-24T13:19:27.617Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/24/4d91e05817e92e3a61c8a21e08fd0f390f5301f1c448b137c57c4bc6e543/semver-3.0.4-py3-none-any.whl", hash = "sha256:9c824d87ba7f7ab4a1890799cec8596f15c1241cb473404ea1cb0c55e4b04746", size = 17912, upload-time = "2025-01-24T13:19:24.949Z" },
+]
+
 [[package]]
 name = "shiboken6"
 version = "6.11.1"