remotedesktop 0.2.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

remotedesktop/__init__.py

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

remotedesktop/autostart.py

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

remotedesktop/server.py

@@ -1,174 +1,189 @@
-"""Server GUI application: shares this computer's desktop with permitted
-clients and prompts the user to approve first-time connections."""
-
-import socket
-import sqlite3
-import sys
-import time
-
-from PySide6.QtCore import Qt
-from PySide6.QtGui import QCloseEvent
-from PySide6.QtWidgets import (
-    QApplication,
-    QLabel,
-    QMainWindow,
-    QMessageBox,
-    QPlainTextEdit,
-    QTabWidget,
-    QVBoxLayout,
-    QWidget,
-)
-
-from remotedesktop import db, tls, window_state
-from remotedesktop.clipboard import ClipboardSync
-from remotedesktop.config import PairedClients, Settings, default_config_dir, default_db_path
-from remotedesktop.discovery import (
-    DEFAULT_CONNECT_PORT,
-    DISCOVERY_PORT,
-    DiscoveryResponder,
-)
-from remotedesktop.inventory import ConnectionInventory, InventoryTab
-from remotedesktop.sharing import ShareServer
-
-
-class ServerWindow(QMainWindow):
-    def __init__(
-        self,
-        *,
-        discovery_port: int = DISCOVERY_PORT,
-        connect_port: int = DEFAULT_CONNECT_PORT,
-        paired: PairedClients | None = None,
-        credentials=None,
-        connection: sqlite3.Connection | None = None,
-    ) -> None:
-        super().__init__()
-        self.setWindowTitle("Remote Desktop Server")
-        self._name = socket.gethostname()
-
-        self._summary = QLabel(alignment=Qt.AlignmentFlag.AlignCenter)
-        self.connection_log = QPlainTextEdit()
-        self.connection_log.setReadOnly(True)
-        self.connection_log.setMaximumBlockCount(1000)
-        status_tab = QWidget()
-        status_layout = QVBoxLayout(status_tab)
-        status_layout.addWidget(self._summary)
-        status_layout.addWidget(self.connection_log, stretch=1)
-
-        # Tests inject a connection to a temp database; the app uses the default.
-        self._db = connection if connection is not None else db.connect(default_db_path())
-        self.inventory = ConnectionInventory(self._db, "server_peers", self)
-        tabs = QTabWidget()
-        tabs.addTab(status_tab, "Status")
-        tabs.addTab(
-            InventoryTab(self.inventory, "Revoke access", self._revoke_client),
-            "Clients on LAN",
-        )
-        self.setCentralWidget(tabs)
-
-        if credentials is None:
-            config_dir = default_config_dir()
-            credentials = tls.load_or_create_credentials(
-                config_dir / "server_cert.pem", config_dir / "server_key.pem"
-            )
-        if paired is None:
-            paired = PairedClients(self._db)
-        self._clipboard = ClipboardSync(parent=self)
-        self.share_server = ShareServer(
-            self._ask_approval,
-            credentials=credentials,
-            paired=paired,
-            clipboard=self._clipboard,
-            parent=self,
-        )
-        self.share_server.status.connect(self.log)
-        self.share_server.clientCountChanged.connect(self._update_summary)
-        self.share_server.peerEvent.connect(self._record_peer)
-        self._listening = self.share_server.listen(connect_port)
-
-        self.responder: DiscoveryResponder | None = None
-        self._discoverable = False
-        if self._listening:
-            responder = DiscoveryResponder(
-                self._name, self.share_server.port, discovery_port=discovery_port
-            )
-            try:
-                responder.start()
-            except OSError as error:
-                self.log(
-                    f"Discovery unavailable (UDP port {discovery_port}): {error} — "
-                    "another server may already be running"
-                )
-            else:
-                self.responder = responder
-                self._discoverable = True
-                self.log(
-                    f'Discoverable as "{self._name}" '
-                    f"(UDP port {discovery_port}, TCP port {self.share_server.port})"
-                )
-        self._update_summary(0)
-        self._settings = Settings(self._db)
-        window_state.restore_geometry(self, self._settings, window_state.SERVER_GEOMETRY_KEY)
-
-    def log(self, message: str) -> None:
-        self.connection_log.appendPlainText(f"{time.strftime('%H:%M:%S')}  {message}")
-
-    def _record_peer(self, event: dict) -> None:
-        self.inventory.record(
-            event["key"],
-            event["event"],
-            name=event.get("name", ""),
-            address=event.get("address", ""),
-            detail=event.get("detail", ""),
-        )
-
-    def _update_summary(self, client_count: int) -> None:
-        if not self._listening:
-            self._summary.setText("Cannot share: the connection port is already in use")
-            return
-        discoverable = (
-            f'Discoverable on this LAN as "{self._name}"'
-            if self._discoverable
-            else "Not discoverable (discovery port in use)"
-        )
-        sharing = (
-            f"Sharing this desktop with {client_count} viewer(s)"
-            if client_count
-            else "Not sharing"
-        )
-        self._summary.setText(f"{discoverable}\n{sharing}")
-
-    def _revoke_client(self, client_id: str) -> None:
-        answer = QMessageBox.question(
-            self,
-            "Revoke access",
-            f"Revoke access for client {client_id}?\n\n"
-            "It will be disconnected now and must be approved again to reconnect.",
-        )
-        if answer == QMessageBox.StandardButton.Yes:
-            self.share_server.revoke_client(client_id)
-
-    def _ask_approval(self, client_id: str, client_name: str) -> bool:
-        answer = QMessageBox.question(
-            self,
-            "Connection request",
-            f'Allow "{client_name}" to view this desktop?\n\nClient id: {client_id}',
-        )
-        return answer == QMessageBox.StandardButton.Yes
-
-    def closeEvent(self, event: QCloseEvent) -> None:
-        window_state.save_geometry(self, self._settings, window_state.SERVER_GEOMETRY_KEY)
-        if self.responder is not None:
-            self.responder.stop()
-        self.share_server.close()
-        super().closeEvent(event)
-
-
-def main() -> None:  # pragma: no cover - runs the Qt event loop
-    app = QApplication(sys.argv)
-    window = ServerWindow()
-    window.show()
-    raise SystemExit(app.exec())
-
-
-if __name__ == "__main__":  # pragma: no cover
-    main()
+"""Server GUI application: shares this computer's desktop with permitted
+clients and prompts the user to approve first-time connections."""
+
+import socket
+import sqlite3
+import sys
+import time
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QCloseEvent
+from PySide6.QtWidgets import (
+    QApplication,
+    QCheckBox,
+    QLabel,
+    QMainWindow,
+    QMessageBox,
+    QPlainTextEdit,
+    QTabWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+from remotedesktop import db, tls, window_state
+from remotedesktop.autostart import Autostart
+from remotedesktop.clipboard import ClipboardSync
+from remotedesktop.config import PairedClients, Settings, default_config_dir, default_db_path
+from remotedesktop.discovery import (
+    DEFAULT_CONNECT_PORT,
+    DISCOVERY_PORT,
+    DiscoveryResponder,
+)
+from remotedesktop.inventory import ConnectionInventory, InventoryTab
+from remotedesktop.sharing import ShareServer
+
+
+class ServerWindow(QMainWindow):
+    def __init__(
+        self,
+        *,
+        discovery_port: int = DISCOVERY_PORT,
+        connect_port: int = DEFAULT_CONNECT_PORT,
+        paired: PairedClients | None = None,
+        credentials=None,
+        connection: sqlite3.Connection | None = None,
+        autostart: Autostart | None = None,
+    ) -> None:
+        super().__init__()
+        self.setWindowTitle("Remote Desktop Server")
+        self._name = socket.gethostname()
+
+        self._summary = QLabel(alignment=Qt.AlignmentFlag.AlignCenter)
+        self._autostart = autostart if autostart is not None else Autostart()
+        self.autostart_checkbox = QCheckBox("Start this server when I log in to Windows")
+        self.autostart_checkbox.setChecked(self._autostart.is_enabled())
+        self.autostart_checkbox.setEnabled(self._autostart.available)
+        self.autostart_checkbox.toggled.connect(self._on_autostart_toggled)
+        self.connection_log = QPlainTextEdit()
+        self.connection_log.setReadOnly(True)
+        self.connection_log.setMaximumBlockCount(1000)
+        status_tab = QWidget()
+        status_layout = QVBoxLayout(status_tab)
+        status_layout.addWidget(self._summary)
+        status_layout.addWidget(self.autostart_checkbox, alignment=Qt.AlignmentFlag.AlignHCenter)
+        status_layout.addWidget(self.connection_log, stretch=1)
+
+        # Tests inject a connection to a temp database; the app uses the default.
+        self._db = connection if connection is not None else db.connect(default_db_path())
+        self.inventory = ConnectionInventory(self._db, "server_peers", self)
+        tabs = QTabWidget()
+        tabs.addTab(status_tab, "Status")
+        tabs.addTab(
+            InventoryTab(self.inventory, "Revoke access", self._revoke_client),
+            "Clients on LAN",
+        )
+        self.setCentralWidget(tabs)
+
+        if credentials is None:
+            config_dir = default_config_dir()
+            credentials = tls.load_or_create_credentials(
+                config_dir / "server_cert.pem", config_dir / "server_key.pem"
+            )
+        if paired is None:
+            paired = PairedClients(self._db)
+        self._clipboard = ClipboardSync(parent=self)
+        self.share_server = ShareServer(
+            self._ask_approval,
+            credentials=credentials,
+            paired=paired,
+            clipboard=self._clipboard,
+            parent=self,
+        )
+        self.share_server.status.connect(self.log)
+        self.share_server.clientCountChanged.connect(self._update_summary)
+        self.share_server.peerEvent.connect(self._record_peer)
+        self._listening = self.share_server.listen(connect_port)
+
+        self.responder: DiscoveryResponder | None = None
+        self._discoverable = False
+        if self._listening:
+            responder = DiscoveryResponder(
+                self._name, self.share_server.port, discovery_port=discovery_port
+            )
+            try:
+                responder.start()
+            except OSError as error:
+                self.log(
+                    f"Discovery unavailable (UDP port {discovery_port}): {error} — "
+                    "another server may already be running"
+                )
+            else:
+                self.responder = responder
+                self._discoverable = True
+                self.log(
+                    f'Discoverable as "{self._name}" '
+                    f"(UDP port {discovery_port}, TCP port {self.share_server.port})"
+                )
+        self._update_summary(0)
+        self._settings = Settings(self._db)
+        window_state.restore_geometry(self, self._settings, window_state.SERVER_GEOMETRY_KEY)
+
+    def log(self, message: str) -> None:
+        self.connection_log.appendPlainText(f"{time.strftime('%H:%M:%S')}  {message}")
+
+    def _record_peer(self, event: dict) -> None:
+        self.inventory.record(
+            event["key"],
+            event["event"],
+            name=event.get("name", ""),
+            address=event.get("address", ""),
+            detail=event.get("detail", ""),
+        )
+
+    def _update_summary(self, client_count: int) -> None:
+        if not self._listening:
+            self._summary.setText("Cannot share: the connection port is already in use")
+            return
+        discoverable = (
+            f'Discoverable on this LAN as "{self._name}"'
+            if self._discoverable
+            else "Not discoverable (discovery port in use)"
+        )
+        sharing = (
+            f"Sharing this desktop with {client_count} viewer(s)"
+            if client_count
+            else "Not sharing"
+        )
+        self._summary.setText(f"{discoverable}\n{sharing}")
+
+    def _on_autostart_toggled(self, checked: bool) -> None:
+        self._autostart.set_enabled(checked)
+        self.log(
+            "Server will start at login" if checked else "Server will no longer start at login"
+        )
+
+    def _revoke_client(self, client_id: str) -> None:
+        answer = QMessageBox.question(
+            self,
+            "Revoke access",
+            f"Revoke access for client {client_id}?\n\n"
+            "It will be disconnected now and must be approved again to reconnect.",
+        )
+        if answer == QMessageBox.StandardButton.Yes:
+            self.share_server.revoke_client(client_id)
+
+    def _ask_approval(self, client_id: str, client_name: str) -> bool:
+        answer = QMessageBox.question(
+            self,
+            "Connection request",
+            f'Allow "{client_name}" to view this desktop?\n\nClient id: {client_id}',
+        )
+        return answer == QMessageBox.StandardButton.Yes
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        window_state.save_geometry(self, self._settings, window_state.SERVER_GEOMETRY_KEY)
+        if self.responder is not None:
+            self.responder.stop()
+        self.share_server.close()
+        super().closeEvent(event)
+
+
+def main() -> None:  # pragma: no cover - runs the Qt event loop
+    app = QApplication(sys.argv)
+    window = ServerWindow()
+    window.show()
+    raise SystemExit(app.exec())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

{remotedesktop-0.2.0.dist-info → remotedesktop-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.2.0
+Version: 0.4.0
 Summary: Remote desktop client/server for Windows computers on the same LAN, with autodiscovery. Provides screen, keyboard, mouse, and clipboard sharing without RDP or Microsoft authentication.
 Author-email: James Abel <j@abel.co>
 License-Expression: MIT
@@ -28,6 +28,10 @@ Description-Content-Type: text/markdown
 A Python client/server application that provides remote desktop for Windows
 computers on the same LAN, with autodiscovery of servers.
 
+The server can optionally start automatically when you log in to Windows —
+a checkbox on its Status tab registers it under the per-user Run key (no
+administrator rights needed).
+
 Connections are made to the desktop screen, keyboard, mouse, and clipboard.
 Other connections are not provided, such as shared drives, devices, or
 multimedia (e.g., audio).
@@ -111,3 +115,13 @@ uv run pytest    # run the tests
 Run the tests from PowerShell or cmd, not Git Bash: Git Bash puts Git's
 MinGW OpenSSL DLLs on `PATH`, which Qt's TLS backend loads and crashes on.
 From PowerShell, Qt uses the Windows schannel backend as intended.
+
+### The `badges` branch
+
+The coverage badge above is served from the `badges` branch
+(`raw.githubusercontent.com/.../badges/coverage.svg`). CI regenerates the
+SVG after each test run on `master` and force-pushes it there as a single
+orphan commit. It lives on its own branch because `master` only accepts
+pull requests (a repository ruleset), so CI cannot commit to it directly;
+keeping the badge in the repo avoids depending on an external coverage
+service. The branch is generated output — never branch from it or merge it.

{remotedesktop-0.2.0.dist-info → remotedesktop-0.4.0.dist-info}/RECORD

@@ -1,4 +1,5 @@
-remotedesktop/__init__.py,sha256=U48HuI2lyUbilZSyrRLP34Te7Zx743rikPVFy5sj2Ro,100
+remotedesktop/__init__.py,sha256=d_RMAscIXOFiew0nH6TDft-NXuqIaPI46IniyCQ20tY,100
+remotedesktop/autostart.py,sha256=MM7qsO6MVcK4dEofjSyRPrKpBinKU5w6xaWptLDC-7g,2251
 remotedesktop/client.py,sha256=XRGPCCmbLDTjsB6eLi8sM87pR9iXWcNJIFZmh8MlMnE,10209
 remotedesktop/clipboard.py,sha256=aDVwBVztSh2MxgTFIMaVsoXjZIrjDeVBnSOCmou9L9A,3743
 remotedesktop/config.py,sha256=pE8hUEnktgthRDALyHz8qdUeUKjIhcSotffgniZLszM,4285
@@ -7,13 +8,13 @@ remotedesktop/discovery.py,sha256=ai_ic2XtSKO_m8y5IFkHQ88PBDgd_N6YOEccaIBtmis,47
 remotedesktop/input_injection.py,sha256=p-MRpnS7WDt5S8JK4gNC5cgAjM9DMqV-kzqJkLdtKTw,4581
 remotedesktop/inventory.py,sha256=fJLh2Ni2oCuUTEvHNANzpVf4abJT1eLeDU-YRSHwpjQ,7406
 remotedesktop/protocol.py,sha256=IeX-SVz2KiZzYZ3ZiAHE8ZNYC8zyVNQi5uTxcGD4Zzc,2532
-remotedesktop/server.py,sha256=eV1adhxRK7opl8jNPsdBiHOugKOZLmpTR8ryRtDAALg,6252
+remotedesktop/server.py,sha256=EgfyHEF4LYe7GjK5TZTWbB3Ul4TvH08x8MSkG_Fi3Yk,7261
 remotedesktop/sharing.py,sha256=XgSCiBcb-r_i2RmPut3ifGS6YvE4AX9O5hr50ob2sXk,24313
 remotedesktop/tls.py,sha256=AGrBpDq1gdjQm7TZ74y2W5-RxyEcbsFDPlNdRvadaAk,3934
 remotedesktop/viewer.py,sha256=b0MGSVuhQKdrQM2cjxHstt_2Flgw6dZv1awAenL4Bys,6554
 remotedesktop/window_state.py,sha256=X47Bl_FrV5WMyVDA-PWShum9pt6TMrR0HhADuz-CqNw,1012
-remotedesktop-0.2.0.dist-info/METADATA,sha256=mYg-85BgtdLoWI7FLQMZmF7IMUmXBj_rC2cEHoEe2-M,5024
-remotedesktop-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-remotedesktop-0.2.0.dist-info/entry_points.txt,sha256=MmHDIIsykHkOwLf_IbGweGDFA2BuITI8_lUXsMpihcg,112
-remotedesktop-0.2.0.dist-info/licenses/LICENSE,sha256=6rWgMfDohGLDuJ0UFOyLphM28Nn0fuN26MczIQldMkc,1067
-remotedesktop-0.2.0.dist-info/RECORD,,
+remotedesktop-0.4.0.dist-info/METADATA,sha256=eXN_CFFwXAbg0J9jXzM3TDUnJWVOMAFSRfKtJ8WOaCU,5734
+remotedesktop-0.4.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+remotedesktop-0.4.0.dist-info/entry_points.txt,sha256=MmHDIIsykHkOwLf_IbGweGDFA2BuITI8_lUXsMpihcg,112
+remotedesktop-0.4.0.dist-info/licenses/LICENSE,sha256=6rWgMfDohGLDuJ0UFOyLphM28Nn0fuN26MczIQldMkc,1067
+remotedesktop-0.4.0.dist-info/RECORD,,