remotedesktop 0.0.1__py3-none-any.whl → 0.2.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.0.1"
+"""Remote desktop client/server for Windows computers on the same LAN."""
+
+__version__ = "0.2.0"

remotedesktop/client.py

@@ -1,27 +1,245 @@
-"""Client GUI application: discovers servers on the LAN, connects to one,
-and shows its desktop in a viewer widget."""
-
-import sys
-
-from PySide6.QtWidgets import QApplication, QMainWindow
-
-from remotedesktop.viewer import ViewerWidget
-
-
-class ClientWindow(QMainWindow):
-    def __init__(self) -> None:
-        super().__init__()
-        self.setWindowTitle("Remote Desktop Client")
-        self.viewer = ViewerWidget(self)
-        self.setCentralWidget(self.viewer)
-
-
-def main() -> None:
-    app = QApplication(sys.argv)
-    window = ClientWindow()
-    window.show()
-    raise SystemExit(app.exec())
-
-
-if __name__ == "__main__":
-    main()
+"""Client GUI application: discovers servers on the LAN, connects to one,
+and shows its desktop in a viewer widget."""
+
+import sqlite3
+import sys
+import threading
+import time
+
+from PySide6.QtCore import Qt, Signal
+from PySide6.QtGui import QCloseEvent
+from PySide6.QtWidgets import (
+    QApplication,
+    QDockWidget,
+    QListWidget,
+    QListWidgetItem,
+    QMainWindow,
+    QMessageBox,
+    QPlainTextEdit,
+    QPushButton,
+    QTabWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+from remotedesktop import db, window_state
+from remotedesktop.clipboard import ClipboardSync
+from remotedesktop.config import KnownServers, Settings, default_db_path, load_client_identity
+from remotedesktop.discovery import DISCOVERY_PORT, ServerInfo, discover_servers
+from remotedesktop.inventory import ConnectionInventory, InventoryTab
+from remotedesktop.sharing import ShareClient
+from remotedesktop.viewer import ViewerWidget
+
+
+class DiscoveryPanel(QWidget):
+    """Scans the LAN for servers and lists them for the user to pick."""
+
+    serverActivated = Signal(ServerInfo)
+    serversFound = Signal(list)
+    status = Signal(str)
+    _scanFinished = Signal(list)
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+        self._refresh_button = QPushButton("Refresh")
+        self.server_list = QListWidget()
+        layout = QVBoxLayout(self)
+        layout.addWidget(self._refresh_button)
+        layout.addWidget(self.server_list)
+        self._refresh_button.clicked.connect(self.refresh)
+        self.server_list.itemActivated.connect(self._on_item_activated)
+        self._scanFinished.connect(self._show_results)
+
+    def refresh(self) -> None:
+        self._refresh_button.setEnabled(False)
+        self._refresh_button.setText("Scanning…")
+        self.status.emit(f"Scanning LAN (UDP broadcast to port {DISCOVERY_PORT}) …")
+        threading.Thread(target=self._scan, name="discovery-scan", daemon=True).start()
+
+    def _scan(self) -> None:
+        # Runs on a worker thread; the signal is delivered queued on the GUI
+        # thread. Any failure must still emit, or the button stays disabled.
+        servers: list[ServerInfo] = []
+        try:
+            servers = discover_servers()
+        except Exception:
+            pass
+        self._scanFinished.emit(servers)
+
+    def _show_results(self, servers: list) -> None:
+        self._refresh_button.setEnabled(True)
+        self._refresh_button.setText("Refresh")
+        self.server_list.clear()
+        for server in servers:
+            item = QListWidgetItem(f"{server.name} ({server.host}:{server.port})")
+            item.setData(Qt.ItemDataRole.UserRole, server)
+            self.server_list.addItem(item)
+        self.serversFound.emit(servers)
+        found = ", ".join(f"{s.name} at {s.host}:{s.port}" for s in servers)
+        self.status.emit(f"Scan finished — found: {found}" if servers else "Scan finished — no servers found")
+
+    def _on_item_activated(self, item: QListWidgetItem) -> None:
+        self.serverActivated.emit(item.data(Qt.ItemDataRole.UserRole))
+
+
+class ClientWindow(QMainWindow):
+    def __init__(self, *, connection: sqlite3.Connection | None = None) -> None:
+        super().__init__()
+        self.setWindowTitle("Remote Desktop Client")
+        # 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.viewer = ViewerWidget(self)
+        self.inventory = ConnectionInventory(self._db, "client_peers", self)
+        tabs = QTabWidget()
+        tabs.addTab(self.viewer, "Remote Screen")
+        tabs.addTab(
+            InventoryTab(self.inventory, "Forget server", self._forget_server),
+            "Servers on LAN",
+        )
+        self.setCentralWidget(tabs)
+
+        self.discovery_panel = DiscoveryPanel(self)
+        servers_dock = QDockWidget("Servers", self)
+        servers_dock.setWidget(self.discovery_panel)
+        self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, servers_dock)
+
+        self.connection_log = QPlainTextEdit(self)
+        self.connection_log.setReadOnly(True)
+        self.connection_log.setMaximumBlockCount(1000)
+        log_dock = QDockWidget("Connection log", self)
+        log_dock.setWidget(self.connection_log)
+        self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, log_dock)
+
+        self.discovery_panel.serverActivated.connect(self._on_server_activated)
+        self.discovery_panel.serversFound.connect(self._record_discovered)
+        self.discovery_panel.status.connect(self.log)
+        self.viewer.inputEvent.connect(self._on_input_event)
+
+        self._clipboard = ClipboardSync(parent=self)
+        self._known_servers = KnownServers(self._db)
+        self._identity = load_client_identity(self._db)
+        self._client: ShareClient | None = None
+        self._connected = False
+        self._denied = False
+        self._server_name = ""
+        self._server_key = ""
+        self._frame_count = 0
+        self.statusBar().showMessage("Not connected")
+        self._settings = Settings(self._db)
+        window_state.restore_geometry(self, self._settings, window_state.CLIENT_GEOMETRY_KEY)
+        self.log("Client started")
+
+    def log(self, message: str) -> None:
+        self.connection_log.appendPlainText(f"{time.strftime('%H:%M:%S')}  {message}")
+
+    def _forget_server(self, key: str) -> None:
+        answer = QMessageBox.question(
+            self,
+            "Forget server",
+            f"Forget server {key}?\n\n"
+            "If connected it will be disconnected, and the next connection will "
+            "need the server user to approve this computer again.",
+        )
+        if answer != QMessageBox.StandardButton.Yes:
+            return
+        if self._connected and self._server_key == key and self._client is not None:
+            self._client.close()
+        self._known_servers.forget(key)
+        self.inventory.record(key, "forgotten")
+        self.log(f"Forgot server {key}")
+
+    def _record_discovered(self, servers: list) -> None:
+        for server in servers:
+            key = f"{server.host}:{server.port}"
+            if self._connected and key == self._server_key:
+                continue  # don't downgrade the connected server to "discovered"
+            self.inventory.record(
+                key, "discovered", name=server.name, address=key, detail=key
+            )
+
+    def _on_server_activated(self, server: ServerInfo) -> None:
+        if self._client is not None:
+            self.log("Closing previous connection")
+            self._client.close()
+            self._client.deleteLater()
+        self._server_name = server.name
+        self._server_key = f"{server.host}:{server.port}"
+        self._frame_count = 0
+        self._connected = False
+        self._denied = False
+        self.inventory.record(
+            self._server_key, "attempt", name=server.name,
+            address=self._server_key, detail=self._server_key,
+        )
+        client = ShareClient(
+            identity=self._identity,
+            known_servers=self._known_servers,
+            clipboard=self._clipboard,
+            parent=self,
+        )
+        self._client = client
+        client.status.connect(self.log)
+        client.connected.connect(self._on_connected)
+        client.denied.connect(self._on_denied)
+        client.disconnected.connect(self._on_disconnected)
+        client.frameReceived.connect(self._on_frame)
+        self.viewer.clear(f"Connecting to {server.name} …")
+        self.statusBar().showMessage(f"Connecting to {server.name} ({server.host}:{server.port}) …")
+        client.connect_to(server.host, server.port)
+
+    def _on_connected(self, server_name: str) -> None:
+        self._server_name = server_name or self._server_name
+        self._connected = True
+        self.inventory.record(self._server_key, "connected", name=self._server_name)
+        self.viewer.setFocus()
+        self.statusBar().showMessage(
+            f"Connected to {self._server_name} — waiting for first frame "
+            "(click the view to control it)"
+        )
+
+    def _on_input_event(self, event: dict) -> None:
+        if self._connected and self._client is not None:
+            self._client.send_input(event)
+
+    def _on_denied(self, reason: str) -> None:
+        self._connected = False
+        self._denied = True
+        self.inventory.record(self._server_key, "denied", name=self._server_name)
+        self.viewer.clear(f"Connection denied: {reason}")
+        self.statusBar().showMessage(f"Denied by {self._server_name}: {reason}")
+
+    def _on_disconnected(self) -> None:
+        self._connected = False
+        # After a denial, keep "denied" as the peer's state in the inventory
+        # rather than overwriting it with the trailing "disconnected".
+        if self._server_key and not self._denied:
+            self.inventory.record(self._server_key, "disconnected", name=self._server_name)
+        if not self._denied:
+            self.viewer.clear("Disconnected")
+            self.statusBar().showMessage(f"Disconnected from {self._server_name}")
+
+    def _on_frame(self, image) -> None:
+        self._frame_count += 1
+        self.viewer.show_frame(image)
+        self.statusBar().showMessage(
+            f"Viewing {self._server_name} — {image.width()}x{image.height()} — "
+            f"{self._frame_count} frames received"
+        )
+
+    def closeEvent(self, event: QCloseEvent) -> None:
+        window_state.save_geometry(self, self._settings, window_state.CLIENT_GEOMETRY_KEY)
+        if self._client is not None:
+            self._client.close()
+        super().closeEvent(event)
+
+
+def main() -> None:  # pragma: no cover - runs the Qt event loop
+    app = QApplication(sys.argv)
+    window = ClientWindow()
+    window.show()
+    window.discovery_panel.refresh()
+    raise SystemExit(app.exec())
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

