riptide-transfer 1.3.6__py3-none-any.whl

riptide/__init__.py

@@ -0,0 +1,28 @@
+"""Riptide: direct, encrypted PC-to-PC file transfer in the terminal."""
+
+from pathlib import Path
+import tomllib
+
+
+def _load_version() -> str:
+    pyproject_path = Path(__file__).resolve().parents[2] / "pyproject.toml"
+    if pyproject_path.exists():
+        try:
+            data = tomllib.loads(pyproject_path.read_text(encoding="utf-8"))
+            return str(data.get("project", {}).get("version", "0.0.0"))
+        except Exception:
+            pass
+    try:
+        from importlib.metadata import version
+        for dist_name in ("riptide-transfer", "riptide"):
+            try:
+                return version(dist_name)
+            except Exception:
+                continue
+    except Exception:
+        pass
+    return "0.0.0"
+
+
+__version__ = _load_version()
+__all__ = ["__version__"]

riptide/__main__.py

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

riptide/app.py

@@ -0,0 +1,45 @@
+"""Riptide Textual app. Entry point: riptide = riptide.app:main"""
+from __future__ import annotations
+
+import argparse
+import sys
+
+from textual.app import App
+
+from . import __version__
+from .theme import CSS
+
+
+class RiptideApp(App):
+    CSS = CSS
+    TITLE = "riptide"
+
+    def render(self):
+        from textual.renderables.blank import Blank
+        return Blank("transparent")
+
+    def on_mount(self) -> None:
+        self.styles.background = "transparent"
+        from .screens.menu import MenuScreen
+
+        self.push_screen(MenuScreen())
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="riptide",
+        description="Direct, encrypted PC-to-PC file transfer in the terminal.",
+    )
+    parser.add_argument("--version", action="version", version=f"riptide {__version__}")
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    parser.parse_args(argv)
+    app = RiptideApp()
+    app.run()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

riptide/core/__init__.py

@@ -0,0 +1 @@
+"""Core, non-UI logic for riptide."""

riptide/core/config.py

