remotedesktop 0.3.0__tar.gz → 0.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: remotedesktop
-Version: 0.3.0
+Version: 0.5.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
@@ -115,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.3.0 → remotedesktop-0.5.0}/readme.md

@@ -96,3 +96,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.3.0 → remotedesktop-0.5.0}/src/remotedesktop/__init__.py

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

{remotedesktop-0.3.0 → remotedesktop-0.5.0}/src/remotedesktop/client.py

@@ -83,7 +83,9 @@ class DiscoveryPanel(QWidget):
 
 
 class ClientWindow(QMainWindow):
-    def __init__(self, *, connection: sqlite3.Connection | None = None) -> None:
+    def __init__(
+        self, *, connection: sqlite3.Connection | None = None, auto_scan: bool = True
+    ) -> None:
         super().__init__()
         self.setWindowTitle("Remote Desktop Client")
         # Tests inject a connection to a temp database; the app uses the default.
@@ -128,6 +130,9 @@ class ClientWindow(QMainWindow):
         self._settings = Settings(self._db)
         window_state.restore_geometry(self, self._settings, window_state.CLIENT_GEOMETRY_KEY)
         self.log("Client started")
+        # Tests pass auto_scan=False so window tests never broadcast on the LAN.
+        if auto_scan:
+            self.discovery_panel.refresh()
 
     def log(self, message: str) -> None:
         self.connection_log.appendPlainText(f"{time.strftime('%H:%M:%S')}  {message}")
@@ -180,6 +185,7 @@ class ClientWindow(QMainWindow):
         self._client = client
         client.status.connect(self.log)
         client.connected.connect(self._on_connected)
+        client.approvalPending.connect(self._on_approval_pending)
         client.denied.connect(self._on_denied)
         client.disconnected.connect(self._on_disconnected)
         client.frameReceived.connect(self._on_frame)
@@ -187,6 +193,15 @@ class ClientWindow(QMainWindow):
         self.statusBar().showMessage(f"Connecting to {server.name} ({server.host}:{server.port}) …")
         client.connect_to(server.host, server.port)
 
+    def _on_approval_pending(self) -> None:
+        self.viewer.clear(
+            f"Waiting for approval — someone at {self._server_name} "
+            "must allow this connection"
+        )
+        self.statusBar().showMessage(
+            f"Waiting for the user on {self._server_name} to approve this computer …"
+        )
+
     def _on_connected(self, server_name: str) -> None:
         self._server_name = server_name or self._server_name
         self._connected = True

{remotedesktop-0.3.0 → remotedesktop-0.5.0}/src/remotedesktop/server.py

@@ -163,12 +163,21 @@ class ServerWindow(QMainWindow):
             self.share_server.revoke_client(client_id)
 
     def _ask_approval(self, client_id: str, client_name: str) -> bool:
-        answer = QMessageBox.question(
-            self,
+        box = QMessageBox(
+            QMessageBox.Icon.Question,
             "Connection request",
             f'Allow "{client_name}" to view this desktop?\n\nClient id: {client_id}',
+            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
+            self,
         )
-        return answer == QMessageBox.StandardButton.Yes
+        # The server usually isn't the foreground app when a request arrives,
+        # and Windows won't give focus to a background app's dialog — keep it
+        # on top so it can't sit unnoticed behind other windows.
+        box.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True)
+        box.show()
+        box.raise_()
+        box.activateWindow()
+        return box.exec() == QMessageBox.StandardButton.Yes
 
     def closeEvent(self, event: QCloseEvent) -> None:
         window_state.save_geometry(self, self._settings, window_state.SERVER_GEOMETRY_KEY)

{remotedesktop-0.3.0 → remotedesktop-0.5.0}/src/remotedesktop/sharing.py

@@ -256,6 +256,8 @@ class ShareServer(QObject):
             )
         else:
             self.status.emit(f'"{client_name}" is new — asking for permission')
+        # Tell the client it's waiting on a human, not a stalled connection.
+        stream.send_json({"type": "pending"})
         # The approval prompt is modal: a nested event loop runs while it is
         # open, so this stream can disconnect (and _drop can run) meanwhile.
         self._prompting.add(stream)
@@ -407,6 +409,7 @@ class ShareClient(QObject):
     """Connects to a ShareServer over TLS, authenticates, and emits frames."""
 
     connected = Signal(str)  # server name
