remotedesktop 0.14.0__tar.gz → 0.17.0__tar.gz

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

@@ -51,7 +51,7 @@ Managed with `uv` (hatchling build backend, src layout):
 - **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 the most recently admitted stream: `{"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).
+- **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.
 - Widget tests need a `QApplication`; use the session-scoped `qapp` fixture in `tests/conftest.py`.

remotedesktop-0.17.0/PKG-INFO

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: remotedesktop
+Version: 0.17.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.
+Author-email: James Abel <j@abel.co>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.14
+Requires-Dist: cryptography>=49.0.0
+Requires-Dist: platformdirs>=4.10.0
+Requires-Dist: pyside6>=6.11.1
+Description-Content-Type: text/markdown
+
+# Remote Desktop
+
+[![CI](https://github.com/jamesabel/remotedesktop/actions/workflows/ci.yml/badge.svg)](https://github.com/jamesabel/remotedesktop/actions/workflows/ci.yml)
+![Coverage](https://raw.githubusercontent.com/jamesabel/remotedesktop/badges/coverage.svg)
+[![PyPI](https://img.shields.io/pypi/v/remotedesktop)](https://pypi.org/project/remotedesktop/)
+![Python](https://img.shields.io/badge/python-3.14%2B-blue)
+![License: MIT](https://img.shields.io/badge/license-MIT-green)
+
+**Lossless, low-latency remote desktop for Windows computers on your LAN — pure Python, zero configuration.**
+
+Run the server on the computer you want to reach and the client anywhere else
+on the network: the server is discovered automatically, the first connection
+is approved with one click on the server side, and from then on the client
+reconnects instantly whenever the server is running. The screen stream is
+pixel-exact at full resolution — built for documents, code, and terminals
+rather than video — captured with DXGI desktop duplication and delta-compressed
+so only the parts of the screen that changed are sent. No Windows RDP, no
+Microsoft accounts, no cloud: just two apps and your LAN.
+
+## See it in action
+
+### Client
+
+![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.
+
+### Server
+
+![Server demo](https://raw.githubusercontent.com/jamesabel/remotedesktop/master/docs/media/server-demo.gif)
+
+The server's *Status* tab shows every connected viewer — who they are (login
+name, computer, OS) and how the connection is doing (bandwidth, round-trip
+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.
+- 🖥️ **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.
+- 🔒 **TLS + approve-once pairing** — every connection is encrypted; the server user approves a new client once, after which it reconnects with a stored token and no prompt.
+- 📊 **Built-in performance monitoring** — live bandwidth and round-trip-time graphs with window statistics (mean/min/max/p99/jitter), plus a per-viewer table on the server.
+- 🔁 **Robust connections** — dead connections are detected and dropped within seconds, and approved clients reconnect automatically without ceremony.
+- 🚀 **Hands-off operation** — optional start-at-login (per-user, no admin rights) and a *Restart server* button usable from the remote session itself, so you can update the software without visiting the machine.
+- 🗃️ **Persistent peer inventory** — both apps keep a SQLite-backed history of every peer seen on the LAN, with one-click *revoke access* / *forget server*.
+
+In scope: screen, keyboard, mouse, and clipboard. Out of scope: shared
+drives, devices, and audio — and smooth playback of fast-changing
+full-screen content (video, games) is a non-goal; the stream is optimized
+for mostly-static desktop work.
+
+## Installation
+
+```
+pip install remotedesktop
+```
+
+or, with [uv](https://docs.astral.sh/uv/):
+
+```
+uv tool install remotedesktop
+```
+
+Or run straight from a clone of this repository: double-click
+`run_server.bat` on the computer to be shared and `run_client.bat` on the
+viewing computer — each prepares the environment on first use and launches
+the app.
+
+## Quick start
+
+1. On the computer to share, run `remotedesktop-server`.
+2. On the viewing computer, run `remotedesktop-client` — the server appears
+   in its *Servers* panel; double-click it.
+3. Approve the connection in the dialog that pops up on the server. That's
+   it — future connections from that client need no approval.
+
+From a terminal in a clone of this repo, the same apps run with
+`uv run remotedesktop-server` and `uv run remotedesktop-client`.
+
+## Security model
+
+Connections are TLS-encrypted with a self-signed certificate the server
+generates once and keeps. The trust model is tuned for a **trusted LAN**:
+certificates are trusted on first use and a changed fingerprint is logged
+rather than blocking the connection, favoring reliable reconnection over
+strict certificate checking. Unapproved clients are limited to small
+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.
+
+## Requirements
+
+- Windows
+- Python 3.14+
+
+## How discovery works
+
+The client broadcasts a small JSON probe over UDP (port 48653); each server
+on the LAN replies with its hostname and connection port. Windows Firewall
+must allow Python to receive inbound UDP on that port for a server to be
+discoverable from other machines.
+
+## Development
+
+```
+uv sync          # set up the environment
+uv run pytest    # run the tests
+```
+
+Run the tests from PowerShell or cmd, not Git Bash: Git Bash puts Git's
+MinGW OpenSSL DLLs on `PATH`, which Qt's TLS backend loads and crashes on.
+From PowerShell, Qt uses the Windows schannel backend as intended.
+
+The demo GIFs above are generated — entirely from synthetic data — by
+`uv run python tools/make_demo_gifs.py`.
+
+### The `badges` branch
+
+The coverage badge above is served from the `badges` branch
+(`raw.githubusercontent.com/.../badges/coverage.svg`). CI regenerates the
+SVG after each test run on `master` and force-pushes it there as a single
+orphan commit. It lives on its own branch because `master` only accepts
+pull requests (a repository ruleset), so CI cannot commit to it directly;
+keeping the badge in the repo avoids depending on an external coverage
+service. The branch is generated output — never branch from it or merge it.

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

@@ -1,46 +1,47 @@
-[project]
-name = "remotedesktop"
-dynamic = ["version"]
-description = "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."
-readme = "readme.md"
-license = "MIT"
-authors = [{ name = "James Abel", email = "j@abel.co" }]
-requires-python = ">=3.14"
-classifiers = [
-    "Development Status :: 2 - Pre-Alpha",
-    "Environment :: Win32 (MS Windows)",
-    "Intended Audience :: End Users/Desktop",
-    "Operating System :: Microsoft :: Windows",
-    "Programming Language :: Python :: 3",
-    "Topic :: System :: Networking",
-]
-dependencies = [
-    "cryptography>=49.0.0",
-    "platformdirs>=4.10.0",
-    "pyside6>=6.11.1",
-]
-
-[project.gui-scripts]
-remotedesktop-client = "remotedesktop.client:main"
-remotedesktop-server = "remotedesktop.server:main"
-
-[dependency-groups]
-dev = [
-    "pytest>=8",
-    "pytest-cov>=7.1.0",
-]
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.version]
-path = "src/remotedesktop/__init__.py"
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-
-[tool.ty.environment]
-# The app targets Windows (SendInput via ctypes.windll); type-check as such
-# even when ty runs on a Linux CI runner.
-python-platform = "win32"
+[project]
+name = "remotedesktop"
+dynamic = ["version"]
+description = "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."
+readme = "readme.md"
+license = "MIT"
+authors = [{ name = "James Abel", email = "j@abel.co" }]
+requires-python = ">=3.14"
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Environment :: Win32 (MS Windows)",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Topic :: System :: Networking",
+]
+dependencies = [
+    "cryptography>=49.0.0",
+    "platformdirs>=4.10.0",
+    "pyside6>=6.11.1",
+]
+
+[project.gui-scripts]
+remotedesktop-client = "remotedesktop.client:main"
+remotedesktop-server = "remotedesktop.server:main"
+
+[dependency-groups]
+dev = [
+    "pillow>=12.3.0",
+    "pytest>=8",
+    "pytest-cov>=7.1.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+path = "src/remotedesktop/__init__.py"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ty.environment]
+# The app targets Windows (SendInput via ctypes.windll); type-check as such
+# even when ty runs on a Linux CI runner.
+python-platform = "win32"

remotedesktop-0.17.0/readme.md

@@ -0,0 +1,129 @@
+# Remote Desktop
+
+[![CI](https://github.com/jamesabel/remotedesktop/actions/workflows/ci.yml/badge.svg)](https://github.com/jamesabel/remotedesktop/actions/workflows/ci.yml)
+![Coverage](https://raw.githubusercontent.com/jamesabel/remotedesktop/badges/coverage.svg)
+[![PyPI](https://img.shields.io/pypi/v/remotedesktop)](https://pypi.org/project/remotedesktop/)
+![Python](https://img.shields.io/badge/python-3.14%2B-blue)
+![License: MIT](https://img.shields.io/badge/license-MIT-green)
+
+**Lossless, low-latency remote desktop for Windows computers on your LAN — pure Python, zero configuration.**
+
+Run the server on the computer you want to reach and the client anywhere else
+on the network: the server is discovered automatically, the first connection
+is approved with one click on the server side, and from then on the client
+reconnects instantly whenever the server is running. The screen stream is
+pixel-exact at full resolution — built for documents, code, and terminals
+rather than video — captured with DXGI desktop duplication and delta-compressed
+so only the parts of the screen that changed are sent. No Windows RDP, no
+Microsoft accounts, no cloud: just two apps and your LAN.
+
+## See it in action
+
+### Client
+
+![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.
+
+### Server
+
+![Server demo](https://raw.githubusercontent.com/jamesabel/remotedesktop/master/docs/media/server-demo.gif)
+
+The server's *Status* tab shows every connected viewer — who they are (login
+name, computer, OS) and how the connection is doing (bandwidth, round-trip
+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.
+- 🖥️ **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.
+- 🔒 **TLS + approve-once pairing** — every connection is encrypted; the server user approves a new client once, after which it reconnects with a stored token and no prompt.
+- 📊 **Built-in performance monitoring** — live bandwidth and round-trip-time graphs with window statistics (mean/min/max/p99/jitter), plus a per-viewer table on the server.
+- 🔁 **Robust connections** — dead connections are detected and dropped within seconds, and approved clients reconnect automatically without ceremony.
+- 🚀 **Hands-off operation** — optional start-at-login (per-user, no admin rights) and a *Restart server* button usable from the remote session itself, so you can update the software without visiting the machine.
+- 🗃️ **Persistent peer inventory** — both apps keep a SQLite-backed history of every peer seen on the LAN, with one-click *revoke access* / *forget server*.
+
+In scope: screen, keyboard, mouse, and clipboard. Out of scope: shared
+drives, devices, and audio — and smooth playback of fast-changing
+full-screen content (video, games) is a non-goal; the stream is optimized
+for mostly-static desktop work.
+
+## Installation
+
+```
+pip install remotedesktop
+```
+
+or, with [uv](https://docs.astral.sh/uv/):
+
+```
+uv tool install remotedesktop
+```
+
+Or run straight from a clone of this repository: double-click
+`run_server.bat` on the computer to be shared and `run_client.bat` on the
+viewing computer — each prepares the environment on first use and launches
+the app.
+
+## Quick start
+
+1. On the computer to share, run `remotedesktop-server`.
+2. On the viewing computer, run `remotedesktop-client` — the server appears
+   in its *Servers* panel; double-click it.
+3. Approve the connection in the dialog that pops up on the server. That's
+   it — future connections from that client need no approval.
+
+From a terminal in a clone of this repo, the same apps run with
+`uv run remotedesktop-server` and `uv run remotedesktop-client`.
+
+## Security model
+
+Connections are TLS-encrypted with a self-signed certificate the server
+generates once and keeps. The trust model is tuned for a **trusted LAN**:
+certificates are trusted on first use and a changed fingerprint is logged
+rather than blocking the connection, favoring reliable reconnection over
+strict certificate checking. Unapproved clients are limited to small
+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.
+
+## Requirements
+
+- Windows
+- Python 3.14+
+
+## How discovery works
+
+The client broadcasts a small JSON probe over UDP (port 48653); each server
+on the LAN replies with its hostname and connection port. Windows Firewall
+must allow Python to receive inbound UDP on that port for a server to be
+discoverable from other machines.
+
+## Development
+
+```
+uv sync          # set up the environment
+uv run pytest    # run the tests
+```
+
+Run the tests from PowerShell or cmd, not Git Bash: Git Bash puts Git's
+MinGW OpenSSL DLLs on `PATH`, which Qt's TLS backend loads and crashes on.
+From PowerShell, Qt uses the Windows schannel backend as intended.
+
+The demo GIFs above are generated — entirely from synthetic data — by
+`uv run python tools/make_demo_gifs.py`.
+
+### The `badges` branch
+
+The coverage badge above is served from the `badges` branch
+(`raw.githubusercontent.com/.../badges/coverage.svg`). CI regenerates the
+SVG after each test run on `master` and force-pushes it there as a single
+orphan commit. It lives on its own branch because `master` only accepts
+pull requests (a repository ruleset), so CI cannot commit to it directly;
+keeping the badge in the repo avoids depending on an external coverage
+service. The branch is generated output — never branch from it or merge it.

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

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