remotedesktop 0.18.0__tar.gz → 0.20.0__tar.gz

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

@@ -36,7 +36,7 @@ Managed with `uv` (hatchling build backend, src layout):
 ## Architecture
 
 - Both apps are PySide6 GUI applications. `src/remotedesktop/client.py` (`ClientWindow`) and `src/remotedesktop/server.py` (`ServerWindow`) hold the app entry points; `main()` in each is wired to the `remotedesktop-client` / `remotedesktop-server` GUI scripts in `pyproject.toml`.
-- The client-side remote desktop view is a widget, `ViewerWidget` in `src/remotedesktop/viewer.py`, hosted as `ClientWindow`'s central widget. Screen display and keyboard/mouse/clipboard forwarding belong in this widget, not in the window.
+- The client-side remote desktop view is a widget, `ViewerWidget` in `src/remotedesktop/viewer.py`. Screen display and keyboard/mouse/clipboard forwarding belong in this widget, not in the window. **The client supports multiple simultaneous server connections**: each is a `ServerSession` in `client.py` (its own `ShareClient` + `ViewerWidget`), shown as a closable tab at the front of `ClientWindow`'s central `QTabWidget`, titled with the server's reported hostname (fixed tabs get their close buttons stripped). Sessions are keyed by `host:port`; activating an already-known server reconnects in its existing tab, activating a connected one just focuses it. The window title lists the connected server names (`_update_window_title`), and the status bar follows the currently selected session tab (`status_text` per session). The `PerformanceMonitor`, `ClipboardSync`, inventory, and Connection log are shared across sessions — the monitor aggregates all attached streams, and `performance.reset()` is only called when no *other* session is connected (resetting detaches every stream). Per-session status log lines are prefixed `[name]`.
 - **Autodiscovery** (`src/remotedesktop/discovery.py`) is a stdlib-only UDP probe/response protocol, deliberately not mDNS: the client broadcasts a JSON probe to `DISCOVERY_PORT` (48653) and servers reply with `{name, port}`; datagrams with the wrong magic/version/type are dropped. The server runs a `DiscoveryResponder` thread while its window is open; the client's `DiscoveryPanel` (dock in `ClientWindow`) calls the blocking `discover_servers()` on a worker thread and delivers results to the GUI via a queued signal. `DEFAULT_CONNECT_PORT` (48654) is reserved for the future desktop connection.
 - Discovery tests run over loopback with ephemeral ports (`bind_host`/`discovery_port`/`broadcast_hosts` parameters exist for this), so they never touch the real LAN or fixed ports.
 - **Screen sharing** (`sharing.py` + `protocol.py` + `frames.py`) runs entirely on the Qt event loop — no threads or locks. `MessageStream` frames messages over a QTcpSocket (4-byte length + kind byte; JSON control messages, full frames, or inter-frame deltas; malformed input aborts the socket). `ShareServer` owns one QTimer that grabs the primary screen at full resolution via `_capture()` (a seam tests override to drive deterministic frame content) and fans out to all clients, skipping clients whose send buffer is backlogged; the timer only runs while clients are connected. Capture is DXGI desktop duplication (`dxgi.py`, hand-rolled ctypes COM — ~10 ms per changed 4K frame, ~0 when idle, and "unchanged" is signalled by returning the same QImage object so the diff is skipped) with automatic fallback to `QScreen.grabWindow` (~96 ms) whenever duplication is unavailable or lost (secure desktop, RDP, display-mode change, CI); unit tests fake the duplication (`FakeDuplication` in `tests/test_dxgi.py`) and the real-hardware test skips where DXGI is unavailable. **Frame transfer is lossless and inter-frame compressed** (`frames.py`): consecutive captures are diffed in 64-row bands (memoryview compares), and only changed bands ship as PNG in a delta payload the client patches onto its previous frame; an unchanged screen sends nothing. Full PNG keyframes go to clients that just joined, just recovered from a send backlog, or requested one (a `{"type": "keyframe"}` message — sent when a delta fails to apply, so desync self-heals). The capability is negotiated via `"delta": true` in the client hello; clients without it (0.5.0) get full JPEG frames every tick because they force-decode frames as JPEG — never send them PNG. Each variant (legacy JPEG / keyframe PNG / delta) is encoded at most once per tick and shared across clients. `ShareClient` decodes/patches to QImage for the viewer, which displays it scaled with a cached `SmoothTransformation` copy (full resolution is always delivered; scaling happens client-side only).
@@ -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.20.0}/PKG-INFO