remotedesktop/clipboard.py

@@ -0,0 +1,93 @@
+"""Clipboard synchronization.
+
+Wraps the local QClipboard: emits `changed` with a serializable payload when
+the user copies something locally, and `apply()` writes a payload received
+from the peer into the local clipboard.
+
+Echo prevention is by content signature, not just a guard flag: applying a
+payload records its signature, and any clipboard-changed notification whose
+content matches the last signature is ignored. The signature hashes the
+canonical pixels of images (not their PNG encoding), so a value that makes a
+round trip through the OS clipboard and back does not loop. This matters
+because on Windows `dataChanged` fires asynchronously, after a simple guard
+flag would already have been cleared.
+"""
+
+import base64
+import hashlib
+
+from PySide6.QtCore import QBuffer, QMimeData, QObject, Signal
+from PySide6.QtGui import QClipboard, QGuiApplication, QImage
+
+
+def _image_hash(image: QImage | None) -> str | None:
+    if image is None or image.isNull():
+        return None
+    canonical = image.convertToFormat(QImage.Format.Format_RGBA8888)
+    return hashlib.sha1(bytes(canonical.constBits())).hexdigest()
+
+
+class ClipboardSync(QObject):
+    """Bridges the local clipboard to the network. See module docstring."""
+
+    changed = Signal(dict)
+
+    def __init__(
+        self, clipboard: QClipboard | None = None, parent: QObject | None = None
+    ) -> None:
+        super().__init__(parent)
+        self._clipboard = clipboard or QGuiApplication.clipboard()
+        self._applying = False
+        self._last_signature: tuple[str | None, str | None] | None = None
+        self._clipboard.dataChanged.connect(self._on_data_changed)
+
+    def _on_data_changed(self) -> None:
+        if self._applying:
+            return
+        text = self._clipboard.text() or None
+        image = self._clipboard.image()
+        image_hash = _image_hash(image)
+        signature = (text, image_hash)
+        if signature == self._last_signature or (text is None and image_hash is None):
+            return
+        self._last_signature = signature
+        payload: dict = {}
+        if text is not None:
+            payload["text"] = text
+        if image_hash is not None:
+            buffer = QBuffer()
+            buffer.open(QBuffer.OpenModeFlag.WriteOnly)
+            image.save(buffer, "PNG")  # ty: ignore[no-matching-overload]
+            payload["image_png"] = base64.b64encode(
+                bytes(buffer.data())  # ty: ignore[invalid-argument-type]
+            ).decode()
+        self.changed.emit(payload)
+
+    def apply(self, payload: dict) -> None:
+        text = payload.get("text")
+        text = text if isinstance(text, str) else None
+        image = None
+        encoded = payload.get("image_png")
+        if isinstance(encoded, str):
+            try:
+                image = QImage.fromData(base64.b64decode(encoded), "PNG")  # ty: ignore[invalid-argument-type]
+            except (ValueError, TypeError):
+                image = None
+        if image is not None and image.isNull():
+            image = None
+        signature = (text, _image_hash(image))
+        if signature == self._last_signature or signature == (None, None):
+            return
+        self._last_signature = signature
+        # One QMimeData carrying both representations, so a payload with text
+        # and an image keeps both halves on the receiving clipboard.
+        mime = QMimeData()
+        if text is not None:
+            mime.setText(text)
+        if image is not None:
+            mime.setImageData(image)
+        self._applying = True
+        try:
+            self._clipboard.setMimeData(mime)
+        finally:
+            self._applying = False

