remotedesktop 0.0.1__tar.gz → 0.2.0__tar.gz

remotedesktop-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,48 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uvx ruff check .
+
+  ty:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      # ty resolves imports from the project venv; pyproject pins the
+      # type-checking platform to win32 (the app's target).
+      - run: uv sync
+      - run: uvx ty check .
+
+  test:
+    # The app targets Windows: input injection, schannel TLS, and the GUI
+    # tests all assume it.
+    runs-on: windows-latest
+    permissions:
+      contents: write # to push the updated coverage badge
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - run: uv sync
+      - run: uv run pytest --cov=remotedesktop --cov-report=term
+      - name: Publish coverage badge
+        # master is PR-only (repo ruleset), so the badge lives on its own
+        # branch: a single-file orphan commit, force-pushed each time.
+        if: github.ref == 'refs/heads/master' && github.event_name == 'push'
+        run: |
+          uv run python scripts/make_coverage_badge.py badges/coverage.svg
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          $blob = (git hash-object -w badges/coverage.svg).Trim()
+          $tree = ("100644 blob $blob`tcoverage.svg" | git mktree).Trim()
+          $commit = (git commit-tree $tree -m "Update coverage badge").Trim()
+          git push --force origin "${commit}:refs/heads/badges"

{remotedesktop-0.0.1 → remotedesktop-0.2.0}/.gitignore

@@ -1,24 +1,25 @@
-# Python
-__pycache__/
-*.py[cod]
-*.egg-info/
-.eggs/
-build/
-dist/
-
-# Virtual environments
-.venv/
-venv/
-
-# Testing
-.pytest_cache/
-.coverage
-htmlcov/
-
-# Tooling caches
-.mypy_cache/
-.ruff_cache/
-
-# IDE
-.idea/
-.vscode/
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+
+# Virtual environments
+.venv/
+venv/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+badges/
+
+# Tooling caches
+.mypy_cache/
+.ruff_cache/
+
+# IDE
+.idea/
+.vscode/

remotedesktop-0.2.0/CLAUDE.md

