remotedesktop 1.4.0__tar.gz → 1.5.0__tar.gz

{remotedesktop-1.4.0 → remotedesktop-1.5.0}/.github/workflows/release.yml

@@ -20,6 +20,8 @@ jobs:
     runs-on: ubuntu-latest
     permissions:
       contents: write # create the tag and the release
+    outputs:
+      version: ${{ steps.version.outputs.version }}
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v6
@@ -46,3 +48,28 @@ jobs:
             --title "${{ steps.version.outputs.version }}" \
             --generate-notes \
             dist/*
+
+  # Unsigned installer build (the signing token is local-only). To replace it
+  # with a signed one: run scripts\make_installer.bat locally, then
+  #   gh release upload v<version> installers\remotedesktop_installer_win64.exe --clobber
+  installer:
+    needs: release
+    runs-on: windows-latest # .NET Framework csc.exe is preinstalled (launcher build)
+    permissions:
+      contents: write # upload the installer to the release
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+      - name: Install NSIS
+        # Not preinstalled on windows-latest; choco puts makensis.exe at
+        # C:\Program Files (x86)\NSIS\makensis.exe, pyship's default path.
+        run: choco install nsis -y --no-progress
+      - name: Build installer
+        run: uv run --group ship python -m pyship --noupload
+      - name: Attach installer to release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: >
+          gh release upload "v${{ needs.release.outputs.version }}"
+          --repo "$env:GITHUB_REPOSITORY" --clobber
+          installers/remotedesktop_installer_win64.exe

{remotedesktop-1.4.0 → remotedesktop-1.5.0}/.gitignore

@@ -10,6 +10,12 @@ dist/
 .venv/
 venv/
 
+# pyship build output (scripts/make_installer.bat); *.nsi is left behind
+# only if makensis fails mid-run
+app/
+installers/
+*.nsi
+
 # Testing
 .pytest_cache/
 .coverage

{remotedesktop-1.4.0 → remotedesktop-1.5.0}/CLAUDE.md

@@ -6,7 +6,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 A Python remote desktop GUI application (PySide6) for Windows computers on the same LAN, per `readme.md`:
 
-- **One app, either or 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). The **viewer role is opt-out** too: Preferences' "Client (viewer)" checkbox (`viewer_enabled`, default on, `load_viewer_enabled`) — when off, `MainWindow._set_viewer_enabled` closes open sessions and hides all client UI (Server placeholder tab, discovery panel, "Server history" group), disables F5, skips session restore, and refuses activations; discovery never broadcasts. Two **role indicator buttons** at the top of the left dock (no title text — the View menu names it "Servers on LAN panel") (`client_role_button`/`server_role_button` — checkable QPushButtons styled green when on, made purely informational via `WA_TransparentForMouseEvents`; roles change only in Preferences) say what the instance is, updated on viewer toggle and `sharingChanged`. The dock always exists (a server-only instance shows just the indicators) and is **closable but not floatable/movable** (`setFeatures(DockWidgetClosable)`). Only one instance runs per user session — a second launch activates the first (`single_instance.py`).
+- **One app, either or 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). The **viewer role is opt-out** too: Preferences' "Client (viewer)" checkbox (`viewer_enabled`, default on, `load_viewer_enabled`) — when off, `MainWindow._set_viewer_enabled` closes open sessions and hides all client UI (Server placeholder tab, discovery panel, "Server history" group), disables F5, skips session restore, and refuses activations; discovery never broadcasts. Two **role indicator buttons** at the top of the left dock (`panel_dock`; headerless — the View menu names it "Panel") (`client_role_button`/`server_role_button` — checkable QPushButtons styled green when on, made purely informational via `WA_TransparentForMouseEvents`; roles change only in Preferences) say what the instance is, updated on viewer toggle and `sharingChanged`. The dock always exists (a server-only instance shows just the indicators) and is **headerless** — no title bar at all (`setTitleBarWidget` with an empty widget, `NoDockWidgetFeatures`); View ▸ Panel is the only way to show/hide it. 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.
@@ -34,6 +34,21 @@ 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.
 
+The same workflow's `installer` job (windows-latest) builds the **pyship
+installer** (`uv run --group ship python -m pyship --noupload`) and attaches
+it to the release — **unsigned**, because the signing token is local-only. To
+ship a signed installer, build locally (`scripts\make_installer.bat`) and
+replace the asset:
+`gh release upload v<version> installers\remotedesktop_installer_win64.exe --clobber`.
+The frozen app is a pyship CLIP (a full standalone CPython), so `pythonw.exe
+-m remotedesktop` still works inside it; `autostart.installed_launcher()`
+detects the install (CLIP dir name `remotedesktop_<version>`) and points
+autostart/restart at the launcher exe, which always starts the newest
+installed version. Users must quit the app before running an installer — a
+running instance holds the CLIP's DLLs locked. Do not set
+`[tool.pyship] run_on_startup` or signing keys in `pyproject.toml` (see the
+comments there).
+
 ## Commands
 
 Managed with `uv` (hatchling build backend, src layout):
@@ -44,11 +59,18 @@ Managed with `uv` (hatchling build backend, src layout):
 - `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
+- `scripts\make_installer.bat` — build the **signed Windows installer** with pyship
+  (`installers\remotedesktop_installer_win64.exe`). Needs the hardware signing token and a
+  local console session (pyship refuses token signing over RDP); set
+  `PYSHIP_SIGNING_CERTIFICATE_PIN` for unattended signing. pyship wipes and rebuilds
+  `dist/`, `app/` (launcher exe + frozen CLIP), and `installers/` — all gitignored.
+  `icon/remotedesktop.ico` is the build-input icon; regenerate with
+  `uv run python tools/make_icon.py` after changing `icon.py` (a test guards it).
 
 ## 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: "Server (sharing this computer)" (the `SharingTab`: summary + viewers table), "Server history" (client-role inventory, Forget), "Client history" (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`).
+- **The sharing lifecycle** (`server.py` `SharingTab`) lives on the "Connections" tab, arranged as one outer QGroupBox per role, side by side as widgets with "Connection log" full-width below: "Client (viewer)" (left; nests "Connected servers" — `app._SessionsTable`, the client-side twin of the viewers table fed by `_ConnectedServersSource` from the live sessions and `client_performance` — over "Server history", client-role inventory, Forget) and "Server (sharing)" (right; the `SharingTab` summary + viewers table over "Client history", server-role inventory, Revoke). **Each role box is visible only while its role is on** (`_update_connections_groups`); boxes are widgets (not column layouts) so a hidden role frees its space and the other starts at the left edge. **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.

{remotedesktop-1.4.0 → remotedesktop-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 1.4.0
+Version: 1.5.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
@@ -62,7 +62,7 @@ time with live statistics.
 
 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
+viewer — who they are (name, login, 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.
@@ -73,7 +73,7 @@ one-click *Forget* / *Revoke*, and the live connection log.
 - 🔍 **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. Prefer eyes-only? Choose *Shared — viewers can watch only* and sharing becomes view-only, switchable live.
+- ⌨️🖱️ **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, view 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.
@@ -90,6 +90,13 @@ for mostly-static desktop work.
 
 ## Installation
 
+The easiest way: download `remotedesktop_installer_win64.exe` from the
+[latest release](https://github.com/jamesabel/remotedesktop/releases/latest)
+and run it — no Python required. To upgrade, quit the app first (tray →
+Quit if it's sharing), then run the newer installer.
+
+With Python, from PyPI:
+
 ```
 pip install remotedesktop
 ```
@@ -108,8 +115,8 @@ it prepares the environment on first use and launches the app.
 1. Run `remotedesktop` on both computers.
 2. On the computer to share, open *Preferences* and set *Server (sharing)*
    to one of the *Shared* modes.
-3. On the viewing computer, the shared computer appears in the *Servers*
-   panel — double-click it.
+3. On the viewing computer, the shared computer appears in the panel on
+   the left — double-click it (or select it and click *Connect*).
 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.

{remotedesktop-1.4.0 → remotedesktop-1.5.0}/pyproject.toml

@@ -35,6 +35,10 @@ dev = [
     "pytest>=8",
     "pytest-cov>=7.1.0",
 ]
+# Only for building the Windows installer (scripts/make_installer.bat / release CI).
+ship = [
+    "pyship>=0.7.4",
+]
 
 [build-system]
 requires = ["hatchling"]
@@ -46,6 +50,15 @@ path = "src/remotedesktop/__init__.py"
 [tool.pytest.ini_options]
 testpaths = ["tests"]
 
+[tool.pyship]
+ui = "gui"
+# Never upload to S3, even without --noupload. Code signing stays out of this
+# config on purpose: CI installer builds are unsigned (the signing token is
+# local-only); scripts/make_installer.bat passes the signing flags.
+upload = false
+# run_on_startup deliberately NOT set: it would write an HKLM Run value named
+# "remotedesktop", colliding with the app's own HKCU autostart preference.
+
 [tool.ty.environment]
 # The app targets Windows (SendInput via ctypes.windll); type-check as such
 # even when ty runs on a Linux CI runner.

{remotedesktop-1.4.0 → remotedesktop-1.5.0}/readme.md

@@ -39,7 +39,7 @@ time with live statistics.
 
 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
+viewer — who they are (name, login, 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.
@@ -50,7 +50,7 @@ one-click *Forget* / *Revoke*, and the live connection log.
 - 🔍 **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. Prefer eyes-only? Choose *Shared — viewers can watch only* and sharing becomes view-only, switchable live.
+- ⌨️🖱️ **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, view 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.
@@ -67,6 +67,13 @@ for mostly-static desktop work.
 
 ## Installation
 
+The easiest way: download `remotedesktop_installer_win64.exe` from the
+[latest release](https://github.com/jamesabel/remotedesktop/releases/latest)
+and run it — no Python required. To upgrade, quit the app first (tray →
+Quit if it's sharing), then run the newer installer.
+
+With Python, from PyPI:
+
 ```
 pip install remotedesktop
 ```
@@ -85,8 +92,8 @@ it prepares the environment on first use and launches the app.
 1. Run `remotedesktop` on both computers.
 2. On the computer to share, open *Preferences* and set *Server (sharing)*
    to one of the *Shared* modes.
-3. On the viewing computer, the shared computer appears in the *Servers*
-   panel — double-click it.
+3. On the viewing computer, the shared computer appears in the panel on
+   the left — double-click it (or select it and click *Connect*).
 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.

remotedesktop-1.5.0/scripts/make_installer.bat

@@ -0,0 +1,27 @@
+@echo off
+setlocal
+cd /d "%~dp0.."
+
+rem Build the signed Windows installer with pyship.
+rem Requirements: the hardware signing token plugged in, a LOCAL console
+rem session (pyship refuses to sign over RDP - failed PIN attempts can lock
+rem the token), and optionally PYSHIP_SIGNING_CERTIFICATE_PIN set for
+rem unattended signing (otherwise the token middleware prompts for the PIN).
+rem CI builds the same installer unsigned; replace the release asset with
+rem this signed one via:
+rem   gh release upload v<version> installers\remotedesktop_installer_win64.exe --clobber
+
+uv sync --group ship
+if errorlevel 1 (
+    echo Failed to create the environment.
+    exit /b 1
+)
+
+rem pyship rebuilds dist\ (wheel), app\ (launcher + frozen CLIP), and installers\.
+uv run --group ship python -m pyship --noupload --code-sign --certificate-auto-select
+if errorlevel 1 (
+    echo Installer build FAILED.
+    exit /b 1
+)
+
+echo Installer: installers\remotedesktop_installer_win64.exe

{remotedesktop-1.4.0 → remotedesktop-1.5.0}/src/remotedesktop/__init__.py

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

{remotedesktop-1.4.0 → remotedesktop-1.5.0}/src/remotedesktop/app.py

@@ -16,7 +16,7 @@ import sqlite3
 import sys
 import time
 
-from PySide6.QtCore import QProcess, Qt, QTimer
+from PySide6.QtCore import QObject, QProcess, Qt, QTimer, Signal
 from PySide6.QtGui import QCloseEvent, QKeySequence
 from PySide6.QtNetwork import QNetworkInterface
 from PySide6.QtWidgets import (
@@ -41,7 +41,7 @@ from PySide6.QtWidgets import (
 
 from remotedesktop import __version__, compat, db, icon, logs, window_state
 from remotedesktop.about import AboutTab
-from remotedesktop.autostart import Autostart
+from remotedesktop.autostart import Autostart, installed_launcher
 from remotedesktop.client import DiscoveryPanel, ServerSession
 from remotedesktop.clipboard import ClipboardSync
 from remotedesktop.config import KnownServers, Settings, default_db_path, load_client_identity
@@ -56,7 +56,7 @@ from remotedesktop.preferences import (
     load_performance_window_seconds,
     load_viewer_enabled,
 )
-from remotedesktop.server import SharingTab
+from remotedesktop.server import SharingTab, ViewersTable
 from remotedesktop.sharing import ShareClient
 from remotedesktop.single_instance import SingleInstance
 from remotedesktop.viewer import ViewerWidget
@@ -67,6 +67,52 @@ _log = logging.getLogger("remotedesktop.app")
 _RECONNECT_CAP_SECONDS = 30.0
 
 
+class _SessionsTable(ViewersTable):
+    """The client-side twin of the viewers table: one row per connected
+    server session, with the same live network statistics."""
+
+    _COLUMNS = [
+        "Name", "Address", "Version", "Send", "Receive",
+        "RTT", "RTT mean", "RTT min", "RTT max", "RTT p99", "RTT jitter",
+    ]
+    _RATE_COLUMNS = (3, 4)
+    _MS_COLUMNS = (5, 6, 7, 8, 9, 10)
+    _METRIC_COLUMNS = _RATE_COLUMNS + _MS_COLUMNS
+
+    def _identity_values(self, viewer: dict) -> list[str]:
+        return [
+            viewer["name"] or "(unknown)",
+            viewer["address"],
+            self._version_cell(viewer["app_version"]),
+        ]
+
+
+class _ConnectedServersSource(QObject):
+    """Adapts the window's connected sessions to the ViewersTable source
+    protocol (a `viewers()` method plus a change signal)."""
+
+    clientCountChanged = Signal(int)
+
+    def __init__(self, window: "MainWindow") -> None:
+        super().__init__(window)
+        self._window = window
+
+    def viewers(self) -> list[dict]:
+        return [
+            {
+                "name": session.name,
+                "address": session.key,
+                "app_version": session.client.server_app_version,
+                "stream": session.client.stream,
+            }
+            for session in self._window._sessions
+            if session.connected
+        ]
+
+    def notify(self) -> None:
+        self.clientCountChanged.emit(len(self.viewers()))
+
+
 class MainWindow(QMainWindow):
     def __init__(
         self,
@@ -161,20 +207,38 @@ class MainWindow(QMainWindow):
         self.get_client_log_button.clicked.connect(self.sharing_tab.request_client_log)
 
         connections_tab = QWidget()
-        sharing_group = QGroupBox("Server (sharing this computer)")
-        QVBoxLayout(sharing_group).addWidget(self.sharing_tab)
-        # Kept as an attribute: hidden when the viewer role is off (a
-        # server-only instance has no server history of its own). "History"
-        # (not "on LAN") — the live discovery list is the Servers on LAN
+        # One outer group box per role, side by side as WIDGETS (not column
+        # layouts): a hidden widget frees its space, so when a role is off
+        # the other box starts at the left edge instead of leaving a gap.
+        # Client box: live connected-server sessions (with the same network
+        # statistics as the viewers table) over the persisted server
+        # records. Server box: live sharing status/viewers over the
+        # persisted client pairings.
+        self._client_role_group = QGroupBox("Client (viewer)")
+        client_role_layout = QVBoxLayout(self._client_role_group)
+        self._sessions_source = _ConnectedServersSource(self)
+        self.sessions_table = _SessionsTable(self.client_performance)
+        self.sessions_table.set_share_server(self._sessions_source)
+        sessions_box = QGroupBox("Connected servers")
+        QVBoxLayout(sessions_box).addWidget(self.sessions_table)
+        # "History" (not "on LAN") — the live discovery list is the left
         # panel; these tables are the persisted first/last-seen records.
-        self._servers_group = QGroupBox("Server history")
-        QVBoxLayout(self._servers_group).addWidget(
+        servers_history_box = QGroupBox("Server history")
+        QVBoxLayout(servers_history_box).addWidget(
             InventoryTab(self.client_inventory, "Forget", self._forget_server)
         )
-        clients_group = QGroupBox("Client history")
-        QVBoxLayout(clients_group).addWidget(
+        client_role_layout.addWidget(sessions_box)
+        client_role_layout.addWidget(servers_history_box)
+
+        self._server_role_group = QGroupBox("Server (sharing)")
+        server_role_layout = QVBoxLayout(self._server_role_group)
+        server_role_layout.addWidget(self.sharing_tab)
+        clients_history_box = QGroupBox("Client history")
+        QVBoxLayout(clients_history_box).addWidget(
             InventoryTab(self.server_inventory, "Revoke", self._revoke_client)
         )
+        server_role_layout.addWidget(clients_history_box)
+
         log_group = QGroupBox("Connection log")
         log_layout = QVBoxLayout(log_group)
         log_buttons = QHBoxLayout()
@@ -183,20 +247,15 @@ class MainWindow(QMainWindow):
         log_buttons.addStretch(1)
         log_layout.addLayout(log_buttons)
         log_layout.addWidget(self.connection_log)
-        # Left column: this computer (sharing status, log). Right column:
-        # the LAN peer tables. Column-level vboxes so a hidden group lets
-        # its neighbor take the full column.
-        left_column = QVBoxLayout()
-        left_column.addWidget(sharing_group)
-        left_column.addWidget(log_group)
-        right_column = QVBoxLayout()
-        right_column.addWidget(self._servers_group)
-        right_column.addWidget(clients_group)
-        columns = QHBoxLayout(connections_tab)
-        columns.addLayout(left_column, 1)
-        columns.addLayout(right_column, 1)
-        if not self._viewer_enabled:
-            self._servers_group.hide()
+        # Client box left, Server box right (the order the indicators and
+        # Preferences use); the log spans the bottom.
+        columns = QHBoxLayout()
+        columns.addWidget(self._client_role_group, 1)
+        columns.addWidget(self._server_role_group, 1)
+        connections_layout = QVBoxLayout(connections_tab)
+        connections_layout.addLayout(columns, 2)
+        connections_layout.addWidget(log_group, 1)
+        self._update_connections_groups()
         self._tabs.addTab(connections_tab, "Connections")
         # The Performance sub-tabs follow the roles: "Viewing" exists only
         # with the viewer role, "Sharing" only while actually serving —
@@ -250,16 +309,18 @@ class MainWindow(QMainWindow):
         if not self._viewer_enabled:
             self.discovery_panel.hide()
         self._update_dock_layout()
-        # No title text: the indicators and server list are self-explanatory.
-        # (The View menu still names it "Servers on LAN panel" for reopening.)
-        self.servers_dock = QDockWidget("", self)
+        # No title bar at all: the contents are self-explanatory, and the
+        # View menu ("Panel") is the way to show or hide it — a blank header
+        # strip whose only job was the X earned no space. The Closable
+        # feature must stay even though there is no X: without it Qt
+        # disables the toggleViewAction, killing the View-menu toggle.
+        self.panel_dock = QDockWidget("", self)
         # An object name is required for saveState() to persist the dock.
-        self.servers_dock.setObjectName("servers_dock")
-        # Closable (the X) but never floatable/movable: the panel lives on
-        # the left, and the View menu brings it back.
-        self.servers_dock.setFeatures(QDockWidget.DockWidgetFeature.DockWidgetClosable)
-        self.servers_dock.setWidget(dock_body)
-        self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, self.servers_dock)
+        self.panel_dock.setObjectName("panel_dock")
+        self.panel_dock.setFeatures(QDockWidget.DockWidgetFeature.DockWidgetClosable)
+        self.panel_dock.setTitleBarWidget(QWidget(self.panel_dock))
+        self.panel_dock.setWidget(dock_body)
+        self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, self.panel_dock)
 
         self.preferences_tab = PreferencesTab(
             self._settings,
@@ -342,9 +403,9 @@ class MainWindow(QMainWindow):
         self.quit_action.triggered.connect(self._quit)
         self._view_menu = bar.addMenu("&View")
         # The dock's own toggle action: the way back after closing the panel.
-        self.servers_panel_action = self.servers_dock.toggleViewAction()
-        self.servers_panel_action.setText("&Servers on LAN panel")
-        self._view_menu.addAction(self.servers_panel_action)
+        self.panel_action = self.panel_dock.toggleViewAction()
+        self.panel_action.setText("&Panel")
+        self._view_menu.addAction(self.panel_action)
         self.refresh_action = self._view_menu.addAction("&Refresh server list")
         self.refresh_action.setShortcut(QKeySequence("F5"))
         self.refresh_action.triggered.connect(self.discovery_panel.refresh)
@@ -385,7 +446,7 @@ class MainWindow(QMainWindow):
             "<h3>No server connected</h3>"
             "<p>Computers sharing their screen appear automatically in the "
             "panel on the left<br>"
-            "(View&nbsp;▸&nbsp;Servers on LAN panel if it is hidden).</p>"
+            "(View&nbsp;▸&nbsp;Panel if it is hidden).</p>"
             "<p>Double-click one — or select it and click <b>Connect</b> — "
             "and this tab becomes your view of that computer.</p>"
             "<p>To make a computer appear in the list, enable "
@@ -429,6 +490,13 @@ class MainWindow(QMainWindow):
         button.setFocusPolicy(Qt.FocusPolicy.NoFocus)
         return button
 
+    def _update_connections_groups(self) -> None:
+        """Show each Connections-tab role box only while its role is on —
+        a client-only instance has no viewers or pairings to display, and a
+        server-only one has no sessions or server history."""
+        self._client_role_group.setVisible(self._viewer_enabled)
+        self._server_role_group.setVisible(self.sharing_tab.serving)
+
     def _update_performance_tabs(self) -> None:
         """Show a Performance sub-tab per role that can produce data."""
         pages = self.performance_pages
@@ -473,10 +541,8 @@ class MainWindow(QMainWindow):
             if placeholder_index != -1:
                 self._tabs.removeTab(placeholder_index)
             self.discovery_panel.hide()
-            self._servers_group.hide()
         else:
             self.discovery_panel.show()
-            self._servers_group.show()
             self._ensure_placeholder()
             self._tabs.setCurrentIndex(0)
             if self._auto_scan:
@@ -485,6 +551,7 @@ class MainWindow(QMainWindow):
         self._update_dock_layout()
         self._update_role_indicators()
         self._update_performance_tabs()
+        self._update_connections_groups()
 
     def _on_current_tab_changed(self, _index: int) -> None:
         self._refresh_status_bar()
@@ -523,11 +590,11 @@ class MainWindow(QMainWindow):
             return
         self._fullscreen_state = {
             "maximized": self.isMaximized(),
-            "dock_visible": self.servers_dock.isVisible(),
+            "dock_visible": self.panel_dock.isVisible(),
         }
         self.menuBar().hide()
         self.statusBar().hide()
-        self.servers_dock.hide()
+        self.panel_dock.hide()
         self._tabs.tabBar().hide()
         self.showFullScreen()
         self.fullscreen_action.setChecked(True)
@@ -544,7 +611,7 @@ class MainWindow(QMainWindow):
         self.menuBar().show()
         self.statusBar().show()
         # A dock the user had closed before fullscreen stays closed.
-        self.servers_dock.setVisible(state["dock_visible"])
+        self.panel_dock.setVisible(state["dock_visible"])
         self._tabs.tabBar().show()
         if state["maximized"]:
             self.showMaximized()
@@ -639,6 +706,7 @@ class MainWindow(QMainWindow):
         self._update_window_title()
         self._update_role_indicators()
         self._update_performance_tabs()
+        self._update_connections_groups()
 
     def _quit(self) -> None:
         self._quitting = True
@@ -710,14 +778,22 @@ class MainWindow(QMainWindow):
         )
         if answer != QMessageBox.StandardButton.Yes:
             return
+        # An installed (pyship) instance relaunches via the launcher exe, which
+        # picks the newest installed version — so restart-after-update actually
+        # starts the update. From source/venv, relaunch this interpreter.
+        launcher = installed_launcher()
+        if launcher is not None:
+            program, args = str(launcher), []
+        else:
+            program, args = sys.executable, ["-m", "remotedesktop"]
         self.log("Restarting: freeing ports and launching a new process")
-        _log.info("Restart requested — relaunching %s -m remotedesktop", sys.executable)
+        _log.info("Restart requested — relaunching %s %s", program, " ".join(args))
         self.sharing_tab.shutdown()
-        if not QProcess.startDetached(sys.executable, ["-m", "remotedesktop"]):
-            # Extremely unlikely (sys.executable exists); the app stays open —
+        if not QProcess.startDetached(program, args):
+            # Extremely unlikely (the program path exists); the app stays open —
             # sharing is stopped, but the machine isn't left with nothing.
             self.log("Restart failed: could not launch a new process — restart manually")
-            _log.error("QProcess.startDetached failed for %s", sys.executable)
+            _log.error("QProcess.startDetached failed for %s", program)
             return
         self._quit()
 
@@ -977,6 +1053,7 @@ class MainWindow(QMainWindow):
         self.log(f"Closed connection to {session.name} ({session.key})")
         self._update_window_title()
         self._refresh_status_bar()
+        self._sessions_source.notify()
 
     def _on_tab_close_requested(self, index: int) -> None:
         if index < len(self._sessions):  # fixed tabs carry no close button
@@ -1032,6 +1109,7 @@ class MainWindow(QMainWindow):
             box.show()  # non-modal: streaming continues behind it
         self.client_inventory.record(session.key, "connected", name=session.name)
         self._persist_sessions()  # the welcome may have renamed the session
+        self._sessions_source.notify()
         session.viewer.setFocus()
         self._set_session_status(
             session,
@@ -1069,6 +1147,7 @@ class MainWindow(QMainWindow):
             session.viewer.clear("Disconnected")
             self._set_session_status(session, f"Disconnected from {session.name}")
         self._update_window_title()
+        self._sessions_source.notify()
         if session.auto_reconnect and not session.denied and not self._quitting:
             self._schedule_reconnect(session)
 

{remotedesktop-1.4.0 → remotedesktop-1.5.0}/src/remotedesktop/autostart.py

@@ -11,6 +11,7 @@ Installations upgraded from the separate server app may still carry the old
 startup) moves that registration to the new value name and command.
 """
 
+import re
 import sys
 from pathlib import Path
 
@@ -22,10 +23,31 @@ _RUN_KEY = r"Software\Microsoft\Windows\CurrentVersion\Run"
 _VALUE_NAME = "remotedesktop"
 _LEGACY_VALUE_NAME = "remotedesktop-server"  # the pre-1.0 server-only app
 
+# A pyship CLIP directory: <install dir>\remotedesktop_<version>\pythonw.exe.
+_CLIP_DIR_RE = re.compile(r"remotedesktop_\d+(\.\d+)*", re.IGNORECASE)
+
+
+def installed_launcher() -> Path | None:
+    """The pyship launcher exe, when running from an installed CLIP.
+
+    The launcher always starts the newest installed remotedesktop_<version>
+    directory, so registrations and relaunches that go through it survive
+    upgrades — a path into this CLIP would go stale instead.
+    """
+    exe_dir = Path(sys.executable).parent
+    if _CLIP_DIR_RE.fullmatch(exe_dir.name):
+        launcher = exe_dir.parent / "remotedesktop" / "remotedesktop.exe"
+        if launcher.exists():
+            return launcher
+    return None
+
 
 def app_command() -> str:
     """The command line that launches this installation at login."""
-    exe = Path(sys.executable).with_name("remotedesktop.exe")
+    launcher = installed_launcher()
+    if launcher is not None:
+        return f'"{launcher}" --minimized'
+    exe = Path(sys.executable).with_name("remotedesktop.exe")  # venv Scripts dir
     if exe.exists():
         return f'"{exe}" --minimized'
     # Fallback (e.g. running from source without the entry-point exe).