remotedesktop/config.py

@@ -0,0 +1,122 @@
+"""Persistent per-machine state, all stored in the shared SQLite database.
+
+`Settings` is a generic key/value store (and holds this client's stable id and
+name). `PairedClients` maps each approved client id to the token issued at
+approval (server side). `KnownServers` records the servers this machine has
+paired with — pinned fingerprint and token — keyed by "host:port" (client
+side). All three operate on a `sqlite3.Connection` from `db.connect`.
+"""
+
+import socket
+import sqlite3
+import uuid
+from pathlib import Path
+
+import platformdirs
+
+
+def default_config_dir() -> Path:
+    return Path(platformdirs.user_data_dir("remotedesktop", appauthor=False))
+
+
+def default_db_path() -> Path:
+    return default_config_dir() / "remotedesktop.db"
+
+
+class Settings:
+    """A key/value store over the `settings` table."""
+
+    def __init__(self, connection: sqlite3.Connection) -> None:
+        self._db = connection
+
+    def get(self, key: str, default: str | None = None) -> str | None:
+        row = self._db.execute(
+            "SELECT value FROM settings WHERE key = ?", (key,)
+        ).fetchone()
+        return row[0] if row is not None else default
+
+    def set(self, key: str, value: str) -> None:
+        self._db.execute(
+            "INSERT INTO settings (key, value) VALUES (?, ?) "
+            "ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+            (key, value),
+        )
+        self._db.commit()
+
+
+def load_client_identity(connection: sqlite3.Connection) -> tuple[str, str]:
+    """Return this client's (stable id, display name), creating it on first use."""
+    settings = Settings(connection)
+    client_id = settings.get("client_id")
+    name = settings.get("client_name")
+    if client_id and name:
+        return client_id, name
+    client_id = str(uuid.uuid4())
+    name = socket.gethostname()
+    settings.set("client_id", client_id)
+    settings.set("client_name", name)
+    return client_id, name
+
+
+class PairedClients:
+    """Maps each approved client id to its shared token (server side).
+
+    A client is "approved" exactly when it has a token here.
+    """
+
+    def __init__(self, connection: sqlite3.Connection) -> None:
+        self._db = connection
+
+    def __contains__(self, client_id: str) -> bool:
+        return self.token_for(client_id) is not None
+
+    def token_for(self, client_id: str) -> str | None:
+        row = self._db.execute(
+            "SELECT token FROM paired_clients WHERE client_id = ?", (client_id,)
+        ).fetchone()
+        return row[0] if row is not None else None
+
+    def pair(self, client_id: str) -> str:
+        """Issue and persist a new token for a client, returning it."""
+        import secrets
+
+        token = secrets.token_hex(32)
+        self._db.execute(
+            "INSERT INTO paired_clients (client_id, token) VALUES (?, ?) "
+            "ON CONFLICT(client_id) DO UPDATE SET token = excluded.token",
+            (client_id, token),
+        )
+        self._db.commit()
+        return token
+
+    def revoke(self, client_id: str) -> None:
+        """Remove a client's token so it must be approved again to reconnect."""
+        self._db.execute("DELETE FROM paired_clients WHERE client_id = ?", (client_id,))
+        self._db.commit()
+
+
+class KnownServers:
+    """Client-side record of paired servers, keyed by "host:port"."""
+
+    def __init__(self, connection: sqlite3.Connection) -> None:
+        self._db = connection
+
+    def get(self, key: str) -> dict | None:
+        row = self._db.execute(
+            "SELECT fingerprint, token FROM known_servers WHERE key = ?", (key,)
+        ).fetchone()
+        return {"fingerprint": row[0], "token": row[1]} if row is not None else None
+
+    def remember(self, key: str, fingerprint: str, token: str) -> None:
+        self._db.execute(
+            "INSERT INTO known_servers (key, fingerprint, token) VALUES (?, ?, ?) "
+            "ON CONFLICT(key) DO UPDATE SET fingerprint = excluded.fingerprint, "
+            "token = excluded.token",
+            (key, fingerprint, token),
+        )
+        self._db.commit()
+
+    def forget(self, key: str) -> None:
+        """Drop a server's stored token and pin, so the next connection re-pairs."""
+        self._db.execute("DELETE FROM known_servers WHERE key = ?", (key,))
+        self._db.commit()