+    approvalPending = Signal()  # server is asking its user for permission
     denied = Signal(str)  # reason
     disconnected = Signal()
     frameReceived = Signal(QImage)
@@ -521,6 +524,11 @@ class ShareClient(QObject):
                     f'Server "{name}" accepted the connection — waiting for first frame'
                 )
                 self.connected.emit(name)
+            case "pending":
+                self.status.emit(
+                    "Server is asking its user for permission — waiting for approval"
+                )
+                self.approvalPending.emit()
             case "denied":
                 reason = str(message.get("reason", "denied"))
                 self.status.emit(f"Server denied the connection: {reason}")

{remotedesktop-0.3.0 → remotedesktop-0.5.0}/tests/test_client_window.py

@@ -1,164 +1,187 @@
-from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QListWidgetItem, QMessageBox
-
-from remotedesktop import client as client_module
-from remotedesktop import db
-from remotedesktop.client import ClientWindow, DiscoveryPanel
-from remotedesktop.config import PairedClients
-from remotedesktop.discovery import ServerInfo
-from remotedesktop.sharing import ShareServer
-
-from test_sharing import pump
-
-
-def make_window(tmp_path):
-    return ClientWindow(connection=db.connect(tmp_path / "client.db"))
-
-
-def make_share_server(credentials, tmp_path, *, approve=lambda *_: True):
-    server = ShareServer(
-        approve_client=approve,
-        credentials=credentials,
-        paired=PairedClients(db.connect(tmp_path / "server.db")),
-    )
-    assert server.listen(0)
-    return server
-
-
-def test_window_starts_disconnected(qapp, tmp_path):
-    window = make_window(tmp_path)
-    assert window.statusBar().currentMessage() == "Not connected"
-    assert "Client started" in window.connection_log.toPlainText()
-    window.close()
-
-
-def test_discovered_servers_are_recorded(qapp, tmp_path):
-    window = make_window(tmp_path)
-    info = ServerInfo(name="box", host="10.0.0.7", port=1234)
-    window._record_discovered([info])
-    peers = window.inventory.peers()
-    assert len(peers) == 1
-    assert peers[0].state == "discovered"
-    window.close()
-
-
-def test_connect_view_and_disconnect_full_flow(qapp, credentials, tmp_path):
-    server = make_share_server(credentials, tmp_path)
-    window = make_window(tmp_path)
-    info = ServerInfo(name="box", host="127.0.0.1", port=server.port)
-    try:
-        window._on_server_activated(info)
-        pump(qapp, lambda: window.viewer.has_frame)
-        assert window._connected
-        assert "Viewing" in window.statusBar().currentMessage()
-        key = f"127.0.0.1:{server.port}"
-        assert window.inventory._peers[key].state == "connected"
-
-        # Input from the viewer is forwarded while connected.
-        window._on_input_event({"action": "move", "x": 0.5, "y": 0.5})
-
-        # A re-scan that finds the connected server must not downgrade it.
-        window._record_discovered([info])
-        assert window.inventory._peers[key].state == "connected"
-
-        server.close()
-        pump(qapp, lambda: not window._connected)
-        assert window.inventory._peers[key].state == "disconnected"
-    finally:
-        window.close()
-        server.close()
-
-
-def test_denied_connection_keeps_denied_state(qapp, credentials, tmp_path):
-    server = make_share_server(credentials, tmp_path, approve=lambda *_: False)
-    window = make_window(tmp_path)
-    try:
-        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
-        pump(qapp, lambda: window._denied)
-        pump(qapp, lambda: "Denied" in window.statusBar().currentMessage())
-        key = f"127.0.0.1:{server.port}"
-        pump(qapp, lambda: window.inventory._peers[key].state == "denied")
-        # The trailing socket disconnect must not overwrite "denied".
-        pump(qapp, lambda: True, timeout=0.3)
-        assert window.inventory._peers[key].state == "denied"
-    finally:
-        window.close()
-        server.close()
-
-
-def test_activating_a_second_server_replaces_the_connection(qapp, credentials, tmp_path):
-    server = make_share_server(credentials, tmp_path)
-    window = make_window(tmp_path)
-    try:
-        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
-        pump(qapp, lambda: window._connected)
-        first_client = window._client
-        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
-        assert window._client is not first_client
-        pump(qapp, lambda: window._connected)
-    finally:
-        window.close()
-        server.close()
-
-
-def test_forget_server_disconnects_and_forgets(qapp, credentials, tmp_path, monkeypatch):
-    server = make_share_server(credentials, tmp_path)
-    window = make_window(tmp_path)
-    key = f"127.0.0.1:{server.port}"
-    try:
-        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
-        pump(qapp, lambda: window._connected)
-        assert window._known_servers.get(key) is not None
-
-        monkeypatch.setattr(
-            QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.Yes)
-        )
-        window._forget_server(key)
-        pump(qapp, lambda: not window._connected)
-        assert window._known_servers.get(key) is None
-        assert window.inventory._peers[key].state == "forgotten"
-
-        # Answering "No" leaves a known server alone.
-        monkeypatch.setattr(
-            QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.No)
-        )
-        window._forget_server(key)
-    finally:
-        window.close()
-        server.close()
-
-
-def test_discovery_panel_lists_scan_results(qapp, monkeypatch):
-    info = ServerInfo(name="box", host="10.0.0.7", port=1234)
-    monkeypatch.setattr(client_module, "discover_servers", lambda: [info])
-    panel = DiscoveryPanel()
-    found: list[list] = []
-    activated: list[ServerInfo] = []
-    panel.serversFound.connect(found.append)
-    panel.serverActivated.connect(activated.append)
-    panel.refresh()
-    assert not panel._refresh_button.isEnabled()
-    pump(qapp, lambda: found)
-    assert found == [[info]]
-    assert panel._refresh_button.isEnabled()
-    assert panel.server_list.count() == 1
-
-    item = panel.server_list.item(0)
-    assert isinstance(item, QListWidgetItem)
-    panel._on_item_activated(item)
-    assert activated == [info]
-    assert item.data(Qt.ItemDataRole.UserRole) == info
-
-
-def test_discovery_panel_survives_scan_failure(qapp, monkeypatch):
-    def boom():
-        raise RuntimeError("scan exploded")
-
-    monkeypatch.setattr(client_module, "discover_servers", boom)
-    panel = DiscoveryPanel()
-    found: list[list] = []
-    panel.serversFound.connect(found.append)
-    panel.refresh()
-    pump(qapp, lambda: found)
-    assert found == [[]]
-    assert panel._refresh_button.isEnabled()
+from PySide6.QtCore import Qt
+from PySide6.QtWidgets import QListWidgetItem, QMessageBox
+
+from remotedesktop import client as client_module
+from remotedesktop import db
+from remotedesktop.client import ClientWindow, DiscoveryPanel
+from remotedesktop.config import PairedClients
+from remotedesktop.discovery import ServerInfo
+from remotedesktop.sharing import ShareServer
+
+from test_sharing import pump
+
+
+def make_window(tmp_path):
+    # auto_scan=False: window tests must never broadcast a discovery probe on the LAN.
+    return ClientWindow(connection=db.connect(tmp_path / "client.db"), auto_scan=False)
+
+
+def make_share_server(credentials, tmp_path, *, approve=lambda *_: True):
+    server = ShareServer(
+        approve_client=approve,
+        credentials=credentials,
+        paired=PairedClients(db.connect(tmp_path / "server.db")),
+    )
+    assert server.listen(0)
+    return server
+
+
+def test_window_starts_disconnected(qapp, tmp_path):
+    window = make_window(tmp_path)
+    assert window.statusBar().currentMessage() == "Not connected"
+    assert "Client started" in window.connection_log.toPlainText()
+    window.close()
+
+
+def test_discovered_servers_are_recorded(qapp, tmp_path):
+    window = make_window(tmp_path)
+    info = ServerInfo(name="box", host="10.0.0.7", port=1234)
+    window._record_discovered([info])
+    peers = window.inventory.peers()
+    assert len(peers) == 1
+    assert peers[0].state == "discovered"
+    window.close()
+
+
+def test_connect_view_and_disconnect_full_flow(qapp, credentials, tmp_path):
+    server = make_share_server(credentials, tmp_path)
+    window = make_window(tmp_path)
+    info = ServerInfo(name="box", host="127.0.0.1", port=server.port)
+    try:
+        window._on_server_activated(info)
+        pump(qapp, lambda: window.viewer.has_frame)
+        assert window._connected
+        assert "Viewing" in window.statusBar().currentMessage()
+        key = f"127.0.0.1:{server.port}"
+        assert window.inventory._peers[key].state == "connected"
+
+        # Input from the viewer is forwarded while connected.
+        window._on_input_event({"action": "move", "x": 0.5, "y": 0.5})
+
+        # A re-scan that finds the connected server must not downgrade it.
+        window._record_discovered([info])
+        assert window.inventory._peers[key].state == "connected"
+
+        server.close()
+        pump(qapp, lambda: not window._connected)
+        assert window.inventory._peers[key].state == "disconnected"
+    finally:
+        window.close()
+        server.close()
+
+
+def test_waiting_for_approval_is_shown_while_server_prompts(qapp, credentials, tmp_path):
+    window = make_window(tmp_path)
+
+    def approve(cid, name):
+        # While the server-side prompt is "open", the client window must show
+        # the waiting state (pump until the pending message arrives).
+        pump(
+            qapp,
+            lambda: "Waiting for the user on box" in window.statusBar().currentMessage(),
+        )
+        return True
+
+    server = make_share_server(credentials, tmp_path, approve=approve)
+    try:
+        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
+        pump(qapp, lambda: window.viewer.has_frame)
+        assert "asking its user for permission" in window.connection_log.toPlainText()
+    finally:
+        window.close()
+        server.close()
+
+
+def test_denied_connection_keeps_denied_state(qapp, credentials, tmp_path):
+    server = make_share_server(credentials, tmp_path, approve=lambda *_: False)
+    window = make_window(tmp_path)
+    try:
+        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
+        pump(qapp, lambda: window._denied)
+        pump(qapp, lambda: "Denied" in window.statusBar().currentMessage())
+        key = f"127.0.0.1:{server.port}"
+        pump(qapp, lambda: window.inventory._peers[key].state == "denied")
+        # The trailing socket disconnect must not overwrite "denied".
+        pump(qapp, lambda: True, timeout=0.3)
+        assert window.inventory._peers[key].state == "denied"
+    finally:
+        window.close()
+        server.close()
+
+
+def test_activating_a_second_server_replaces_the_connection(qapp, credentials, tmp_path):
+    server = make_share_server(credentials, tmp_path)
+    window = make_window(tmp_path)
+    try:
+        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
+        pump(qapp, lambda: window._connected)
+        first_client = window._client
+        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
+        assert window._client is not first_client
+        pump(qapp, lambda: window._connected)
+    finally:
+        window.close()
+        server.close()
+
+
+def test_forget_server_disconnects_and_forgets(qapp, credentials, tmp_path, monkeypatch):
+    server = make_share_server(credentials, tmp_path)
+    window = make_window(tmp_path)
+    key = f"127.0.0.1:{server.port}"
+    try:
+        window._on_server_activated(ServerInfo(name="box", host="127.0.0.1", port=server.port))
+        pump(qapp, lambda: window._connected)
+        assert window._known_servers.get(key) is not None
+
+        monkeypatch.setattr(
+            QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.Yes)
+        )
+        window._forget_server(key)
+        pump(qapp, lambda: not window._connected)
+        assert window._known_servers.get(key) is None
+        assert window.inventory._peers[key].state == "forgotten"
+
+        # Answering "No" leaves a known server alone.
+        monkeypatch.setattr(
+            QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.No)
+        )
+        window._forget_server(key)
+    finally:
+        window.close()
+        server.close()
+
+
+def test_discovery_panel_lists_scan_results(qapp, monkeypatch):
+    info = ServerInfo(name="box", host="10.0.0.7", port=1234)
+    monkeypatch.setattr(client_module, "discover_servers", lambda: [info])
+    panel = DiscoveryPanel()
+    found: list[list] = []
+    activated: list[ServerInfo] = []
+    panel.serversFound.connect(found.append)
+    panel.serverActivated.connect(activated.append)
+    panel.refresh()
+    assert not panel._refresh_button.isEnabled()
+    pump(qapp, lambda: found)
+    assert found == [[info]]
+    assert panel._refresh_button.isEnabled()
+    assert panel.server_list.count() == 1
+
+    item = panel.server_list.item(0)
+    assert isinstance(item, QListWidgetItem)
+    panel._on_item_activated(item)
+    assert activated == [info]
+    assert item.data(Qt.ItemDataRole.UserRole) == info
+
+
+def test_discovery_panel_survives_scan_failure(qapp, monkeypatch):
+    def boom():
+        raise RuntimeError("scan exploded")
+
+    monkeypatch.setattr(client_module, "discover_servers", boom)
+    panel = DiscoveryPanel()
+    found: list[list] = []
+    panel.serversFound.connect(found.append)
+    panel.refresh()
+    pump(qapp, lambda: found)
+    assert found == [[]]
+    assert panel._refresh_button.isEnabled()

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