@@ -0,0 +1,59 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What This Project Is
+
+A Python client/server remote desktop GUI application (PySide6) for Windows computers on the same LAN, per `readme.md`:
+
+- **Autodiscovery and connection** of servers on the LAN.
+- **In scope:** desktop screen, keyboard, mouse, and clipboard.
+- **Out of scope:** shared drives, devices, and multimedia (e.g., audio).
+- **Two GUI apps:** a client and a server, each run on its respective computer.
+- **Trust model:** on first connection, the user on the server side must explicitly permit the client. After that, the client may reconnect whenever the server is running without further approval.
+- **Constraint:** does not use Windows RDP and does not rely on any Microsoft-based authentication.
+
+LAN autodiscovery, screen sharing, keyboard/mouse forwarding, clipboard sync, and a TLS-encrypted transport with a token-authenticated handshake are all implemented — the readme feature set plus security hardening.
+
+## Workflow
+
+**Never push directly to `master`** — a repository ruleset rejects it. Every
+change goes through a pull request: branch → push → PR → CI green → merge.
+CI publishes the coverage badge to the unprotected `badges` branch (readme
+references it by raw URL), so no workflow ever needs to write to `master`.
+
+## Commands
+
+Managed with `uv` (hatchling build backend, src layout):
+
+- `uv sync` — create/update the venv with the project and dev dependencies
+- `uv run pytest` — run all tests
+- `uv run pytest tests/test_smoke.py::test_version` — run a single test
+- `uv run remotedesktop-client` / `uv run remotedesktop-server` — launch the apps. These are `gui-scripts`, so they run detached with no console output; use `uv run python -m remotedesktop.client` (or `.server`) when you need stdout/tracebacks.
+- `uv build` — build sdist and wheel into `dist/`
+- `uv publish` — publish to PyPI
+
+## 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.
+- **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`) 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 or JPEG frames; malformed input aborts the socket). `ShareServer` owns one QTimer that grabs the primary screen via `QScreen.grabWindow(0)`, JPEG-encodes once, and fans out to all clients, skipping clients whose send buffer is backlogged; the timer only runs while clients are connected. `ShareClient` decodes frames to QImage for the viewer.
+- **All persistence is one SQLite database** (`db.py`): `db.connect(path)` opens the DB and ensures every table (`settings`, `paired_clients`, `known_servers`, and the inventory tables). The file lives at `config.default_db_path()` — `platformdirs.user_data_dir("remotedesktop")` (`%LOCALAPPDATA%\remotedesktop\remotedesktop.db` on Windows). **Use `platformdirs` for any new data location; don't hardcode `%APPDATA%`.** Every store (`Settings`, `PairedClients`, `KnownServers`, `ConnectionInventory`) takes a `sqlite3.Connection`; the GUIs open one connection per window and share it. Both window classes take a `connection=` keyword so tests inject a temp-file DB and never touch the real one (see `tests/test_client_window.py` / `test_server_window.py`). Tests pass `db.connect(tmp_path/"x.db")` (or omit for in-memory), and use **separate DB files for the server and client** since they model different machines.
+- **Trust model plumbing** (`config.py`): the client has a stable UUID identity (`load_client_identity`, in the `settings` table) and the server maps each approved client-id to a token (`PairedClients`). `ShareServer` takes an `approve_client(client_id, name) -> bool` callback; `ServerWindow` implements it as a modal QMessageBox. Tests inject stores backed by a temp DB and explicit identities so they never touch real data or prompt.
+- **Status/debug logging is a feature**: `ShareServer`, `ShareClient`, and `DiscoveryPanel` emit human-readable `status` signals for every connection phase, and both windows show them in a timestamped "Connection log" pane. When adding connection behavior, emit a status message for each new phase or failure path — there's a test asserting the server's phase messages.
+- **Connection inventory** (`inventory.py`): both windows have a tab (server: "Clients on LAN"; client: "Servers on LAN") backed by a `ConnectionInventory` — one `PeerRecord` per peer with attempts count, current state, first/last seen. The server drives it from `ShareServer.peerEvent` (a structured `{key, event, name, address, detail}` signal emitted alongside the status strings at each phase — keep both in sync when adding phases). The client drives it from `ClientWindow`'s own handlers (discovered servers from `DiscoveryPanel.serversFound`, plus attempt/connected/denied/disconnected). Server peers key by client-id; client peers key by `host:port`. **Persisted in SQLite** and reloaded on startup, so it survives restarts.
+- **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.
+- **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.
+- **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`.
+
+## Environment Notes
+
+- Target platform is Windows; development happens on Windows 11. Requires Python >=3.14.
+- **Run the tests from PowerShell/cmd, not Git Bash.** Git Bash puts `C:\Program Files\Git\mingw64\bin` on PATH, so Qt loads its `openssl` TLS backend against Git's MinGW-built OpenSSL DLLs and crashes with an access violation on the first TLS connection. From PowerShell those DLLs aren't on PATH and Qt uses schannel, as intended.

remotedesktop-0.2.0/PKG-INFO