remotedesktop/db.py

@@ -0,0 +1,49 @@
+"""The single SQLite database that backs all persistence.
+
+One database file under %LOCALAPPDATA%/remotedesktop holds every persistent table:
+settings (a key/value store, including this client's identity), the server's
+paired clients, the client's known servers, and the connection inventory. Pass
+`None` for an in-memory database (used by tests).
+"""
+
+import sqlite3
+from pathlib import Path
+
+_PEER_COLUMNS = (
+    "key TEXT PRIMARY KEY, name TEXT, address TEXT, detail TEXT, "
+    "first_seen TEXT, last_seen TEXT, attempts INTEGER, state TEXT, last_event TEXT"
+)
+
+# The server's inventory of clients and the client's inventory of servers are
+# kept in separate tables so a machine running both apps doesn't commingle them.
+# `peers` is the generic table used by tests.
+PEER_TABLES = ("peers", "server_peers", "client_peers")
+
+_SCHEMA = f"""
+CREATE TABLE IF NOT EXISTS settings (
+    key TEXT PRIMARY KEY,
+    value TEXT
+);
+CREATE TABLE IF NOT EXISTS paired_clients (
+    client_id TEXT PRIMARY KEY,
+    token TEXT
+);
+CREATE TABLE IF NOT EXISTS known_servers (
+    key TEXT PRIMARY KEY,
+    fingerprint TEXT,
+    token TEXT
+);
+CREATE TABLE IF NOT EXISTS peers ({_PEER_COLUMNS});
+CREATE TABLE IF NOT EXISTS server_peers ({_PEER_COLUMNS});
+CREATE TABLE IF NOT EXISTS client_peers ({_PEER_COLUMNS});
+"""
+
+
+def connect(path: Path | None) -> sqlite3.Connection:
+    """Open (creating if needed) the database and ensure every table exists."""
+    if path is not None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+    connection = sqlite3.connect(str(path) if path is not None else ":memory:")
+    connection.executescript(_SCHEMA)
+    connection.commit()
+    return connection