@@ -85,10 +85,19 @@ def test_autostart_checkbox_toggles_registration(qapp, credentials, tmp_path):
         window.close()
 
 
+def stub_approval_prompt(monkeypatch, button):
+    """Answer _ask_approval's stay-on-top QMessageBox without showing any UI.
+
+    The approval prompt is an instance QMessageBox (show + exec), not
+    QMessageBox.question, so both methods are stubbed: show so nothing pops
+    up on screen, exec so the "user" answers immediately.
+    """
+    monkeypatch.setattr(QMessageBox, "show", lambda self: None)
+    monkeypatch.setattr(QMessageBox, "exec", lambda self: button)
+
+
 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)
-    )
+    stub_approval_prompt(monkeypatch, QMessageBox.StandardButton.Yes)
     window = make_window(credentials, tmp_path)
     client = make_client(tmp_path)
     names = []
@@ -105,9 +114,7 @@ def test_approval_prompt_pairs_client_and_updates_summary(qapp, credentials, tmp
 
 
 def test_refused_approval_denies_client(qapp, credentials, tmp_path, monkeypatch):
-    monkeypatch.setattr(
-        QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.No)
-    )
+    stub_approval_prompt(monkeypatch, QMessageBox.StandardButton.No)
     window = make_window(credentials, tmp_path)
     client = make_client(tmp_path)
     denials = []
