remotedesktop 0.18.0__tar.gz → 0.19.0__tar.gz

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

@@ -53,7 +53,7 @@ Managed with `uv` (hatchling build backend, src layout):
 - **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.18.0 → remotedesktop-0.19.0}/PKG-INFO

@@ -1,7 +1,10 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.18.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.18.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.18.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.18.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.18.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.18.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.18.0 → remotedesktop-0.19.0}/src/remotedesktop/server.py

@@ -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
@@ -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()
 
@@ -205,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:

{remotedesktop-0.18.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.18.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.18.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.18.0 → remotedesktop-0.19.0}/tests/test_server_window.py

@@ -114,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()
 
@@ -244,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()
@@ -277,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)
@@ -295,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.18.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.18.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"