remotedesktop 0.2.0__tar.gz → 0.3.0__tar.gz

{remotedesktop-0.2.0 → remotedesktop-0.3.0}/.github/workflows/ci.yml

@@ -43,6 +43,11 @@ jobs:
           git config user.name "github-actions[bot]"
           git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
           $blob = (git hash-object -w badges/coverage.svg).Trim()
-          $tree = ("100644 blob $blob`tcoverage.svg" | git mktree).Trim()
+          # Build the tree via a temp index, not `... | git mktree`: PowerShell
+          # pipes CRLF to native stdin, which puts a literal \r in the filename.
+          $env:GIT_INDEX_FILE = "$env:RUNNER_TEMP\badge-index"
+          git update-index --add --cacheinfo "100644,$blob,coverage.svg"
+          $tree = (git write-tree).Trim()
+          Remove-Item Env:\GIT_INDEX_FILE
           $commit = (git commit-tree $tree -m "Update coverage badge").Trim()
           git push --force origin "${commit}:refs/heads/badges"

{remotedesktop-0.2.0 → remotedesktop-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.2.0
+Version: 0.3.0
 Summary: Remote desktop client/server for Windows computers on the same LAN, with autodiscovery. Provides screen, keyboard, mouse, and clipboard sharing without RDP or Microsoft authentication.
 Author-email: James Abel <j@abel.co>
 License-Expression: MIT
@@ -28,6 +28,10 @@ Description-Content-Type: text/markdown
 A Python client/server application that provides remote desktop for Windows
 computers on the same LAN, with autodiscovery of servers.
 
+The server can optionally start automatically when you log in to Windows —
+a checkbox on its Status tab registers it under the per-user Run key (no
+administrator rights needed).
+
 Connections are made to the desktop screen, keyboard, mouse, and clipboard.
 Other connections are not provided, such as shared drives, devices, or
 multimedia (e.g., audio).

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

@@ -9,6 +9,10 @@
 A Python client/server application that provides remote desktop for Windows
 computers on the same LAN, with autodiscovery of servers.
 
+The server can optionally start automatically when you log in to Windows —
+a checkbox on its Status tab registers it under the per-user Run key (no
+administrator rights needed).
+
 Connections are made to the desktop screen, keyboard, mouse, and clipboard.
 Other connections are not provided, such as shared drives, devices, or
 multimedia (e.g., audio).

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

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

remotedesktop-0.3.0/src/remotedesktop/autostart.py

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

{remotedesktop-0.2.0 → remotedesktop-0.3.0}/src/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.3.0/tests/test_autostart.py

@@ -0,0 +1,54 @@
+"""Autostart tests run against an isolated registry key, never the real
+Run key, so they cannot change what actually starts at login."""
+
+import sys
+
+import pytest
+
+from remotedesktop.autostart import Autostart, server_command
+
+pytestmark = pytest.mark.skipif(sys.platform != "win32", reason="Windows registry")
+
+_TEST_KEY = r"Software\remotedesktop-tests\Run"
+
+
+@pytest.fixture
+def autostart():
+    instance = Autostart(key_path=_TEST_KEY, value_name="test-server")
+    yield instance
+    instance.set_enabled(False)
+
+
+def test_enable_disable_round_trip(autostart):
+    assert not autostart.is_enabled()
+    autostart.set_enabled(True)
+    assert autostart.is_enabled()
+    autostart.set_enabled(False)
+    assert not autostart.is_enabled()
+
+
+def test_disable_when_not_registered_is_a_noop(autostart):
+    autostart.set_enabled(False)
+    assert not autostart.is_enabled()
+
+
+def test_registered_command_is_stored(autostart):
+    import winreg
+
+    autostart.set_enabled(True)
+    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, _TEST_KEY) as key:
+        value, kind = winreg.QueryValueEx(key, "test-server")
+    assert kind == winreg.REG_SZ
+    assert value == server_command()
+
+
+def test_server_command_is_quoted_and_launchable():
+    command = server_command()
+    assert command.startswith('"')
+    assert "remotedesktop" in command
+
+
+def test_unavailable_autostart_is_inert(autostart):
+    autostart.available = False
+    autostart.set_enabled(True)
+    assert not autostart.is_enabled()

{remotedesktop-0.2.0 → remotedesktop-0.3.0}/tests/test_server_window.py

