adbsshdeck 0.1.1__py3-none-any.whl

adbsshdeck-0.1.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeviceDeck contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

adbsshdeck-0.1.1.dist-info/METADATA

@@ -0,0 +1,136 @@
+Metadata-Version: 2.2
+Name: adbsshdeck
+Version: 0.1.1
+Summary: Desktop workspace for Android: ADB and SSH terminals, serial, file access, and USB screen control (DeviceDeck).
+Author: DeviceDeck contributors
+License: MIT
+Project-URL: Homepage, https://nvnkennedy.github.io/Device_Deck/
+Project-URL: Repository, https://github.com/nvnkennedy/Device_Deck
+Project-URL: Documentation, https://github.com/nvnkennedy/Device_Deck#readme
+Project-URL: PyPI, https://pypi.org/project/adbsshdeck/
+Keywords: android,adb,ssh,serial,scrcpy,pyqt5,sftp,desktop,screen-mirroring
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: X11 Applications :: Qt
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyQt5<6.0,>=5.15.11
+Requires-Dist: pyserial<4.0,>=3.5
+Requires-Dist: paramiko<5.0,>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: build
+Requires-Dist: pyinstaller<7.0,>=6.0; extra == "build"
+
+# DeviceDeck (PyQt5)
+
+Desktop workspace for Android debugging: ADB file transfer, multi-session **SSH**, **serial**, USB **screen** forwarding, and on-device files — in one app.
+
+| | |
+|--|--|
+| **PyPI package** | **`adbsshdeck`** (ADB + SSH + workspace “deck”, including screen control) |
+| **Run after install** | **`adbsshdeck`** (also in `Scripts` on Windows) |
+| **Python import** | `devicedeck` (unchanged) |
+| **Website** | [nvnkennedy.github.io/Device_Deck](https://nvnkennedy.github.io/Device_Deck/) |
+| **PyPI** | [pypi.org/project/adbsshdeck](https://pypi.org/project/adbsshdeck/) |
+
+The name **`devicedeck`** on PyPI was already taken; **`adbsshdeck`** is this project’s distribution name.
+
+## Prerequisites
+
+- Python 3.9+
+- **ADB** and a **USB display-forwarding** tool on `PATH`, or paths in **File → Preferences**
+- **`ssh` on PATH** if you use SSH terminal sessions
+- **Serial/COM** hardware if you use serial tabs (pyserial is a dependency)
+
+## Install (recommended)
+
+From [PyPI](https://pypi.org/project/adbsshdeck/):
+
+```bash
+python -m pip install --upgrade pip
+python -m pip install adbsshdeck
+```
+
+Then:
+
+```bash
+adbsshdeck
+```
+
+Same as: `python -m devicedeck` (import package is still `devicedeck`).
+
+This repository is **source-only** on GitHub — users install the **published package** with pip.
+
+## Install from a git clone (development)
+
+```bash
+git clone https://github.com/nvnkennedy/Device_Deck.git
+cd Device_Deck
+pip install -e ".[dev]"
+```
+
+Or:
+
+```bash
+pip install "git+https://github.com/nvnkennedy/Device_Deck.git"
+```
+
+`main.py` is a thin launcher for local development only.
+
+## Publishing to PyPI
+
+See **[docs/PYPI_PUBLISH.md](docs/PYPI_PUBLISH.md)** (build wheel/sdist, API token, optional GitHub Actions).
+
+## Website (GitHub Pages)
+
+Static site under `site/` — **Install** instructions for end users. Deployed by `.github/workflows/pages.yml` when you push changes under `site/`.
+
+## Windows standalone executable (optional, maintainers only)
+
+For machines **without** Python, you can build a **PyInstaller** folder or installer **locally** — outputs are **not** committed to this repo.
+
+```powershell
+pip install -e ".[build]"
+powershell -ExecutionPolicy Bypass -File scripts\build_windows_exe.ps1
+```
+
+See `DeviceDeck.spec`. ADB and display-forwarding tools are **not** bundled.
+
+## Project layout
+
+- `pyproject.toml` — metadata; console entry **`adbsshdeck`**
+- `devicedeck/` — application code (import name)
+- `site/` — GitHub Pages (home + install + PyPI links)
+- `scripts/` — `build_windows_exe.ps1`, `export_app_icon.py`
+- `tests/` — pytest
+- `DeviceDeck.spec` — PyInstaller (optional)
+
+## Build wheel / sdist
+
+```bash
+pip install build
+python -m build
+```
+
+Artifacts: `dist/adbsshdeck-*.whl` and `dist/*.tar.gz`.
+
+## Testing
+
+```bash
+python -m pytest tests/ -q
+```
+
+## Notes
+
+- Settings: `~/.devicedeck.json`
+- License: MIT — see [LICENSE](LICENSE)

adbsshdeck-0.1.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+devicedeck/__init__.py,sha256=Cwb3P1gD2rAtHfcyjWR97oCHXtl_cVp11bnhhheUJH4,137
+devicedeck/__main__.py,sha256=jJMizmtrs4RRW6hHriblxX87GGrCZ8u5bXYnY8lVvAg,65
+devicedeck/app.py,sha256=gipuf5TRNqjQ1eKJW4klLfQP1g-47AFcE5-r-BjuyUU,1399
+devicedeck/config.py,sha256=GnxwCyLSvmsNAfxkQK9aSoCC0kPH7c4NXP-MZTgusjw,5404
+devicedeck/session.py,sha256=WduDszs3lGzsk8yVBhdj5Mwz52dIz2whWLKFCXE2Rx4,1426
+devicedeck/services/__init__.py,sha256=-pvWpwx6VTZC3aVtyZfKSnNlNDaw_W3YPMDDtXGKCC4,27
+devicedeck/services/adb_devices.py,sha256=rVu6bGxr57Jbel06hijlSxbDZgp4RtyxVdb83PV3tZ8,2536
+devicedeck/services/commands.py,sha256=WVl5ffoW38ZNi6TGWNSNckvYSiUPCz0YWjmNyRMB0I8,3044
+devicedeck/services/remote_clients.py,sha256=_tDHAEHFXsceKkSefdDlWbnn3W24qa0EedvYq31AEU4,2189
+devicedeck/ui/__init__.py,sha256=y7PPGvLSjPcvNLfoUdhyQhhwnVza925Xgetg9GG9Oz0,14
+devicedeck/ui/app_icon.py,sha256=aTJnCPn93nNMiH9ttrMDGEt08MO0921S8rNAX2lAo3s,1418
+devicedeck/ui/combo_utils.py,sha256=uSYxgFY1ZCrKWHYirA2GJmFk_8egAW7aOL4sFGiFUyk,1779
+devicedeck/ui/first_run_dialog.py,sha256=YPBWBjIIntFMvANXsdN0HIrSsgCBqsjSNO0rOgBaFLI,3670
+devicedeck/ui/icon_utils.py,sha256=5Q-6lFIerolMnoY4BxujQj_H8Sqsofr8wlB387xHwiI,4630
+devicedeck/ui/main_window.py,sha256=LqkfAFwsbEjX1mn01oCt1wSIJl4PLKm-zyEOe0HSmqk,30515
+devicedeck/ui/preferences_dialog.py,sha256=NdC3qGo2P22jwNQGnJOSvUqkHh5khh4-1vljfPAfWiU,4333
+devicedeck/ui/session_login_dialog.py,sha256=9dZ-CjOU7BmUwiXhuKI_uUeg-iYit8mtb4kcEefk9J0,30828
+devicedeck/ui/styles.py,sha256=f4QNpDBY7ch5f0p2RCtEc4RgLIiQRpVybZHl0bVsl8Q,30904
+devicedeck/ui/win_scrcpy_hotkey.py,sha256=1WLlM5L_x3pi4RSA5kt9DibTC97UxO4GCfmH6fPhHqo,2287
+devicedeck/ui/tabs/__init__.py,sha256=Bo61o8qAdbFDOS19L6BKmezb7pvVIqAwx3qb_n3v2HY,21
+devicedeck/ui/tabs/file_explorer_tab.py,sha256=dh_y88eF2UxMT90ty5v9UXizvLC8HEj_OK38La9WwF4,151211
+devicedeck/ui/tabs/scrcpy_tab.py,sha256=auJK-r7m91bG7k4-ZwYEjZgfNqCss0RpGyqzCSQcxYU,30871
+devicedeck/ui/tabs/terminal_tab.py,sha256=0kXFvlHb9l3XkBzpGpUgaeUeZ89Pvkw8bPZsBGjkcbk,47928
+adbsshdeck-0.1.1.dist-info/LICENSE,sha256=_SWWCpa7LHxGYXdl3gQFlvj8SAf8H4mNw21HCkwQyas,1101
+adbsshdeck-0.1.1.dist-info/METADATA,sha256=fo6iu9HXse74aokfYd9tsJmdFKcTYdTwohRtM5dNPSY,4487
+adbsshdeck-0.1.1.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+adbsshdeck-0.1.1.dist-info/entry_points.txt,sha256=9jRm-947unZlvUXPBXkaT3pxVj-2wagtOs0DpIWYeu4,51
+adbsshdeck-0.1.1.dist-info/top_level.txt,sha256=jiQAATACR-5dTUdD_P2g-pZ0mpJ8K-P_A5StUrRzd74,11
+adbsshdeck-0.1.1.dist-info/RECORD,,

adbsshdeck-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

adbsshdeck-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+adbsshdeck = devicedeck.app:main

adbsshdeck-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+devicedeck

devicedeck/__init__.py

@@ -0,0 +1,4 @@
+# Application display name (window title, About, scrcpy default window title, etc.).
+APP_TITLE = "DeviceDeck"
+
+__version__ = "0.1.1"

devicedeck/__main__.py

@@ -0,0 +1,4 @@
+from .app import main
+
+if __name__ == "__main__":
+    main()

devicedeck/app.py

@@ -0,0 +1,45 @@
+import sys
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import QApplication, QStyleFactory
+
+from . import APP_TITLE
+from .config import AppConfig, has_existing_config_file
+from .ui.app_icon import create_app_icon
+from .ui.main_window import MainWindow
+
+
+def _set_windows_app_user_model_id() -> None:
+    """So the taskbar uses our window icon instead of the generic Python icon."""
+    if sys.platform != "win32":
+        return
+    try:
+        import ctypes
+
+        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID("DeviceDeck.DeviceDeck.Application.1")
+    except Exception:
+        pass
+
+
+def main():
+    _set_windows_app_user_model_id()
+    try:
+        QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps, True)
+    except AttributeError:
+        pass
+    app = QApplication(sys.argv)
+    app.setWindowIcon(create_app_icon())
+    fusion = QStyleFactory.create("Fusion")
+    if fusion is not None:
+        app.setStyle(fusion)
+    app.setApplicationName(APP_TITLE)
+    # Blinking text caret (ms). QApplication provides this in Qt5; ignore if unavailable.
+    try:
+        QApplication.setCursorFlashTime(530)
+    except AttributeError:
+        pass
+    fresh_config = not has_existing_config_file()
+    config = AppConfig.load()
+    window = MainWindow(config, first_launch=fresh_config)
+    window.show()
+    sys.exit(app.exec_())

devicedeck/config.py

@@ -0,0 +1,130 @@
+import json
+import os
+import tempfile
+from dataclasses import asdict, dataclass, field, fields
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+# Primary settings file; legacy `~/.adb_explorer_pro.json` is still read and removed after first save.
+CONFIG_PATH = Path.home() / ".devicedeck.json"
+_LEGACY_CONFIG_PATH = Path.home() / ".adb_explorer_pro.json"
+
+
+def has_existing_config_file() -> bool:
+    return CONFIG_PATH.exists() or _LEGACY_CONFIG_PATH.exists()
+
+
+def _sanitize_bookmark(bookmark: Dict[str, Any]) -> Dict[str, Any]:
+    """Drop sensitive fields before keeping bookmark data in config."""
+    cleaned = dict(bookmark)
+    for key in ("ssh_password", "sftp_password", "ftp_password"):
+        cleaned.pop(key, None)
+    return cleaned
+
+
+@dataclass
+class AppConfig:
+    # Empty on first run; resolved at runtime to "adb"/"scrcpy" when unset.
+    adb_path: str = ""
+    scrcpy_path: str = ""
+    dark_theme: bool = False
+    # When True, dock scrcpy into the Screen Control tab (Windows). Default False: separate window keeps
+    # reliable touch/swipe (embedded HWND reparenting often breaks input).
+    embed_scrcpy_mirror: bool = False
+    # Legacy mirror of embed checkbox; kept for older configs (embed off => opt_out true).
+    embed_scrcpy_mirror_opt_out: bool = True
+    default_ssh_host: str = ""
+    default_serial_port: str = "COM3"
+    default_serial_baud: str = "115200"
+    # Optional SSH: sent to the active terminal when using Commands → SSH (after you open an SSH tab).
+    ssh_mount_command: str = ""
+    # List of {"label": str, "command": str} — customizable in Preferences.
+    ssh_quick_commands: List[Dict[str, str]] = field(default_factory=list)
+    # Saved sessions (WinSCP/Moba-style): list of dicts with kind, name, host, user, etc.
+    session_bookmarks: List[Dict[str, Any]] = field(default_factory=list)
+    # Find files dialog: recent folder paths per side (local vs remote search)
+    find_folder_history_local: List[str] = field(default_factory=list)
+    find_folder_history_remote: List[str] = field(default_factory=list)
+
+    @classmethod
+    def load(cls) -> "AppConfig":
+        if CONFIG_PATH.exists():
+            read_path = CONFIG_PATH
+        elif _LEGACY_CONFIG_PATH.exists():
+            read_path = _LEGACY_CONFIG_PATH
+        else:
+            return cls()
+        known = {f.name for f in fields(cls)}
+        try:
+            raw = json.loads(read_path.read_text(encoding="utf-8"))
+            defaults = asdict(cls())
+            if isinstance(raw, dict):
+                for key, value in raw.items():
+                    if key in known:
+                        defaults[key] = value
+            if not isinstance(defaults.get("session_bookmarks"), list):
+                defaults["session_bookmarks"] = []
+            else:
+                defaults["session_bookmarks"] = [
+                    _sanitize_bookmark(x)
+                    for x in defaults["session_bookmarks"]
+                    if isinstance(x, dict)
+                ]
+            qc = defaults.get("ssh_quick_commands")
+            if not isinstance(qc, list):
+                defaults["ssh_quick_commands"] = []
+            else:
+                defaults["ssh_quick_commands"] = [
+                    {"label": str(x.get("label", "")), "command": str(x.get("command", ""))}
+                    for x in qc
+                    if isinstance(x, dict) and (x.get("label") or x.get("command"))
+                ]
+            for key in ("find_folder_history_local", "find_folder_history_remote"):
+                lst = defaults.get(key)
+                if not isinstance(lst, list):
+                    defaults[key] = []
+                else:
+                    defaults[key] = [str(x).strip() for x in lst if str(x).strip()][:40]
+            return cls(**defaults)
+        except Exception as exc:
+            print(f"[DeviceDeck] Could not load config '{read_path}': {exc}")
+            return cls()
+
+    def save(self) -> None:
+        data = asdict(self)
+        data["session_bookmarks"] = [
+            _sanitize_bookmark(x)
+            for x in data.get("session_bookmarks", [])
+            if isinstance(x, dict)
+        ]
+        qc = data.get("ssh_quick_commands")
+        if isinstance(qc, list):
+            data["ssh_quick_commands"] = [
+                {"label": str(x.get("label", "")), "command": str(x.get("command", ""))}
+                for x in qc
+                if isinstance(x, dict) and (str(x.get("label", "")).strip() or str(x.get("command", "")).strip())
+            ]
+        text = json.dumps(data, indent=2, ensure_ascii=False) + "\n"
+        path = CONFIG_PATH
+        path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp_path = tempfile.mkstemp(
+            suffix=".tmp",
+            prefix=f"{path.name}.",
+            dir=str(path.parent),
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                f.write(text)
+            os.replace(tmp_path, path)
+        except Exception:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+            raise
+        try:
+            if _LEGACY_CONFIG_PATH.is_file():
+                _LEGACY_CONFIG_PATH.unlink()
+        except OSError:
+            pass

devicedeck/services/__init__.py

@@ -0,0 +1 @@
+# Service helpers package

devicedeck/services/adb_devices.py

@@ -0,0 +1,74 @@
+"""Parse `adb devices -l` for serial + human-readable device names (e.g. model name)."""
+
+import re
+from typing import List, Optional, Tuple
+
+from .commands import run_adb
+
+
+def _parse_devices_l_line(line: str) -> Optional[Tuple[str, str]]:
+    line = line.strip()
+    if not line or line.startswith("List of devices"):
+        return None
+    # Match: SERIAL <spaces> device|unauthorized|sideload|recovery (adb uses tabs or spaces)
+    m = re.match(r"^(\S+)\s+(device|unauthorized|sideload|recovery)\b", line)
+    if not m:
+        return None
+    serial, state = m.group(1), m.group(2)
+    if serial in ("List", "*", "adb"):
+        return None
+
+    m2 = re.search(r"\bmodel:([^\s]+)", line)
+    model = m2.group(1).replace("_", " ") if m2 else ""
+    if not model:
+        m3 = re.search(r"\bdevice:([^\s]+)", line)
+        model = m3.group(1).replace("_", " ") if m3 else ""
+    tag = f" [{state}]" if state != "device" else ""
+    if model:
+        display = f"{model} · {serial}{tag}"
+    else:
+        display = f"{serial}{tag}"
+    return serial, display
+
+
+def list_adb_devices(adb_path: str) -> List[Tuple[str, str]]:
+    """
+    Return [(serial, display_label), ...].
+    Lists devices (handles space- or tab-separated lines).
+    """
+    code, stdout, _ = run_adb(adb_path, ["devices", "-l"])
+    out: List[Tuple[str, str]] = []
+    if code == 0 and stdout:
+        for line in stdout.splitlines():
+            parsed = _parse_devices_l_line(line)
+            if parsed:
+                out.append(parsed)
+    if out:
+        return out
+
+    code2, stdout2, _ = run_adb(adb_path, ["devices"])
+    if code2 != 0:
+        return []
+    for line in stdout2.splitlines():
+        line = line.strip()
+        if not line or line.startswith("List of devices"):
+            continue
+        m = re.match(r"^(\S+)\s+(device|unauthorized|sideload|recovery)\s*$", line)
+        if m:
+            serial = m.group(1)
+            state = m.group(2)
+            tag = f" [{state}]" if state != "device" else ""
+            out.append((serial, f"{serial}{tag}"))
+    return out
+
+
+def friendly_name_for_serial(adb_path: str, serial: str) -> str:
+    """Short name for tabs (e.g. 'Palq'); falls back to serial."""
+    if not serial:
+        return "ADB"
+    for s, display in list_adb_devices(adb_path):
+        if s == serial:
+            if " · " in display:
+                return display.split(" · ", 1)[0].strip()
+            return display
+    return serial

devicedeck/services/commands.py

@@ -0,0 +1,96 @@
+import re
+import subprocess
+import threading
+import sys
+from typing import Callable, List, Optional, Tuple
+
+
+def _win_subprocess_flags() -> dict:
+    """Hide spawned console windows for background commands on Windows."""
+    if sys.platform != "win32":
+        return {}
+    startupinfo = subprocess.STARTUPINFO()
+    startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+    startupinfo.wShowWindow = 0  # SW_HIDE
+    return {
+        "creationflags": getattr(subprocess, "CREATE_NO_WINDOW", 0),
+        "startupinfo": startupinfo,
+    }
+
+
+def run_command(command: List[str], timeout: int = 20) -> Tuple[int, str, str]:
+    try:
+        result = subprocess.run(
+            command,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            shell=False,
+            **_win_subprocess_flags(),
+        )
+        return result.returncode, result.stdout, result.stderr
+    except FileNotFoundError:
+        return 127, "", f"Command not found: {command[0]}"
+    except subprocess.TimeoutExpired:
+        return 124, "", "Command timed out"
+
+
+def run_adb(adb_path: str, args: List[str], timeout: int = 20) -> Tuple[int, str, str]:
+    return run_command([adb_path, *args], timeout=timeout)
+
+
+_pct_re = re.compile(r"(\d{1,3})\s*%")
+
+
+def run_adb_with_line_callback(
+    adb_path: str,
+    args: List[str],
+    timeout: int = 600,
+    on_line: Optional[Callable[[str], None]] = None,
+    on_percent: Optional[Callable[[int], None]] = None,
+) -> Tuple[int, str, str]:
+    """Run adb merging stderr into stdout; invoke on_line per line and on_percent when N%% is seen."""
+    cmd = [adb_path, *args]
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            stdin=subprocess.DEVNULL,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            bufsize=1,
+            **_win_subprocess_flags(),
+        )
+    except FileNotFoundError:
+        return 127, "", f"Command not found: {adb_path}"
+
+    out_chunks: List[str] = []
+
+    def reader():
+        assert proc.stdout is not None
+        for line in iter(proc.stdout.readline, ""):
+            out_chunks.append(line)
+            if on_line:
+                on_line(line.rstrip("\n"))
+            if on_percent:
+                for m in _pct_re.finditer(line):
+                    try:
+                        p = int(m.group(1))
+                        if 0 <= p <= 100:
+                            on_percent(p)
+                    except ValueError:
+                        pass
+        proc.stdout.close()
+
+    t = threading.Thread(target=reader, daemon=True)
+    t.start()
+    try:
+        proc.wait(timeout=timeout)
+    except subprocess.TimeoutExpired:
+        proc.kill()
+        proc.wait()
+        return 124, "".join(out_chunks), "Command timed out"
+    t.join(timeout=2.0)
+    return proc.returncode or 0, "".join(out_chunks), ""

devicedeck/services/remote_clients.py

@@ -0,0 +1,84 @@
+"""SFTP / FTP connection helpers for the unified session model."""
+
+import socket
+from ftplib import FTP, error_perm
+from typing import Optional, Tuple
+
+try:
+    import paramiko
+except ImportError:
+    paramiko = None  # type: ignore
+
+
+def connect_sftp(
+    host: str,
+    port: int,
+    username: str,
+    password: str,
+    timeout: int = 25,
+) -> Tuple[Optional["paramiko.Transport"], Optional["paramiko.SFTPClient"], str]:
+    if paramiko is None:
+        return None, None, "paramiko is not installed (pip install paramiko)"
+    if not host.strip():
+        return None, None, "Host is empty"
+    sock = None
+    try:
+        sock = socket.create_connection((host.strip(), int(port)), timeout=timeout)
+        t = paramiko.Transport(sock)
+        t.banner_timeout = timeout
+        t.auth_timeout = timeout
+        uname = (username or "").strip() or None
+        pwd = password if password else None
+        t.connect(username=uname, password=pwd)
+        sftp = paramiko.SFTPClient.from_transport(t)
+        return t, sftp, ""
+    except Exception as exc:
+        try:
+            if sock is not None:
+                sock.close()
+        except Exception:
+            pass
+        return None, None, str(exc)
+
+
+def disconnect_sftp(transport, sftp) -> None:
+    try:
+        if sftp is not None:
+            sftp.close()
+    except Exception:
+        pass
+    try:
+        if transport is not None:
+            transport.close()
+    except Exception:
+        pass
+
+
+def connect_ftp(
+    host: str,
+    port: int,
+    user: str,
+    password: str,
+    timeout: int = 25,
+) -> Tuple[Optional[FTP], str]:
+    if not host.strip():
+        return None, "Host is empty"
+    try:
+        ftp = FTP()
+        ftp.connect(host.strip(), int(port), timeout=timeout)
+        ftp.login(user or "", password or "")
+        return ftp, ""
+    except Exception as exc:
+        return None, str(exc)
+
+
+def disconnect_ftp(ftp: Optional[FTP]) -> None:
+    if ftp is None:
+        return
+    try:
+        ftp.quit()
+    except Exception:
+        try:
+            ftp.close()
+        except Exception:
+            pass