remotedesktop 0.20.1__tar.gz → 1.3.0__tar.gz

remotedesktop-1.3.0/.github/workflows/release.yml

@@ -0,0 +1,48 @@
+name: Release
+
+# A merged version-bump PR changes src/remotedesktop/__init__.py — the only
+# place the version lives — so a push to master touching it means a new
+# version: tag it v<version> and publish a GitHub release with the built
+# distributions attached. Idempotent: if the release already exists (rerun,
+# or a touch that didn't change the version) it does nothing, so the manual
+# workflow_dispatch trigger is always safe to run. PyPI publishing stays
+# manual (`uv publish`), on explicit request only.
+
+on:
+  push:
+    branches: [master]
+    paths:
+      - src/remotedesktop/__init__.py
+  workflow_dispatch:
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # create the tag and the release
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Read version
+        id: version
+        # __init__.py is docstring + __version__ only; exec-ing it avoids
+        # installing the package just to read the version.
+        run: |
+          version=$(python3 -c "exec(open('src/remotedesktop/__init__.py').read()); print(__version__)")
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+      - name: Create release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          tag="v${{ steps.version.outputs.version }}"
+          if gh release view "$tag" --repo "$GITHUB_REPOSITORY" > /dev/null 2>&1; then
+            echo "Release $tag already exists — nothing to do."
+            exit 0
+          fi
+          uv build
+          gh release create "$tag" \
+            --repo "$GITHUB_REPOSITORY" \
+            --target "$GITHUB_SHA" \
+            --title "${{ steps.version.outputs.version }}" \
+            --generate-notes \
+            dist/*

remotedesktop-1.3.0/CLAUDE.md

@@ -0,0 +1,80 @@
+# 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 remote desktop GUI application (PySide6) for Windows computers on the same LAN, per `readme.md`:
+
+- **One app, both roles**: every instance can view other computers, and opts in to *sharing* its own screen via a three-state Screen sharing choice in Preferences — Not shared / view only / full control (persisted; a viewing-only instance binds no ports and creates no TLS credentials). Only one instance runs per user session — a second launch activates the first (`single_instance.py`).
+- **Autodiscovery and connection** of sharing computers on the LAN.
+- **In scope:** desktop screen, keyboard, mouse, and clipboard.
+- **Out of scope:** shared drives, devices, and multimedia (e.g., audio). Smooth playback of fast-changing full-screen content (video, games) is a non-goal: the screen transfer is lossless and optimized for mostly-static desktop work, not for video bandwidth.
+- **Trust model:** on first connection, the user on the sharing side must explicitly permit the client. After that, the client may reconnect whenever sharing is on 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. (Pre-1.0 shipped as two separate apps; 1.0.0 unified them. The wire protocol did not change in that bump.)
+
+## Workflow
+
+**Never push directly to `master`** — a repository ruleset rejects it. Every
+change goes through a pull request: branch → push → PR → CI green → merge.
+The ruleset also **requires the `ruff`, `ty`, and `test` checks to pass**
+(GitHub Actions, non-strict), so a merge with a red or missing check is
+rejected by GitHub; if a CI job is added or renamed, update the ruleset's
+required checks to match. 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`.
+
+**Releases are tagged automatically**: merging a version-bump PR (a change
+to `src/remotedesktop/__init__.py`, the only place the version lives)
+triggers `.github/workflows/release.yml`, which tags `v<version>` and
+creates a GitHub release with generated notes and the built sdist/wheel
+attached. It is idempotent (skips if the release exists) and can be run
+manually via workflow_dispatch. PyPI publishing stays manual (`uv publish`),
+only on the user's explicit request.
+
+## 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` — launch the app. It's a `gui-script`, so it runs detached with no console output; use `uv run python -m remotedesktop` when you need stdout/tracebacks. `--minimized` starts hidden in the tray when sharing is on (what the autostart registration passes).
+- `uv build` — build sdist and wheel into `dist/`
+- `uv publish` — publish to PyPI
+
+## Architecture
+
+- One PySide6 GUI app: `src/remotedesktop/app.py` (`MainWindow` + `main()`, wired to the `remotedesktop` GUI script in `pyproject.toml`; `__main__.py` makes `python -m remotedesktop` work — the in-app Restart relaunches that). `client.py` holds the viewing-role widgets (`DiscoveryPanel`, `ServerSession`), `server.py` the sharing-role widgets (`SharingTab`, `ViewersTable`) — neither has a window or entry point of its own anymore.
+- **The sharing lifecycle** (`server.py` `SharingTab`) lives on the "Connections" tab, a 2×2 QGridLayout of QGroupBox sections: "Sharing this computer" (the `SharingTab`: summary + viewers table), "Servers on LAN" (client-role inventory, Forget), "Clients on LAN" (server-role inventory, Revoke), and "Connection log" (the log pane + both get-log buttons). **The mode itself is chosen in Preferences**: a three-state radio group (`preferences.py`, `sharingModeChanged` signal) wired by `MainWindow` to `SharingTab.set_mode("off"/"view"/"control")` — `server.py` exposes `SHARING_MODE_*` constants and `load_sharing_mode(settings)`, persisted as the two legacy keys `server_enabled` + `allow_remote_input` so old installs migrate for free. View ↔ control switches apply live (`ShareServer.set_input_allowed`) without dropping viewers; off/on tears down / creates the `ShareServer` + `DiscoveryResponder` (a fresh `ShareServer` per enable; `close()` leaves teardown state), so a viewing-only instance binds no ports and never creates TLS credentials (loaded lazily on first enable). The host window calls `restore_sharing()` after wiring `statusMessage`/`peerEvent`/`sharingChanged`, so no startup status message is emitted before anyone listens. `serving` is mode-on AND actually listening. `revoke_client` works even while not sharing (direct `PairedClients.revoke`). The Restart app button also lives in Preferences (`preferences_tab.restart_button` → `MainWindow._restart_app`).
+- **Tray + lifecycle** (`app.py`): while sharing, closing the window hides to a `QSystemTrayIcon` (menu: Show / Restart / Quit) and sharing continues; not sharing → close quits. `main()` sets `setQuitOnLastWindowClosed(False)`, so **every exit path must reach `QApplication.quit()`** (plain close, tray Quit, restart). `tray_available=` is injectable — tests always pass an explicit value and never call `isSystemTrayAvailable()`. `--minimized` (used by the autostart registration) starts hidden in the tray when sharing is on. `single_instance.py` (`SingleInstance`, QLocalServer-based) enforces one instance per user session; a second launch tells the first to `bring_to_front()` and exits. `autostart.py` registers `remotedesktop.exe --minimized` under HKCU Run value `"remotedesktop"` and migrates the pre-1.0 `"remotedesktop-server"` value at startup (`migrate_legacy`).
+- The 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. **Multiple simultaneous server connections**: each is a `ServerSession` in `client.py` (its own `ShareClient` + `ViewerWidget`, hosted in a `QScrollArea` tab page — `session.page` is the tab widget, `session.viewer` the viewer), shown as a closable tab at the front of `MainWindow`'s central `QTabWidget`, titled with the server's reported hostname (fixed tabs get their close buttons stripped). Fit mode is `widgetResizable(True)`; **View → Actual size** flips the page to non-resizable and the viewer sizes itself to `frame / devicePixelRatio` (1:1 device pixels, the no-resample paint branch; input mapping unchanged because the frame fills the widget). 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 and a "— sharing" suffix while serving (`_update_window_title`); the status bar's message area follows the currently selected session tab (`status_text` per session) and a permanent right-side label shows "Sharing — N viewer(s)" whenever sharing is on (driven by `SharingTab.viewerCountChanged`). The `ClipboardSync`, inventories, and Connection log are shared across sessions; `client_performance.reset()` is only called when no *other* session is connected (resetting detaches every stream). Per-session status log lines are prefixed `[name]`.
+- **Auto-reconnect** (`app.py`): a session that *was connected* and drops retries `client.connect_to` with exponential backoff (base `reconnect_base_seconds=2.0` kwarg — tests inject ~0.05 — doubling to a 30 s cap), driven by a per-session single-shot QTimer. `ShareClient.connectionFailed` exists because **Qt emits `disconnected` only for sockets that reached ConnectedState** — refused/unreachable attempts fire `errorOccurred` with the socket back in UnconnectedState. The active-timer guard dedupes the errorOccurred+disconnected double-fire. Denial cancels until a manual activation; tab close/forget/quit cancel; retries bypass `_connect_session` on purpose (no perf reset, no tab steal, no inventory attempt spam). **Open session tabs persist** (`open_sessions` JSON in Settings, written on connect/rename/close) and are restored + reconnected at startup with `auto_reconnect` pre-armed, so a not-yet-available server is retried on the backoff loop; deliberately closed tabs are not restored. While no session exists, a non-closable "Server" placeholder tab (instructions) sits at index 0 and swaps with the first session's tab.
+- **Menus & shortcuts contract** (`app.py` `_build_menus`, `viewer.py`): File/View/Help menu bar; shortcuts Ctrl+W (close session tab), Ctrl+Q (quit), F5 (rescan), F11 (fullscreen). While a viewer shows a frame it **accepts `ShortcutOverride`** so every key forwards to the remote machine — **F11 is the single reserved local key**. Shortcut actions are also `addAction`-ed on the window so they fire with the menu bar hidden (fullscreen). Keep every menu/action as an attribute — PySide6 gives Python ownership of `addMenu`/`addAction` (and `QAction.menu()`) wrappers, and a GC'd local deletes the C++ object. Fullscreen hides menu/status bars, dock, and tab bar and restores them (including pre-fullscreen dock visibility) on exit; `closeEvent` exits fullscreen before persisting layout. Window geometry AND dock layout persist (`window_state.save_state`/`restore_state`, key `main_window_state`; the dock needs its objectName).
+- **Privacy toggles**: Preferences' "Sync clipboard" checkbox (`clipboard_sync_enabled`, default on) drives `ClipboardSync.enabled` — while off, local copies aren't sent and peer payloads aren't applied. View-only sharing is the "view" mode of the Screen sharing radios (`ShareServer.set_input_allowed` — a server-side drop, no wire change, that releases held input when switched off). Quitting with ≥1 viewer connected asks for confirmation (declining resets `_quitting`); restart shuts sharing down first so it never double-prompts.
+- **Two `PerformanceMonitor`s, never one**: `MainWindow.client_performance` (viewing sessions) and `server_performance` (the SharingTab's viewers). `ShareServer.close()` resets its monitor, so sharing a monitor across roles would wipe the other role's graphs. The Performance tab has "Viewing"/"Sharing" sub-tabs (`MainWindow.performance_pages`); `PreferencesTab` takes the list of monitors and applies the history-window setting to all.
+- **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. A sharing instance runs a `DiscoveryResponder` thread while sharing is enabled; the `DiscoveryPanel` (dock in `MainWindow`) calls the blocking `discover_servers()` on a worker thread and delivers results to the GUI via a queued signal. With `auto_scan=True` (the app; tests default to False and never broadcast) it scans **once at startup only** — further scans happen only on manual Refresh/F5 (deliberately no periodic background scanning; the user asked for this), guarded against overlapping scans and preserving the selection across repopulation; it also has a Connect button, a right-click Connect menu, and an empty-state hint. The "(this computer)" entry is not connectable (Connect disabled, activation swallowed, plus a `MainWindow._on_server_activated` guard). `DEFAULT_CONNECT_PORT` is 48654. An instance that shares and scans discovers itself — `DiscoveryPanel`'s `is_self=` callable labels that entry "(this computer)" (never hidden).
+- 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).
+- **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 app opens one connection and shares it. `MainWindow` takes a `connection=` keyword so tests inject a temp-file DB and never touch the real one (see `tests/test_main_window.py` / `test_sharing_tab.py`). Tests pass `db.connect(tmp_path/"x.db")` (or omit for in-memory), and use **separate DB files per simulated machine**.
+- **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; `SharingTab` implements it as a modal stay-on-top 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`, `SharingTab`, and `DiscoveryPanel` emit human-readable `status`/`statusMessage` signals for every connection phase, shown in the window's 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. Everything the pane shows is also written to a rotating debug log file (`logs.py`; `logs.init_logging("remotedesktop")` is called only by `app.main()`, under `platformdirs.user_log_dir("remotedesktop")` — `%LOCALAPPDATA%\remotedesktop\Logs\remotedesktop.log` on Windows; pre-1.0 `client.log`/`server.log` files just age out). Lower-level detail (socket state changes, protocol aborts, frame-drop/backlog, discovery datagram drops) goes straight to `logging.getLogger("remotedesktop.*")` at debug/warning level — silent failure paths should log there even when a status message would be too noisy. Library code and tests never call `init_logging`; without a handler those loggers are no-ops.
+- **Connection inventory** (`inventory.py`): the Connections tab has two grouped tables ("Clients on LAN" for the sharing role, "Servers on LAN" for the viewing role), each backed by its own `ConnectionInventory` — one `PeerRecord` per peer with attempts count, current state, first/last seen. The sharing side is driven by `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), forwarded through `SharingTab.peerEvent`. The viewing side is driven by `MainWindow`'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)`; each row gets its own button labeled `action_label` (in the trailing stretch column) whose callback receives that row's peer key. "Clients on LAN" wires "Revoke" → `SharingTab.revoke_client(client_id)` (via `ShareServer.revoke_client` while sharing — removes the token via `PairedClients.revoke`, disconnects any live stream with a `denied: access revoked`, and `_drop` emits a "revoked" peer event; a `_revoked` set distinguishes it from a plain disconnect — or directly via `PairedClients.revoke` while not sharing). "Servers on LAN" wires "Forget" → `KnownServers.forget(key)` + disconnect + `ConnectionInventory.remove(key)`. **Both delete the peer's row from the table and the DB outright** (`MainWindow._record_server_peer` turns a "revoked" event into a `remove`); a rescan or new connection attempt records the peer afresh. After either, the next connection needs a fresh approval. The roles use *separate tables* (`server_peers` / `client_peers`, selected via the `table=` arg) so they don't commingle; `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.
+- **Modal-loop pump** (`modal_loop.py`): a Windows title-bar drag (or click-and-hold) puts the window's thread into a native modal move/size loop where Qt's dispatcher stops — for a sharing instance this deadlocked when a *remote* click grabbed the window's own title bar (the mouse-up sat unread on the socket). `MainWindow.nativeEvent` feeds `ModalLoopPump`, which runs a native `SetTimer` from `WM_NCLBUTTONDOWN` (a press-and-hold that never moves blocks in DefWindowProc's click tracking without ever sending `WM_ENTERSIZEMOVE`) until `WM_CAPTURECHANGED`/`WM_EXITSIZEMOVE`, whose callback pumps Qt events (user input excluded). The caption buttons (min/max/close) are the exception — their tracking loop dispatches only mouse messages, so no timer can pump inside it; the pump instead performs those via its `caption_action` callback on press and consumes the message (nativeEvent must return True when `handle_native_event` does), so DefWindowProc's button tracking never starts. Tests inject a fake `timers` backend — never let them create real Win32 timers.
+- **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 app passes `logs.read_log_tail("remotedesktop")`, capped at `logs.TAIL_BYTES`); a missing provider/file answers with a placeholder rather than hanging the requester. The Connection log group on the Connections tab has both buttons — "Get server log" asks the server of the current session tab, "Get client log" asks the most recently admitted viewer; the reply opens a `logs.PeerLogDialog`.
+- **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 **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 tab's `ViewersTable` (`server.py`; it takes the monitor and follows the current ShareServer via `set_share_server`, empty when None), 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. The "Performance" tab (`PerformanceTab`, custom QPainter graphs, one per role sub-tab) schedules **no paint work while hidden** (gated on `isVisible()`, repaint on `showEvent`); the "Preferences" tab's 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 GUI (and clipboard tests) enables it; **plain sharing/input tests must leave it off to avoid touching the real OS clipboard.** The app shares ONE `ClipboardSync` across both roles (one OS clipboard): a real local copy fans out to connected servers and own viewers; a peer-received payload records its signature before applying, so it never re-emits `changed` and cannot loop between the roles. 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. **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
+
+- 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.20.1 → remotedesktop-1.3.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.20.1
-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.
+Version: 1.3.0
+Summary: Remote desktop app for Windows computers on the same LAN, with autodiscovery. View other computers and optionally share this one — screen, keyboard, mouse, and clipboard, 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/
@@ -29,50 +29,59 @@ Description-Content-Type: text/markdown
 ![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.**
+**Lossless, low-latency remote desktop for Windows computers on your LAN — one app, 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
+Run the same app on every computer. Turn on *Screen sharing* (view only or
+full control) in Preferences on the ones you want to reach, and they appear
+automatically in every other instance's *Servers* panel: the first
+connection is approved with one click on the shared computer, and from then
+on it reconnects instantly. View several computers at once — each in its own tab — while
+optionally sharing your own screen at the same time; closing the window
+while sharing keeps serving from the system tray. 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.
+Microsoft accounts, no cloud: just one app and your LAN.
 
 ## See it in action
 
-### Client
+### Viewing
 
-![Client demo](https://raw.githubusercontent.com/jamesabel/remotedesktop/master/docs/media/client-demo.gif)
+![Viewing 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
+The app discovers sharing computers on the LAN, connects, and streams each
 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
+computers 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
+### Sharing
 
-![Server demo](https://raw.githubusercontent.com/jamesabel/remotedesktop/master/docs/media/server-demo.gif)
+![Sharing 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).
+Sharing is turned on in Preferences (*view only* or *full control*). The
+*Connections* tab then shows everything in one place: 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) — the history of servers seen and clients paired with
+one-click *Forget* / *Revoke*, and the live connection log.
 
 ## 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.
+- 🧩 **One app, both roles** — every install can view other computers and share its own screen at the same time; sharing is a three-state choice in Preferences (*Not shared* / *view only* / *full control*), and only one instance runs per computer (launching it again just raises the existing window).
+- 🔍 **Autodiscovery** — sharing computers announce themselves over UDP; the app lists every one on the LAN at startup, no addresses to type (press *Refresh* or F5 to rescan).
+- 🗂️ **Multiple computers at once** — view and control several computers 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.
+- ⌨️🖱️ **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. Prefer eyes-only? Choose *Shared — viewers can watch only* and sharing becomes view-only, switchable live.
+- 🖼️ **View your way** — each connection scales to fit or shows the remote screen at 1:1 pixels with panning, and F11 goes full screen. While you type into a remote session every key is forwarded — F11 is the one key that stays local.
+- 📋 **Two-way clipboard** — text and images copied on either machine appear on the other; a Preferences toggle turns syncing off entirely.
 - 🔒 **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*.
+- 🔁 **Robust connections** — dead connections are detected within seconds, and dropped sessions reconnect automatically with backoff; a server restart heals by itself, no clicks needed. Connections that were open when the app closed are restored on the next start.
+- 🚀 **Hands-off operation** — optional start-at-login (per-user, no admin rights), close-to-tray while sharing (the screen stays available with the window closed), and a *Restart app* button usable from the remote session itself, so you can update the software without visiting the machine.
+- 🗃️ **Persistent peer inventory** — a SQLite-backed history of every peer seen on the LAN, with one-click *Revoke* / *Forget*.
+- 🧭 **Desktop-app niceties** — a real menu bar with standard shortcuts, a status-bar sharing indicator, a confirmation before quitting with viewers connected, and window/panel layout that persists across restarts.
 
 In scope: screen, keyboard, mouse, and clipboard. Out of scope: shared
 drives, devices, and audio — and smooth playback of fast-changing
@@ -91,21 +100,24 @@ 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.
+Or run straight from a clone of this repository: double-click `run.bat` —
+it 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.
+1. Run `remotedesktop` on both computers.
+2. On the computer to share, open *Preferences* and set *Screen sharing*
+   to one of the *Shared* modes.
+3. On the viewing computer, the shared computer appears in the *Servers*
+   panel — double-click it.
+4. Approve the connection in the dialog that pops up on the shared
+   computer. That's it — future connections from that computer 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`.
+From a terminal in a clone of this repo, the app runs with
+`uv run remotedesktop` (or `uv run python -m remotedesktop` for console
+output). While sharing, closing the window keeps the app serving from the
+system tray; quit from the tray menu.
 
 ## Security model
 
@@ -114,13 +126,14 @@ 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
+handshake messages until the user at the shared computer admits them;
+access can be revoked at any time from the *Connections* 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
+All of this is pure Python — the GUI is 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.

{remotedesktop-0.20.1 → remotedesktop-1.3.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [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."
+description = "Remote desktop app for Windows computers on the same LAN, with autodiscovery. View other computers and optionally share this one — screen, keyboard, mouse, and clipboard, without RDP or Microsoft authentication."
 readme = "readme.md"
 license = "MIT"
 authors = [{ name = "James Abel", email = "j@abel.co" }]
@@ -27,8 +27,7 @@ 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 = "remotedesktop.app:main"
 
 [dependency-groups]
 dev = [

{remotedesktop-0.20.1 → remotedesktop-1.3.0}/readme.md

@@ -6,50 +6,59 @@
 ![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
+**Lossless, low-latency remote desktop for Windows computers on your LAN — one app, pure Python, zero configuration.**
+
+Run the same app on every computer. Turn on *Screen sharing* (view only or
+full control) in Preferences on the ones you want to reach, and they appear
+automatically in every other instance's *Servers* panel: the first
+connection is approved with one click on the shared computer, and from then
+on it reconnects instantly. View several computers at once — each in its own tab — while
+optionally sharing your own screen at the same time; closing the window
+while sharing keeps serving from the system tray. 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.
+Microsoft accounts, no cloud: just one app and your LAN.
 
 ## See it in action
 
-### Client
+### Viewing
 
-![Client demo](https://raw.githubusercontent.com/jamesabel/remotedesktop/master/docs/media/client-demo.gif)
+![Viewing 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
+The app discovers sharing computers on the LAN, connects, and streams each
 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
+computers 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
+### Sharing
 
-![Server demo](https://raw.githubusercontent.com/jamesabel/remotedesktop/master/docs/media/server-demo.gif)
+![Sharing 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).
+Sharing is turned on in Preferences (*view only* or *full control*). The
+*Connections* tab then shows everything in one place: 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) — the history of servers seen and clients paired with
+one-click *Forget* / *Revoke*, and the live connection log.
 
 ## 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.
+- 🧩 **One app, both roles** — every install can view other computers and share its own screen at the same time; sharing is a three-state choice in Preferences (*Not shared* / *view only* / *full control*), and only one instance runs per computer (launching it again just raises the existing window).
+- 🔍 **Autodiscovery** — sharing computers announce themselves over UDP; the app lists every one on the LAN at startup, no addresses to type (press *Refresh* or F5 to rescan).
+- 🗂️ **Multiple computers at once** — view and control several computers 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.
+- ⌨️🖱️ **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. Prefer eyes-only? Choose *Shared — viewers can watch only* and sharing becomes view-only, switchable live.
+- 🖼️ **View your way** — each connection scales to fit or shows the remote screen at 1:1 pixels with panning, and F11 goes full screen. While you type into a remote session every key is forwarded — F11 is the one key that stays local.
+- 📋 **Two-way clipboard** — text and images copied on either machine appear on the other; a Preferences toggle turns syncing off entirely.
 - 🔒 **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*.
+- 🔁 **Robust connections** — dead connections are detected within seconds, and dropped sessions reconnect automatically with backoff; a server restart heals by itself, no clicks needed. Connections that were open when the app closed are restored on the next start.
+- 🚀 **Hands-off operation** — optional start-at-login (per-user, no admin rights), close-to-tray while sharing (the screen stays available with the window closed), and a *Restart app* button usable from the remote session itself, so you can update the software without visiting the machine.
+- 🗃️ **Persistent peer inventory** — a SQLite-backed history of every peer seen on the LAN, with one-click *Revoke* / *Forget*.
+- 🧭 **Desktop-app niceties** — a real menu bar with standard shortcuts, a status-bar sharing indicator, a confirmation before quitting with viewers connected, and window/panel layout that persists across restarts.
 
 In scope: screen, keyboard, mouse, and clipboard. Out of scope: shared
 drives, devices, and audio — and smooth playback of fast-changing
@@ -68,21 +77,24 @@ 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.
+Or run straight from a clone of this repository: double-click `run.bat` —
+it 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.
+1. Run `remotedesktop` on both computers.
+2. On the computer to share, open *Preferences* and set *Screen sharing*
+   to one of the *Shared* modes.
+3. On the viewing computer, the shared computer appears in the *Servers*
+   panel — double-click it.
+4. Approve the connection in the dialog that pops up on the shared
+   computer. That's it — future connections from that computer 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`.
+From a terminal in a clone of this repo, the app runs with
+`uv run remotedesktop` (or `uv run python -m remotedesktop` for console
+output). While sharing, closing the window keeps the app serving from the
+system tray; quit from the tray menu.
 
 ## Security model
 
@@ -91,13 +103,14 @@ 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
+handshake messages until the user at the shared computer admits them;
+access can be revoked at any time from the *Connections* 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
+All of this is pure Python — the GUI is 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.

remotedesktop-0.20.1/run_client.bat → remotedesktop-1.3.0/run.bat

@@ -1,14 +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" %*
+@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.exe" %*

{remotedesktop-0.20.1 → remotedesktop-1.3.0}/src/remotedesktop/__init__.py

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

remotedesktop-1.3.0/src/remotedesktop/__main__.py

@@ -0,0 +1,6 @@
+"""`python -m remotedesktop` launches the app (also used by app restart)."""
+
+from remotedesktop.app import main
+
+if __name__ == "__main__":
+    main()

{remotedesktop-0.20.1 → remotedesktop-1.3.0}/src/remotedesktop/about.py

@@ -1,4 +1,4 @@
-"""The "About" tab, shared by the client and server windows.
+"""The "About" tab of the app window.
 
 Shows the same metadata the PyPI page shows — summary, author, license,
 Python requirement, links — read from the installed package's metadata via
@@ -17,9 +17,10 @@ _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."
+        "Remote desktop app for Windows computers on the same LAN, with "
+        "autodiscovery. View other computers and optionally share this one — "
+        "screen, keyboard, mouse, and clipboard, without RDP or Microsoft "
+        "authentication."
     ),
     "Author-email": "James Abel <j@abel.co>",
     "License-Expression": "MIT",
@@ -64,7 +65,7 @@ class AboutTab(QWidget):
             Qt.TextInteractionFlag.TextBrowserInteraction
         )
         logo = QLabel()
-        logo.setPixmap(icon.app_icon("client").pixmap(48, 48))
+        logo.setPixmap(icon.app_icon("app").pixmap(48, 48))
         layout = QVBoxLayout(self)
         layout.addWidget(logo)
         layout.addWidget(body)