@@ -1,130 +1,147 @@
-import socket
-
-from PySide6.QtNetwork import QHostAddress, QTcpServer
-from PySide6.QtWidgets import QMessageBox
-
-from remotedesktop import db
-from remotedesktop.config import PairedClients
-from remotedesktop.server import ServerWindow
-
-from test_discovery import free_udp_port
-from test_sharing import CLIENT_ID, make_client, pump
-
-
-def make_window(credentials, tmp_path, *, discovery_port=None, connect_port=0):
-    connection = db.connect(tmp_path / "server.db")
-    return ServerWindow(
-        discovery_port=discovery_port if discovery_port is not None else free_udp_port(),
-        connect_port=connect_port,
-        paired=PairedClients(connection),
-        credentials=credentials,
-        connection=connection,
-    )
-
-
-def test_window_listens_and_is_discoverable(qapp, credentials, tmp_path):
-    window = make_window(credentials, tmp_path)
-    try:
-        assert window._listening
-        assert window._discoverable
-        assert "Discoverable on this LAN" in window._summary.text()
-        assert "Not sharing" in window._summary.text()
-    finally:
-        window.close()
-
-
-def test_window_reports_discovery_port_conflict(qapp, credentials, tmp_path):
-    blocker = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    blocker.bind(("", 0))
-    port = blocker.getsockname()[1]
-    try:
-        window = make_window(credentials, tmp_path, discovery_port=port)
-        try:
-            assert window._listening
-            assert not window._discoverable
-            assert "Not discoverable" in window._summary.text()
-            assert "Discovery unavailable" in window.connection_log.toPlainText()
-        finally:
-            window.close()
-    finally:
-        blocker.close()
-
-
-def test_window_reports_connect_port_conflict(qapp, credentials, tmp_path):
-    # Block the port the same way the app binds it (dual-stack Any via Qt);
-    # a raw IPv4-only socket would not conflict with Qt's IPv6 Any binding.
-    blocker = QTcpServer()
-    assert blocker.listen(QHostAddress.SpecialAddress.Any, 0)
-    port = blocker.serverPort()
-    try:
-        window = make_window(credentials, tmp_path, connect_port=port)
-        try:
-            assert not window._listening
-            assert window.responder is None
-            assert "Cannot share" in window._summary.text()
-        finally:
-            window.close()
-    finally:
-        blocker.close()
-
-
-def test_approval_prompt_pairs_client_and_updates_summary(qapp, credentials, tmp_path, monkeypatch):
-    monkeypatch.setattr(
-        QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.Yes)
-    )
-    window = make_window(credentials, tmp_path)
-    client = make_client(tmp_path)
-    names = []
-    client.connected.connect(names.append)
-    client.connect_to("127.0.0.1", window.share_server.port)
-    try:
-        pump(qapp, lambda: names)
-        pump(qapp, lambda: "Sharing this desktop with 1 viewer(s)" in window._summary.text())
-        # The inventory tab tracked the pairing via peer events.
-        assert window.inventory._peers[CLIENT_ID].state == "connected (paired)"
-    finally:
-        client.close()
-        window.close()
-
-
-def test_refused_approval_denies_client(qapp, credentials, tmp_path, monkeypatch):
-    monkeypatch.setattr(
-        QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.No)
-    )
-    window = make_window(credentials, tmp_path)
-    client = make_client(tmp_path)
-    denials = []
-    client.denied.connect(denials.append)
-    client.connect_to("127.0.0.1", window.share_server.port)
-    try:
-        pump(qapp, lambda: denials)
-        assert "refused" in denials[0]
-    finally:
-        client.close()
-        window.close()
-
-
-def test_revoke_via_window_disconnects_client(qapp, credentials, tmp_path, monkeypatch):
-    monkeypatch.setattr(
-        QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.Yes)
-    )
-    window = make_window(credentials, tmp_path)
-    client = make_client(tmp_path)
-    names, disconnected = [], []
-    client.connected.connect(names.append)
-    client.disconnected.connect(lambda: disconnected.append(True))
-    client.connect_to("127.0.0.1", window.share_server.port)
-    try:
-        pump(qapp, lambda: names)
-        window._revoke_client(CLIENT_ID)
-        pump(qapp, lambda: disconnected)
-        assert window.inventory._peers[CLIENT_ID].state == "revoked"
-
-        # Answering "No" must not revoke anything.
-        monkeypatch.setattr(
-            QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.No)
-        )
-        window._revoke_client(CLIENT_ID)
-    finally:
-        client.close()
-        window.close()
+import socket
+
+from PySide6.QtNetwork import QHostAddress, QTcpServer
+from PySide6.QtWidgets import QMessageBox
+
+from remotedesktop import db
+from remotedesktop.autostart import Autostart
+from remotedesktop.config import PairedClients
+from remotedesktop.server import ServerWindow
+
+from test_discovery import free_udp_port
+from test_sharing import CLIENT_ID, make_client, pump
+
+_TEST_AUTOSTART_KEY = r"Software\remotedesktop-tests\WindowRun"
+
+
+def make_window(credentials, tmp_path, *, discovery_port=None, connect_port=0):
+    connection = db.connect(tmp_path / "server.db")
+    return ServerWindow(
+        discovery_port=discovery_port if discovery_port is not None else free_udp_port(),
+        connect_port=connect_port,
+        paired=PairedClients(connection),
+        credentials=credentials,
+        connection=connection,
+        autostart=Autostart(key_path=_TEST_AUTOSTART_KEY, value_name="window-test"),
+    )
+
+
+def test_window_listens_and_is_discoverable(qapp, credentials, tmp_path):
+    window = make_window(credentials, tmp_path)
+    try:
+        assert window._listening
+        assert window._discoverable
+        assert "Discoverable on this LAN" in window._summary.text()
+        assert "Not sharing" in window._summary.text()
+    finally:
+        window.close()
+
+
+def test_window_reports_discovery_port_conflict(qapp, credentials, tmp_path):
+    blocker = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    blocker.bind(("", 0))
+    port = blocker.getsockname()[1]
+    try:
+        window = make_window(credentials, tmp_path, discovery_port=port)
+        try:
+            assert window._listening
+            assert not window._discoverable
+            assert "Not discoverable" in window._summary.text()
+            assert "Discovery unavailable" in window.connection_log.toPlainText()
+        finally:
+            window.close()
+    finally:
+        blocker.close()
+
+
+def test_window_reports_connect_port_conflict(qapp, credentials, tmp_path):
+    # Block the port the same way the app binds it (dual-stack Any via Qt);
+    # a raw IPv4-only socket would not conflict with Qt's IPv6 Any binding.
+    blocker = QTcpServer()
+    assert blocker.listen(QHostAddress.SpecialAddress.Any, 0)
+    port = blocker.serverPort()
+    try:
+        window = make_window(credentials, tmp_path, connect_port=port)
+        try:
+            assert not window._listening
+            assert window.responder is None
+            assert "Cannot share" in window._summary.text()
+        finally:
+            window.close()
+    finally:
+        blocker.close()
+
+
+def test_autostart_checkbox_toggles_registration(qapp, credentials, tmp_path):
+    window = make_window(credentials, tmp_path)
+    try:
+        assert not window._autostart.is_enabled()
+        window.autostart_checkbox.setChecked(True)
+        assert window._autostart.is_enabled()
+        assert "start at login" in window.connection_log.toPlainText()
+        window.autostart_checkbox.setChecked(False)
+        assert not window._autostart.is_enabled()
+    finally:
+        window.close()
+
+
+def test_approval_prompt_pairs_client_and_updates_summary(qapp, credentials, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.Yes)
+    )
+    window = make_window(credentials, tmp_path)
+    client = make_client(tmp_path)
+    names = []
+    client.connected.connect(names.append)
+    client.connect_to("127.0.0.1", window.share_server.port)
+    try:
+        pump(qapp, lambda: names)
+        pump(qapp, lambda: "Sharing this desktop with 1 viewer(s)" in window._summary.text())
+        # The inventory tab tracked the pairing via peer events.
+        assert window.inventory._peers[CLIENT_ID].state == "connected (paired)"
+    finally:
+        client.close()
+        window.close()
+
+
+def test_refused_approval_denies_client(qapp, credentials, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.No)
+    )
+    window = make_window(credentials, tmp_path)
+    client = make_client(tmp_path)
+    denials = []
+    client.denied.connect(denials.append)
+    client.connect_to("127.0.0.1", window.share_server.port)
+    try:
+        pump(qapp, lambda: denials)
+        assert "refused" in denials[0]
+    finally:
+        client.close()
+        window.close()
+
+
+def test_revoke_via_window_disconnects_client(qapp, credentials, tmp_path, monkeypatch):
+    monkeypatch.setattr(
+        QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.Yes)
+    )
+    window = make_window(credentials, tmp_path)
+    client = make_client(tmp_path)
+    names, disconnected = [], []
+    client.connected.connect(names.append)
+    client.disconnected.connect(lambda: disconnected.append(True))
+    client.connect_to("127.0.0.1", window.share_server.port)
+    try:
+        pump(qapp, lambda: names)
+        window._revoke_client(CLIENT_ID)
+        pump(qapp, lambda: disconnected)
+        assert window.inventory._peers[CLIENT_ID].state == "revoked"
+
+        # Answering "No" must not revoke anything.
+        monkeypatch.setattr(
+            QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.No)
+        )
+        window._revoke_client(CLIENT_ID)
+    finally:
+        client.close()
+        window.close()