@@ -122,6 +129,8 @@ def test_refused_approval_denies_client(qapp, credentials, tmp_path, monkeypatch
 
 
 def test_revoke_via_window_disconnects_client(qapp, credentials, tmp_path, monkeypatch):
+    stub_approval_prompt(monkeypatch, QMessageBox.StandardButton.Yes)
+    # The revoke confirmation is still QMessageBox.question — patch it separately.
     monkeypatch.setattr(
         QMessageBox, "question", staticmethod(lambda *a, **k: QMessageBox.StandardButton.Yes)
     )

{remotedesktop-0.3.0 → remotedesktop-0.5.0}/tests/test_sharing.py

@@ -99,6 +99,35 @@ def test_reconnect_uses_token_without_prompting(qapp, credentials, tmp_path):
         server.close()
 
 
+def test_approval_pending_is_signaled_only_when_prompting(qapp, credentials, tmp_path):
+    server = make_server(credentials, tmp_path, approve=lambda *_: True)
+    try:
+        # First connection: the server prompts, so the client hears "pending"
+        # before it is admitted.
+        client = make_client(tmp_path)
+        events: list[str] = []
+        client.approvalPending.connect(lambda: events.append("pending"))
+        client.connected.connect(lambda _name: events.append("connected"))
+        client.connect_to("127.0.0.1", server.port)
+        pump(qapp, lambda: "connected" in events)
+        assert events == ["pending", "connected"]
+        client.close()
+        pump(qapp, lambda: True, timeout=0.3)
+
+        # Token reconnect: no prompt on the server, so no pending signal.
+        client2 = make_client(tmp_path)
+        events2: list[str] = []
+        client2.approvalPending.connect(lambda: events2.append("pending"))
+        client2.connected.connect(lambda _name: events2.append("connected"))
+        client2.connect_to("127.0.0.1", server.port)
+        pump(qapp, lambda: "connected" in events2)
+        assert events2 == ["connected"]
+    finally:
+        client2.close()
+        client.close()
+        server.close()
+
+
 def test_revoke_disconnects_and_requires_reapproval(qapp, credentials, tmp_path):
     prompts = []
     server = make_server(

{remotedesktop-0.3.0 → remotedesktop-0.5.0}/tests/test_smoke.py

@@ -1,58 +1,58 @@
-import socket
-
-import remotedesktop
-from remotedesktop import db
-from remotedesktop.client import ClientWindow, DiscoveryPanel
-from remotedesktop.config import PairedClients
-from remotedesktop.discovery import ServerInfo, discover_servers
-from remotedesktop.server import ServerWindow
-from remotedesktop.viewer import ViewerWidget
-
-from test_discovery import LOOPBACK, free_udp_port
-
-
-def test_version() -> None:
-    assert remotedesktop.__version__
-
-
-def test_client_window_hosts_viewer(qapp) -> None:
-    window = ClientWindow()
-    assert isinstance(window.viewer, ViewerWidget)
-    assert isinstance(window.discovery_panel, DiscoveryPanel)
-
-
-def test_discovery_panel_lists_servers(qapp) -> None:
-    panel = DiscoveryPanel()
-    server = ServerInfo(name="testbox", host="192.168.1.7", port=12345)
-    panel._show_results([server])
-    assert panel.server_list.count() == 1
-    assert "testbox" in panel.server_list.item(0).text()
-
-
-def test_server_window_is_discoverable(qapp, credentials, tmp_path) -> None:
-    port = free_udp_port()
-    window = ServerWindow(
-        discovery_port=port,
-        connect_port=0,
-        paired=PairedClients(db.connect(tmp_path / "server.db")),
-        credentials=credentials,
-    )
-    try:
-        servers = discover_servers(
-            timeout=2.0, discovery_port=port, broadcast_hosts=(LOOPBACK,)
-        )
-        assert [s.name for s in servers] == [socket.gethostname()]
-        assert servers[0].port == window.share_server.port
-    finally:
-        window.close()
-
-
-def test_viewer_widget_shows_and_clears_frames(qapp) -> None:
-    from PySide6.QtGui import QImage
-
-    viewer = ViewerWidget()
-    assert not viewer.has_frame
-    viewer.show_frame(QImage(8, 8, QImage.Format.Format_RGB32))
-    assert viewer.has_frame
-    viewer.clear("gone")
-    assert not viewer.has_frame
+import socket
+
+import remotedesktop
+from remotedesktop import db
+from remotedesktop.client import ClientWindow, DiscoveryPanel
+from remotedesktop.config import PairedClients
+from remotedesktop.discovery import ServerInfo, discover_servers
+from remotedesktop.server import ServerWindow
+from remotedesktop.viewer import ViewerWidget
+
+from test_discovery import LOOPBACK, free_udp_port
+
+
+def test_version() -> None:
+    assert remotedesktop.__version__
+
+
+def test_client_window_hosts_viewer(qapp) -> None:
+    window = ClientWindow(auto_scan=False)
+    assert isinstance(window.viewer, ViewerWidget)
+    assert isinstance(window.discovery_panel, DiscoveryPanel)
+
+
+def test_discovery_panel_lists_servers(qapp) -> None:
+    panel = DiscoveryPanel()
+    server = ServerInfo(name="testbox", host="192.168.1.7", port=12345)
+    panel._show_results([server])
+    assert panel.server_list.count() == 1
+    assert "testbox" in panel.server_list.item(0).text()
+
+
+def test_server_window_is_discoverable(qapp, credentials, tmp_path) -> None:
+    port = free_udp_port()
+    window = ServerWindow(
+        discovery_port=port,
+        connect_port=0,
+        paired=PairedClients(db.connect(tmp_path / "server.db")),
+        credentials=credentials,
+    )
+    try:
+        servers = discover_servers(
+            timeout=2.0, discovery_port=port, broadcast_hosts=(LOOPBACK,)
+        )
+        assert [s.name for s in servers] == [socket.gethostname()]
+        assert servers[0].port == window.share_server.port
+    finally:
+        window.close()
+
+
+def test_viewer_widget_shows_and_clears_frames(qapp) -> None:
+    from PySide6.QtGui import QImage
+
+    viewer = ViewerWidget()
+    assert not viewer.has_frame
+    viewer.show_frame(QImage(8, 8, QImage.Format.Format_RGB32))
+    assert viewer.has_frame
+    viewer.clear("gone")
+    assert not viewer.has_frame