@@ -0,0 +1,113 @@
+Metadata-Version: 2.4
+Name: remotedesktop
+Version: 0.2.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)
+
+A Python client/server application that provides remote desktop for Windows
+computers on the same LAN, with autodiscovery of servers.
+
+Connections are made to the desktop screen, keyboard, mouse, and clipboard.
+Other connections are not provided, such as shared drives, devices, or
+multimedia (e.g., audio).
+
+The client and server are PySide6 (Qt) GUI apps, each run on its respective
+computer. The client requests connection to the server, and for the initial
+connection the user on the server side must permit the connection. After
+that, the client can connect to the server whenever the server is running,
+without the server having to grant permission again.
+
+This does not use Windows RDP nor rely on any Microsoft-based authentication.
+
+## Status
+
+The core feature set works: autodiscovery, live screen viewing,
+mouse/keyboard control, and two-way clipboard sync. A running server appears
+in the client's *Servers* panel; opening it (after the server user approves
+the first connection) shows the remote screen, clicking into the view
+forwards mouse and keyboard input, and text/images copied on either side
+appear on the other. Input forwarding is safe against interruptions: if the
+viewer loses focus, a drag ends outside the view, or a client disconnects
+mid-keystroke, anything still held down is released on the server — no stuck
+keys or mouse buttons.
+
+The connection is encrypted with TLS, and after the server user approves a
+client once, that client reconnects automatically using a stored token.
+Unapproved connections are limited to small handshake messages until the
+server user admits them. The security model is tuned for a trusted LAN: the
+server's certificate is self-signed and trusted on first use, favoring
+reliable reconnection over strict certificate checking — if the server's
+certificate ever changes, the client logs a warning and updates its stored
+fingerprint rather than refusing to connect.
+
+Both apps have a second tab listing every peer seen on the LAN — on the
+server, the clients that have connected or attempted to; on the client, the
+servers it has discovered or tried to reach — with each peer's current state,
+number of attempts, and when it was first and last seen. From that tab the
+server can revoke a client (disconnecting it and requiring approval to
+reconnect) and the client can forget a server. This inventory, and all other
+state (identity, pairings, settings), is stored in a SQLite database and
+persists across restarts. Its location is chosen by `platformdirs` (on
+Windows, `%LOCALAPPDATA%\remotedesktop`).
+
+## Requirements
+
+- Windows
+- Python 3.14+
+- [uv](https://docs.astral.sh/uv/)
+
+## Running
+
+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
+script prepares the environment (installing dependencies on first use) and
+then launches the app, closing its console window once the app is running.
+
+To run from a terminal instead:
+
+```
+uv run remotedesktop-server
+uv run remotedesktop-client
+```
+
+The apps are also published on PyPI as
+[`remotedesktop`](https://pypi.org/project/remotedesktop/).
+
+## 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.

{remotedesktop-0.0.1 → remotedesktop-0.2.0}/pyproject.toml

@@ -15,6 +15,8 @@ classifiers = [
     "Topic :: System :: Networking",
 ]
 dependencies = [
+    "cryptography>=49.0.0",
+    "platformdirs>=4.10.0",
     "pyside6>=6.11.1",
 ]
 
@@ -25,6 +27,7 @@ remotedesktop-server = "remotedesktop.server:main"
 [dependency-groups]
 dev = [
     "pytest>=8",
+    "pytest-cov>=7.1.0",
 ]
 
 [build-system]
@@ -36,3 +39,8 @@ 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.2.0/readme.md

@@ -0,0 +1,94 @@
+# 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)
+
+A Python client/server application that provides remote desktop for Windows
+computers on the same LAN, with autodiscovery of servers.
+
+Connections are made to the desktop screen, keyboard, mouse, and clipboard.
+Other connections are not provided, such as shared drives, devices, or
+multimedia (e.g., audio).
+
+The client and server are PySide6 (Qt) GUI apps, each run on its respective
+computer. The client requests connection to the server, and for the initial
+connection the user on the server side must permit the connection. After
+that, the client can connect to the server whenever the server is running,
+without the server having to grant permission again.
+
+This does not use Windows RDP nor rely on any Microsoft-based authentication.
+
+## Status
+
+The core feature set works: autodiscovery, live screen viewing,
+mouse/keyboard control, and two-way clipboard sync. A running server appears
+in the client's *Servers* panel; opening it (after the server user approves
+the first connection) shows the remote screen, clicking into the view
+forwards mouse and keyboard input, and text/images copied on either side
+appear on the other. Input forwarding is safe against interruptions: if the
+viewer loses focus, a drag ends outside the view, or a client disconnects
+mid-keystroke, anything still held down is released on the server — no stuck
+keys or mouse buttons.
+
+The connection is encrypted with TLS, and after the server user approves a
+client once, that client reconnects automatically using a stored token.
+Unapproved connections are limited to small handshake messages until the
+server user admits them. The security model is tuned for a trusted LAN: the
+server's certificate is self-signed and trusted on first use, favoring
+reliable reconnection over strict certificate checking — if the server's
+certificate ever changes, the client logs a warning and updates its stored
+fingerprint rather than refusing to connect.
+
+Both apps have a second tab listing every peer seen on the LAN — on the
+server, the clients that have connected or attempted to; on the client, the
+servers it has discovered or tried to reach — with each peer's current state,
+number of attempts, and when it was first and last seen. From that tab the
+server can revoke a client (disconnecting it and requiring approval to
+reconnect) and the client can forget a server. This inventory, and all other
+state (identity, pairings, settings), is stored in a SQLite database and
+persists across restarts. Its location is chosen by `platformdirs` (on
+Windows, `%LOCALAPPDATA%\remotedesktop`).
+
+## Requirements
+
+- Windows
+- Python 3.14+
+- [uv](https://docs.astral.sh/uv/)
+
+## Running
+
+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
+script prepares the environment (installing dependencies on first use) and
+then launches the app, closing its console window once the app is running.
+
+To run from a terminal instead:
+
+```
+uv run remotedesktop-server
+uv run remotedesktop-client
+```
+
+The apps are also published on PyPI as
+[`remotedesktop`](https://pypi.org/project/remotedesktop/).
+
+## 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.

remotedesktop-0.2.0/run_client.bat

@@ -0,0 +1,14 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+
+rem Prepare the environment (installs/updates dependencies) before launching.
+uv sync --quiet
+if errorlevel 1 (
+    echo Failed to prepare the environment.
+    pause
+    exit /b 1
+)
+
+rem Launch the GUI detached so this console window can close immediately.
+start "" ".venv\Scripts\remotedesktop-client.exe" %*

remotedesktop-0.2.0/run_server.bat

@@ -0,0 +1,14 @@
+@echo off
+setlocal
+cd /d "%~dp0"
+
+rem Prepare the environment (installs/updates dependencies) before launching.
+uv sync --quiet
+if errorlevel 1 (
+    echo Failed to prepare the environment.
+    pause
+    exit /b 1
+)
+
+rem Launch the GUI detached so this console window can close immediately.
+start "" ".venv\Scripts\remotedesktop-server.exe" %*

remotedesktop-0.2.0/scripts/make_coverage_badge.py

@@ -0,0 +1,57 @@
+"""Generate a shields-style SVG coverage badge from the .coverage data file.
+
+Reads the total percentage via `coverage report --format=total` (so run the
+tests with `--cov` first) and writes the badge, by default to
+badges/coverage.svg. CI runs this and commits the badge so the readme can
+reference it without any external service (the repo is private).
+"""
+
+import subprocess
+import sys
+from pathlib import Path
+
+_COLORS = [  # same thresholds the coverage-badge package used
+    (100, "#4c1"),
+    (90, "#97CA00"),
+    (75, "#a4a61d"),
+    (60, "#dfb317"),
+    (40, "#fe7d37"),
+    (0, "#e05d44"),
+]
+
+_SVG = """<svg xmlns="http://www.w3.org/2000/svg" width="104" height="20" role="img" aria-label="coverage: {pct}%">
+  <linearGradient id="s" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="r"><rect width="104" height="20" rx="3" fill="#fff"/></clipPath>
+  <g clip-path="url(#r)">
+    <rect width="61" height="20" fill="#555"/>
+    <rect x="61" width="43" height="20" fill="{color}"/>
+    <rect width="104" height="20" fill="url(#s)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
+    <text x="31.5" y="14">coverage</text>
+    <text x="82.5" y="14">{pct}%</text>
+  </g>
+</svg>
+"""
+
+
+def main() -> None:
+    total = subprocess.run(
+        [sys.executable, "-m", "coverage", "report", "--format=total"],
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout.strip()
+    pct = round(float(total))
+    color = next(c for threshold, c in _COLORS if pct >= threshold)
+    out = Path(sys.argv[1] if len(sys.argv) > 1 else "badges/coverage.svg")
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(_SVG.format(pct=pct, color=color), encoding="utf-8")
+    print(f"{out}: {pct}%")
+
+
+if __name__ == "__main__":
+    main()

remotedesktop-0.2.0/scripts/make_venv.bat

@@ -0,0 +1,13 @@
+@echo off
+setlocal
+cd /d "%~dp0.."
+
+rem Create/update .venv with the project and dev dependencies.
+uv sync
+if errorlevel 1 (
+    echo Failed to create the environment.
+    pause
+    exit /b 1
+)
+
+echo .venv is ready.

{remotedesktop-0.0.1 → remotedesktop-0.2.0}/src/remotedesktop/__init__.py

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