@@ -0,0 +1,176 @@
+"""Saved connections and settings.
+
+Location is always Path.home() / ".riptide" / "config.toml", on every OS.
+Private keys and certificates are never stored here. A peer is identified
+by host + TLS certificate fingerprint, approved in the UI on first connect.
+
+Since v1.1, the host side also keeps trusted clients, separate from
+dial-out peers. A trusted client is identified by fingerprint, with
+the device name as a display label only. The dial-out peer list is
+keyed by host, for filling the Join address, while the trusted
+client list is keyed by fingerprint, for host-side authentication.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # Python < 3.11, not supported by pyproject
+    import tomli as tomllib  # type: ignore
+
+# Session port. Kept in code/config only, except for the
+# Create/Join header and waiting text.
+# 50000 is in the dynamic/private range (49152-65535), so it is not
+# IANA-reserved, but it is the de facto default for IBM DB2, Jenkins
+# agents, and SAP NetWeaver Java, so a machine running one of those
+# will already have it in use and Riptide will fail to bind.
+DEFAULT_SESSION_PORT = 50000
+
+
+def config_dir(home: Path | None = None) -> Path:
+    return (home or Path.home()) / ".riptide"
+
+
+def config_path(home: Path | None = None) -> Path:
+    return config_dir(home) / "config.toml"
+
+
+@dataclass
+class Peer:
+    name: str
+    host: str = ""
+    fingerprint: str = ""
+
+
+@dataclass
+class Config:
+    peers: list[Peer] = field(default_factory=list)
+    trusted_clients: list[Peer] = field(default_factory=list)
+    session_port: int = DEFAULT_SESSION_PORT
+    firewall_port_open: bool | None = None
+    def peer_for(self, host: str) -> Peer | None:
+        for peer in self.peers:
+            if peer.host == host:
+                return peer
+        return None
+    def trusted_client_for_fingerprint(self, fingerprint: str) -> Peer | None:
+        for peer in self.trusted_clients:
+            if peer.fingerprint and peer.fingerprint == fingerprint:
+                return peer
+        return None
+    def trusted_client_for_device(self, device: str) -> Peer | None:
+        for peer in self.trusted_clients:
+            if peer.name and peer.name == device:
+                return peer
+        return None
+
+
+def _escape(value: str) -> str:
+    return value.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def _contains_private_key(text: str) -> bool:
+    return "PRIVATE KEY" in text or "-----BEGIN" in text
+
+
+def load_config(home: Path | None = None) -> Config:
+    path = config_path(home)
+    if not path.exists():
+        return Config()
+    try:
+        data = tomllib.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return Config()
+    peers = []
+    for item in data.get("peer", []) if isinstance(data.get("peer", []), list) else []:
+        if not isinstance(item, dict):
+            continue
+        peers.append(Peer(
+            name=str(item.get("name", "")),
+            host=str(item.get("host", "")),
+            fingerprint=str(item.get("fingerprint", "")),
+        ))
+    trusted_clients = []
+    for item in data.get("trusted_client", []) if isinstance(data.get("trusted_client", []), list) else []:
+        if not isinstance(item, dict):
+            continue
+        trusted_clients.append(Peer(
+            name=str(item.get("name", "")),
+            host=str(item.get("host", "")),
+            fingerprint=str(item.get("fingerprint", "")),
+        ))
+    session_port = data.get("session_port", DEFAULT_SESSION_PORT)
+    try:
+        session_port = int(session_port)
+    except Exception:
+        session_port = DEFAULT_SESSION_PORT
+    firewall_val = data.get("firewall_port_open")
+    firewall_port_open = bool(firewall_val) if firewall_val is not None else None
+    return Config(peers=peers, trusted_clients=trusted_clients, session_port=session_port, firewall_port_open=firewall_port_open)
+
+
+def save_config(config: Config, home: Path | None = None) -> Path:
+    for peer in list(config.peers) + list(config.trusted_clients):
+        for value in (peer.name, peer.host, peer.fingerprint):
+            if _contains_private_key(value):
+                raise ValueError("refusing to store a private key in config")
+    directory = config_dir(home)
+    directory.mkdir(parents=True, exist_ok=True)
+    lines = [f"session_port = {int(config.session_port)}"]
+    if config.firewall_port_open is not None:
+        lines.append(f"firewall_port_open = {'true' if config.firewall_port_open else 'false'}")
+    lines.append("")
+    for peer in config.peers:
+        lines.append("[[peer]]")
+        lines.append(f'name = "{_escape(peer.name)}"')
+        lines.append(f'host = "{_escape(peer.host)}"')
+        lines.append(f'fingerprint = "{_escape(peer.fingerprint)}"')
+        lines.append("")
+    for peer in config.trusted_clients:
+        lines.append("[[trusted_client]]")
+        lines.append(f'name = "{_escape(peer.name)}"')
+        lines.append(f'host = "{_escape(peer.host)}"')
+        lines.append(f'fingerprint = "{_escape(peer.fingerprint)}"')
+        lines.append("")
+    path = config_path(home)
+    path.write_text("\n".join(lines), encoding="utf-8")
+    return path
+
+
+def add_peer(config: Config, peer: Peer, home: Path | None = None) -> Config:
+    existing = config.peer_for(peer.host) if peer.host else None
+    if existing is not None:
+        existing.name = peer.name or existing.name
+        existing.fingerprint = peer.fingerprint or existing.fingerprint
+    else:
+        config.peers.append(peer)
+    save_config(config, home=home)
+    return config
+
+
+def add_trusted_client(config: Config, peer: Peer, home: Path | None = None) -> Config:
+    """Save a host-side trusted client, keyed by fingerprint.
+
+    If the fingerprint is already trusted, update its label.
+    If the device label is already trusted with a different
+    fingerprint, replace that fingerprint, which is the explicit
+    Replace flow after a changed-fingerprint warning. Otherwise
+    append a new trusted client.
+    """
+    if peer.fingerprint:
+        existing = config.trusted_client_for_fingerprint(peer.fingerprint)
+        if existing is not None:
+            existing.name = peer.name or existing.name
+            save_config(config, home=home)
+            return config
+    if peer.name:
+        by_device = config.trusted_client_for_device(peer.name)
+        if by_device is not None:
+            by_device.fingerprint = peer.fingerprint
+            save_config(config, home=home)
+            return config
+    config.trusted_clients.append(peer)
+    save_config(config, home=home)
+    return config

riptide/core/file_select.py

@@ -0,0 +1,89 @@
+"""File selection: the file manager listing and display.
+
+Files are selected only from the file manager, with Space, and
+sent with Enter. This module is deliberately stdlib-only so it
+is easy to test.
+"""
+from __future__ import annotations
+from datetime import datetime
+import re
+import shlex
+from pathlib import Path
+
+
+def format_bytes(n: int) -> str:
+    n = int(n)
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024 or unit == "TB":
+            return f"{n:.1f} {unit}" if unit != "B" else f"{n} B"
+        n = n / 1024  # type: ignore[assignment]
+    return f"{n} B"
+
+
+def total_size(paths: list[Path]) -> int:
+    total = 0
+    for path in paths:
+        try:
+            if path.is_file():
+                total += path.stat().st_size
+        except OSError:
+            pass
+    return total
+
+def format_mtime(mtime: float) -> str:
+    """Format modification timestamp as strictly dd-mm-yyyy hh:mm am/pm in lowercase."""
+    dt = datetime.fromtimestamp(mtime)
+    return dt.strftime("%d-%m-%Y %I:%M %p").lower()
+
+
+def format_file_row(path: Path) -> tuple[str, str, str]:
+    """Return (filename, size_str, mtime_str) for displaying in file tables."""
+    stat = path.stat()
+    return path.name, format_bytes(stat.st_size), format_mtime(stat.st_mtime)
+
+
+
+
+
+
+
+
+def add_to_selection(selection: list[Path], new: list[Path]) -> list[Path]:
+    seen = set(selection)
+    for path in new:
+        if path not in seen:
+            seen.add(path)
+            selection.append(path)
+    return selection
+
+
+
+
+
+
+def list_browser_entries(directory: Path) -> list[Path]:
+    """File-manager entries for a directory: folders first, then
+    files, each group alphabetical. Hidden entries are kept."""
+    if not directory.is_dir():
+        return []
+    try:
+        entries = list(directory.iterdir())
+    except OSError:
+        return []
+    folders = sorted((p for p in entries if p.is_dir()), key=lambda p: p.name.lower())
+    files = sorted((p for p in entries if p.is_file()), key=lambda p: p.name.lower())
+    return folders + files
+
+
+def format_browser_row(path: Path) -> tuple[str, str, str]:
+    """Display row for the file manager: (display, size, mtime).
+
+    Folders get a folder icon and a trailing slash, and no size
+    or date: ``📁 docs/`` with empty size/mtime. Files keep the
+    name / size / mtime format."""
+    if path.is_dir():
+        return f"📁 {path.name}/", "", ""
+    name, size, mtime = format_file_row(path)
+    return name, size, mtime
+
+