@@ -1,7 +1,10 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.18.0
+Version: 0.20.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
@@ -43,9 +47,11 @@ Microsoft accounts, no cloud: just two apps and your LAN.
 ![Client demo](https://raw.githubusercontent.com/jamesabel/remotedesktop/master/docs/media/client-demo.gif)
 
 The client discovers the server on the LAN, connects, and streams its
-desktop live in the *Remote Screen* tab — click into the view and your mouse
-and keyboard control the remote machine. The *Performance* tab graphs
-bandwidth and round-trip time with live statistics.
+desktop live in a tab named after that computer — click into the view and
+your mouse and keyboard control the remote machine. Connect to several
+servers at once and each gets its own tab; the window title lists every
+connected computer. The *Performance* tab graphs bandwidth and round-trip
+time with live statistics.
 
 ### Server
 
@@ -58,6 +64,7 @@ time with mean/min/max/p99/jitter over the recent window).
 ## Features
 
 - 🔍 **Autodiscovery** — servers announce themselves over UDP; the client lists every server on the LAN, no addresses to type.
+- 🗂️ **Multiple servers at once** — one client can view and control several servers simultaneously, each in its own tab named for that computer; the window title shows who you're connected to, even minimized.
 - 🖥️ **Lossless screen sharing** — pixel-exact at full resolution, DXGI desktop-duplication capture (~10 ms per 4K frame), and inter-frame delta compression: an unchanged screen sends nothing.
 - ⌨️🖱️ **Full input control** — mouse, wheel, and keyboard forwarding that is safe against interruptions: anything still held down is released on the server if the viewer loses focus or disconnects, so no stuck keys.
 - 📋 **Two-way clipboard** — text and images copied on either machine appear on the other.
@@ -111,6 +118,70 @@ 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.
 
