remotedesktop 0.1.0__tar.gz → 0.3.0__tar.gz

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

@@ -0,0 +1,53 @@
+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()
+          # Build the tree via a temp index, not `... | git mktree`: PowerShell
+          # pipes CRLF to native stdin, which puts a literal \r in the filename.
+          $env:GIT_INDEX_FILE = "$env:RUNNER_TEMP\badge-index"
+          git update-index --add --cacheinfo "100644,$blob,coverage.svg"
+          $tree = (git write-tree).Trim()
+          Remove-Item Env:\GIT_INDEX_FILE
+          $commit = (git commit-tree $tree -m "Update coverage badge").Trim()
+          git push --force origin "${commit}:refs/heads/badges"

{remotedesktop-0.1.0 → remotedesktop-0.3.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.1.0 → remotedesktop-0.3.0}/CLAUDE.md

@@ -1,52 +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.
-
-## 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. 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.
+# 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.1.0 → remotedesktop-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.1.0
+Version: 0.3.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
@@ -20,7 +20,7 @@ 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](badges/coverage.svg)
+![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)
@@ -28,6 +28,10 @@ Description-Content-Type: text/markdown
 A Python client/server application that provides remote desktop for Windows
 computers on the same LAN, with autodiscovery of servers.
 
+The server can optionally start automatically when you log in to Windows —
+a checkbox on its Status tab registers it under the per-user Run key (no
+administrator rights needed).
+
 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).

{remotedesktop-0.1.0 → remotedesktop-0.3.0}/readme.md

@@ -1,94 +1,98 @@
-# Remote Desktop
-
-[![CI](https://github.com/jamesabel/remotedesktop/actions/workflows/ci.yml/badge.svg)](https://github.com/jamesabel/remotedesktop/actions/workflows/ci.yml)
-![Coverage](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.
+# 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.
+
+The server can optionally start automatically when you log in to Windows —
+a checkbox on its Status tab registers it under the per-user Run key (no
+administrator rights needed).
+
+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.3.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.1.0 → remotedesktop-0.3.0}/src/remotedesktop/__init__.py

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

remotedesktop-0.3.0/src/remotedesktop/autostart.py

@@ -0,0 +1,63 @@
+"""Start the server automatically when the user logs in to Windows.
+
+Uses the per-user Run registry key (HKCU), so no administrator rights are
+needed and the server starts in the interactive session — which it needs,
+because approving a new client is a GUI prompt. On non-Windows platforms
+this is an inert stub, like input injection.
+"""
+
+import sys
+from pathlib import Path
+
+_IS_WINDOWS = sys.platform == "win32"
+if _IS_WINDOWS:
+    import winreg
+
+_RUN_KEY = r"Software\Microsoft\Windows\CurrentVersion\Run"
+_VALUE_NAME = "remotedesktop-server"
+
+
+def server_command() -> str:
+    """The command line that launches this installation's server."""
+    exe = Path(sys.executable).with_name("remotedesktop-server.exe")
+    if exe.exists():
+        return f'"{exe}"'
+    # Fallback (e.g. running from source without the entry-point exe).
+    return f'"{sys.executable}" -m remotedesktop.server'
+
+
+class Autostart:
+    """Reads and writes the login-autostart registration.
+
+    Tests pass their own `key_path` so they never touch the real Run key.
+    """
+
+    def __init__(self, *, key_path: str = _RUN_KEY, value_name: str = _VALUE_NAME) -> None:
+        self.available = _IS_WINDOWS
+        self._key_path = key_path
+        self._value_name = value_name
+
+    def is_enabled(self) -> bool:
+        if not self.available:
+            return False
+        try:
+            with winreg.OpenKey(winreg.HKEY_CURRENT_USER, self._key_path) as key:
+                winreg.QueryValueEx(key, self._value_name)
+            return True
+        except OSError:
+            return False
+
+    def set_enabled(self, enabled: bool) -> None:
+        if not self.available:
+            return
+        if enabled:
+            with winreg.CreateKey(winreg.HKEY_CURRENT_USER, self._key_path) as key:
+                winreg.SetValueEx(key, self._value_name, 0, winreg.REG_SZ, server_command())
+        else:
+            try:
+                with winreg.OpenKey(
+                    winreg.HKEY_CURRENT_USER, self._key_path, 0, winreg.KEY_SET_VALUE
+                ) as key:
+                    winreg.DeleteValue(key, self._value_name)
+            except OSError:
+                pass  # already not registered