remotedesktop/discovery.py

@@ -0,0 +1,146 @@
+"""LAN autodiscovery.
+
+Clients broadcast a JSON probe datagram to the discovery port; every server
+on the LAN replies with its display name and TCP connection port. Datagrams
+whose magic, protocol version, or type don't match are ignored.
+"""
+
+import json
+import socket
+import threading
+import time
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+DISCOVERY_PORT = 48653
+DEFAULT_CONNECT_PORT = 48654
+
+_MAGIC = "remotedesktop"
+_PROTOCOL_VERSION = 1
+_MAX_DATAGRAM = 4096
+
+
+@dataclass(frozen=True)
+class ServerInfo:
+    name: str
+    host: str
+    port: int
+
+
+def _parse(data: bytes, expected_type: str) -> dict | None:
+    try:
+        message = json.loads(data.decode())
+    except (UnicodeDecodeError, json.JSONDecodeError):
+        return None
+    if not isinstance(message, dict):
+        return None
+    if message.get("magic") != _MAGIC or message.get("version") != _PROTOCOL_VERSION:
+        return None
+    if message.get("type") != expected_type:
+        return None
+    return message
+
+
+def _encode(message_type: str, **fields: object) -> bytes:
+    return json.dumps(
+        {"magic": _MAGIC, "version": _PROTOCOL_VERSION, "type": message_type, **fields}
+    ).encode()
+
+
+class DiscoveryResponder:
+    """Runs on the server; answers discovery probes with this server's info."""
+
+    def __init__(
+        self,
+        name: str,
+        connect_port: int,
+        *,
+        discovery_port: int = DISCOVERY_PORT,
+        bind_host: str = "",
+    ) -> None:
+        self._reply = _encode("reply", name=name, port=connect_port)
+        self._discovery_port = discovery_port
+        self._bind_host = bind_host
+        self._socket: socket.socket | None = None
+        self._thread: threading.Thread | None = None
+        self._running = threading.Event()
+
+    def start(self) -> None:
+        if self._thread is not None:
+            raise RuntimeError("responder already started")
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        try:
+            sock.bind((self._bind_host, self._discovery_port))
+        except OSError:
+            sock.close()
+            raise
+        sock.settimeout(0.25)
+        self._socket = sock
+        self._running.set()
+        self._thread = threading.Thread(
+            target=self._serve, name="discovery-responder", daemon=True
+        )
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._running.clear()
+        if self._thread is not None:
+            self._thread.join()
+            self._thread = None
+        if self._socket is not None:
+            self._socket.close()
+            self._socket = None
+
+    def _serve(self) -> None:
+        assert self._socket is not None
+        while self._running.is_set():
+            try:
+                data, sender = self._socket.recvfrom(_MAX_DATAGRAM)
+            except TimeoutError:
+                continue
+            except OSError:
+                return
+            if _parse(data, "probe") is None:
+                continue
+            try:
+                self._socket.sendto(self._reply, sender)
+            except OSError:
+                pass
+
+
+def discover_servers(
+    timeout: float = 1.0,
+    *,
+    discovery_port: int = DISCOVERY_PORT,
+    broadcast_hosts: Sequence[str] = ("255.255.255.255",),
+) -> list[ServerInfo]:
+    """Broadcast a probe and collect server replies until the timeout expires.
+
+    Results are deduplicated by (host, port); order is arrival order.
+    """
+    found: dict[tuple[str, int], ServerInfo] = {}
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        sock.bind(("", 0))
+        probe = _encode("probe")
+        for host in broadcast_hosts:
+            try:
+                sock.sendto(probe, (host, discovery_port))
+            except OSError:
+                pass
+        deadline = time.monotonic() + timeout
+        while (remaining := deadline - time.monotonic()) > 0:
+            sock.settimeout(remaining)
+            try:
+                data, (host, _sender_port) = sock.recvfrom(_MAX_DATAGRAM)
+            except (TimeoutError, OSError):
+                break
+            message = _parse(data, "reply")
+            if message is None:
+                continue
+            name = message.get("name")
+            port = message.get("port")
+            if not isinstance(name, str) or not isinstance(port, int):
+                continue
+            found.setdefault((host, port), ServerInfo(name=name, host=host, port=port))
+    return list(found.values())