+## How it works
+
+All of this is pure Python — the GUIs are PySide6 (Qt), and the two places
+that need to talk to Windows directly (screen capture and input injection)
+call the Win32/COM APIs through `ctypes`, so there are no native extensions
+to compile.
+
+**Screen capture.** The server grabs the desktop with the **DXGI desktop
+duplication API**, driven directly through `ctypes` COM calls. Desktop
+duplication is the mechanism Windows provides for exactly this job: the
+compositor hands over a GPU texture of the screen and tells you whether
+anything changed, so a changed 4K frame costs about 10 ms to read back and
+an idle screen costs essentially nothing. When duplication is unavailable
+or gets lost — the secure desktop (UAC/logon screen), an RDP session, a
+display-mode change — the server transparently falls back to Qt's
+`QScreen.grabWindow` (~96 ms per frame) and keeps retrying duplication in
+the background.
+
+**Screen transfer.** Frames are captured at up to 30 fps and compared with
+the previous capture in 64-row bands; only the bands that changed are
+encoded — losslessly, as PNG — and sent as a delta the client patches onto
+its last frame. An unchanged screen sends nothing at all. Full PNG
+keyframes go to clients that just connected, fell behind (a client whose
+socket backlog grows gets frames dropped, then a fresh keyframe once it
+catches up), or asked for one because a delta failed to apply — so a
+desynced stream heals itself. The frame always travels at the server's
+full resolution; scaling to the viewer window happens on the client.
+
+**Input injection.** The client's viewer widget captures your mouse and
+keyboard events, maps mouse positions to coordinates normalized 0..1 over
+the displayed frame (so window size and letterboxing don't matter), and
+sends them as small JSON messages. The server injects them with the Win32
+**`SendInput`** API: normalized coordinates map onto SendInput's 0..65535
+absolute coordinate space over the primary monitor, and keystrokes carry
+the client's native virtual-key codes, which are injected as-is — both
+ends are Windows, so no key translation is needed. The server only injects
+input from clients that have passed the approval handshake, and anything
+still held down (a dragged button, a modifier key) is released
+automatically if the viewer disconnects or loses focus.
+
+**Clipboard.** Both sides watch their local clipboard via Qt and forward
+copies (text, or images as PNG) over the same connection. Echo loops are
+prevented by content signature — an image is hashed by its canonical
+pixels, so a PNG that makes a round trip through the OS clipboard and
+comes back re-encoded is still recognized and not sent again.
+
+**Transport.** Each client talks to the server over a single TCP
+connection: TLS via the Windows schannel backend with a self-signed
+certificate the server generates and keeps, then simple length-prefixed
+messages on top — JSON for control (hello/welcome, input, clipboard,
+ping/pong for the round-trip-time graphs, log exchange) and binary
+payloads for frames and deltas. Discovery is a UDP broadcast probe that
+every server answers with its name and port (see below).
+
+## 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.20.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.20.0}/readme.md

@@ -24,9 +24,11 @@ Microsoft accounts, no cloud: just two apps and your LAN.
 ![Client demo](https://raw.githubusercontent.com/jamesabel/remotedesktop/master/docs/media/client-demo.gif)
 
 The client discovers the server on the LAN, connects, and streams its
-desktop live in the *Remote Screen* tab — click into the view and your mouse
-and keyboard control the remote machine. The *Performance* tab graphs
-bandwidth and round-trip time with live statistics.
+desktop live in a tab named after that computer — click into the view and
+your mouse and keyboard control the remote machine. Connect to several
+servers at once and each gets its own tab; the window title lists every
+connected computer. The *Performance* tab graphs bandwidth and round-trip
+time with live statistics.
 
 ### Server
 
@@ -39,6 +41,7 @@ time with mean/min/max/p99/jitter over the recent window).
 ## Features
 
 - 🔍 **Autodiscovery** — servers announce themselves over UDP; the client lists every server on the LAN, no addresses to type.
+- 🗂️ **Multiple servers at once** — one client can view and control several servers simultaneously, each in its own tab named for that computer; the window title shows who you're connected to, even minimized.
 - 🖥️ **Lossless screen sharing** — pixel-exact at full resolution, DXGI desktop-duplication capture (~10 ms per 4K frame), and inter-frame delta compression: an unchanged screen sends nothing.
 - ⌨️🖱️ **Full input control** — mouse, wheel, and keyboard forwarding that is safe against interruptions: anything still held down is released on the server if the viewer loses focus or disconnects, so no stuck keys.
 - 📋 **Two-way clipboard** — text and images copied on either machine appear on the other.
@@ -92,6 +95,70 @@ 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.
 
+## How it works
+
+All of this is pure Python — the GUIs are PySide6 (Qt), and the two places
+that need to talk to Windows directly (screen capture and input injection)
+call the Win32/COM APIs through `ctypes`, so there are no native extensions
+to compile.
+
+**Screen capture.** The server grabs the desktop with the **DXGI desktop
+duplication API**, driven directly through `ctypes` COM calls. Desktop
+duplication is the mechanism Windows provides for exactly this job: the
+compositor hands over a GPU texture of the screen and tells you whether
+anything changed, so a changed 4K frame costs about 10 ms to read back and
+an idle screen costs essentially nothing. When duplication is unavailable
+or gets lost — the secure desktop (UAC/logon screen), an RDP session, a
+display-mode change — the server transparently falls back to Qt's
+`QScreen.grabWindow` (~96 ms per frame) and keeps retrying duplication in
+the background.
+
+**Screen transfer.** Frames are captured at up to 30 fps and compared with
+the previous capture in 64-row bands; only the bands that changed are
+encoded — losslessly, as PNG — and sent as a delta the client patches onto
+its last frame. An unchanged screen sends nothing at all. Full PNG
+keyframes go to clients that just connected, fell behind (a client whose
+socket backlog grows gets frames dropped, then a fresh keyframe once it
+catches up), or asked for one because a delta failed to apply — so a
+desynced stream heals itself. The frame always travels at the server's
+full resolution; scaling to the viewer window happens on the client.
+
+**Input injection.** The client's viewer widget captures your mouse and
+keyboard events, maps mouse positions to coordinates normalized 0..1 over
+the displayed frame (so window size and letterboxing don't matter), and
+sends them as small JSON messages. The server injects them with the Win32
+**`SendInput`** API: normalized coordinates map onto SendInput's 0..65535
+absolute coordinate space over the primary monitor, and keystrokes carry
+the client's native virtual-key codes, which are injected as-is — both
+ends are Windows, so no key translation is needed. The server only injects
+input from clients that have passed the approval handshake, and anything
+still held down (a dragged button, a modifier key) is released
+automatically if the viewer disconnects or loses focus.
+
+**Clipboard.** Both sides watch their local clipboard via Qt and forward
+copies (text, or images as PNG) over the same connection. Echo loops are
+prevented by content signature — an image is hashed by its canonical
+pixels, so a PNG that makes a round trip through the OS clipboard and
+comes back re-encoded is still recognized and not sent again.
+
+**Transport.** Each client talks to the server over a single TCP
+connection: TLS via the Windows schannel backend with a self-signed
+certificate the server generates and keeps, then simple length-prefixed
+messages on top — JSON for control (hello/welcome, input, clipboard,
+ping/pong for the round-trip-time graphs, log exchange) and binary
+payloads for frames and deltas. Discovery is a UDP broadcast probe that
+every server answers with its name and port (see below).
+
+## 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.20.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.20.0"

remotedesktop-0.20.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)