xshell-like 0.1.0__py3-none-any.whl

xshell/__init__.py

@@ -0,0 +1,3 @@
+"""XShell-like terminal tool: SSH + serial, tabs, batch connect, sessions, SFTP."""
+
+__version__ = "0.1.0"

xshell/__main__.py

@@ -0,0 +1,22 @@
+"""Entry point: python -m xshell (GUI; use QT_QPA_PLATFORM=offscreen for headless)."""
+import sys
+
+
+def main() -> int:
+    from PySide6.QtWidgets import QApplication
+
+    from xshell.core.storage import SessionStore
+    from xshell.ui.main_window import MainWindow
+
+    app = QApplication(sys.argv)
+    app.setApplicationName("xshell-like")
+    app.setOrganizationName("xshell-like")
+
+    store = SessionStore()
+    window = MainWindow(store=store)
+    window.show()
+    return app.exec()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

xshell/core/__init__.py

@@ -0,0 +1 @@
+"""Core layer: pure Python, no Qt dependency (fully headless-testable)."""

xshell/core/batch.py

@@ -0,0 +1,59 @@
+"""Batch orchestration: connect many sessions at once, isolate failures."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, List, Optional, Tuple
+
+from .session import SessionConfig
+from .transport import TransportBase, default_transport_factory
+
+
+@dataclass
+class BatchResult:
+    opened: List[Tuple[SessionConfig, TransportBase]] = field(default_factory=list)
+    failed: List[Tuple[SessionConfig, str]] = field(default_factory=list)
+
+    @property
+    def ok_count(self) -> int:
+        return len(self.opened)
+
+    @property
+    def fail_count(self) -> int:
+        return len(self.failed)
+
+    def summary(self) -> str:
+        lines = [f"connected {self.ok_count}, failed {self.fail_count}"]
+        for cfg, err in self.failed:
+            lines.append(f"  ✗ {cfg.display_name()}: {err}")
+        return "\n".join(lines)
+
+
+class BatchManager:
+    """Opens one transport per config; a bad session never blocks the rest."""
+
+    def __init__(self, transport_factory: Optional[Callable] = None):
+        self._factory = transport_factory or default_transport_factory
+
+    def connect_one(self, config: SessionConfig, **kwargs) -> TransportBase:
+        transport = self._factory(config, **kwargs)
+        transport.open()
+        return transport
+
+    def connect_all(self, configs: List[SessionConfig], **kwargs) -> BatchResult:
+        result = BatchResult()
+        for config in configs:
+            try:
+                transport = self.connect_one(config, **kwargs)
+            except Exception as exc:
+                result.failed.append((config, str(exc)))
+                continue
+            result.opened.append((config, transport))
+        return result
+
+    def close_all(self, transports: List[TransportBase]) -> None:
+        for transport in transports:
+            try:
+                if transport.is_open:
+                    transport.close()
+            except Exception:
+                pass  # closing must never throw back into the UI

xshell/core/keydeploy.py

@@ -0,0 +1,127 @@
+"""Deploy the local public key to a remote host (passwordless setup).
+
+Equivalent of `ssh-copy-id`, implemented over paramiko so it also works on
+Windows: connect with the credentials the session already has (password,
+existing key, or agent), then run the append through the remote shell.
+"""
+from __future__ import annotations
+
+import os
+import re
+import stat
+from dataclasses import dataclass
+from pathlib import Path
+
+import paramiko
+
+from .session import SessionConfig
+
+_PUBKEY_RE = re.compile(r"^(ssh-(rsa|dss|ed25519)|ecdsa-[a-z0-9-]+) [A-Za-z0-9+/=]+[ @]")
+_CHECK_CMD = "mkdir -p ~/.ssh && chmod 700 ~/.ssh && cat ~/.ssh/authorized_keys 2>/dev/null || true"
+_APPEND_CMD = "mkdir -p ~/.ssh && chmod 700 ~/.ssh && echo {key} >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys"
+
+
+@dataclass
+class DeployResult:
+    ok: bool
+    already_present: bool
+    message: str
+
+
+def find_local_public_key(ssh_dir: Path = None) -> tuple | None:
+    """Find an existing default keypair. Returns (private_path, pubkey_text)."""
+    ssh_dir = Path(ssh_dir) if ssh_dir else Path.home() / ".ssh"
+    for name in ("id_ed25519", "id_rsa", "id_ecdsa", "id_dsa"):
+        priv = ssh_dir / name
+        pub = ssh_dir / (name + ".pub")
+        if pub.exists():
+            return str(priv), pub.read_text(encoding="utf-8").strip()
+    return None
+
+
+def ensure_local_keypair(ssh_dir: Path = None) -> tuple:
+    """Find or generate a default keypair (RSA 3072, no passphrase).
+    Returns (private_path, pubkey_text)."""
+    existing = find_local_public_key(ssh_dir)
+    if existing:
+        return existing
+
+    ssh_dir = Path(ssh_dir) if ssh_dir else Path.home() / ".ssh"
+    ssh_dir.mkdir(parents=True, exist_ok=True)
+    key = paramiko.RSAKey.generate(3072)
+    priv_path = ssh_dir / "id_rsa"
+    key.write_private_key_file(str(priv_path))
+    os.chmod(priv_path, stat.S_IRUSR | stat.S_IWUSR)  # 0600
+    pub_path = ssh_dir / "id_rsa.pub"
+    pub_path.write_text(f"{key.get_name()} {key.get_base64()} xshell-like\n", encoding="utf-8")
+    return str(priv_path), pub_path.read_text(encoding="utf-8").strip()
+
+
+def _run(client: paramiko.SSHClient, command: str) -> str:
+    _, stdout, _ = client.exec_command(command, timeout=15)
+    output = stdout.read().decode("utf-8", errors="replace")
+    exit_code = stdout.channel.recv_exit_status()
+    if exit_code != 0:
+        raise RuntimeError(f"远端命令失败(退出码 {exit_code}): {command[:60]}…")
+    return output
+
+
+def deploy_public_key(config: SessionConfig, ssh_dir: Path = None) -> DeployResult:
+    """Append the local public key to the remote authorized_keys.
+
+    Uses the session's own credentials for the first hop: a stored password,
+    an explicit key file, or the agent/default keys.
+    """
+    priv_path, pub_text = ensure_local_keypair(ssh_dir)
+    if not _PUBKEY_RE.match(pub_text):
+        return DeployResult(False, False, f"本机公钥格式异常，拒绝部署: {pub_text[:40]}…")
+
+    cfg = config
+    client = paramiko.SSHClient()
+    client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+    kwargs = dict(
+        hostname=cfg.host,
+        port=int(cfg.port),
+        username=cfg.username or None,
+        timeout=10,
+        banner_timeout=10,
+        allow_agent=False,
+        look_for_keys=False,
+    )
+    if cfg.auth_method == "key" and cfg.key_path:
+        kwargs["key_filename"] = cfg.key_path
+        kwargs["allow_agent"] = True
+    elif cfg.auth_method == "auto":
+        kwargs["allow_agent"] = True
+        kwargs["look_for_keys"] = True
+    elif cfg.password:
+        kwargs["password"] = cfg.password
+    elif cfg.auth_method == "key" or cfg.auth_method == "auto":
+        kwargs["allow_agent"] = True
+        kwargs["look_for_keys"] = True
+    else:  # password auth but no password stored — caller must prompt first
+        return DeployResult(
+            False, False, "该会话没有可用凭据：请先在会话里保存密码，或已配置免密/agent"
+        )
+
+    try:
+        client.connect(**kwargs)
+    except paramiko.AuthenticationException:
+        return DeployResult(False, False, "认证失败：密码错误且无可用密钥")
+    except (paramiko.SSHException, OSError) as exc:
+        return DeployResult(False, False, f"连接失败: {exc}")
+
+    try:
+        existing = _run(client, _CHECK_CMD)
+        if pub_text in existing:
+            return DeployResult(True, True, "公钥已存在，无需重复部署")
+        append_cmd = _APPEND_CMD.format(key="'" + pub_text + "'")
+        _run(client, append_cmd)
+        confirm = _run(client, _CHECK_CMD)
+        if pub_text not in confirm:
+            return DeployResult(False, False, "部署后校验失败：远端 authorized_keys 未见公钥")
+        return DeployResult(True, False, f"已部署公钥 {Path(priv_path).name} → {cfg.summary()}")
+    except (paramiko.SSHException, OSError, RuntimeError) as exc:
+        return DeployResult(False, False, f"部署失败: {exc}")
+    finally:
+        client.close()

xshell/core/serial_transport.py

@@ -0,0 +1,98 @@
+"""Serial transport on top of pyserial (device files / USB adapters)."""
+from __future__ import annotations
+
+import threading
+
+import serial
+
+from .session import SessionConfig
+from .transport import TransportBase
+
+READ_TIMEOUT = 0.2  # seconds — read() returns up to this early
+WRITE_TIMEOUT = 10  # seconds — how long a blocked write may hold the caller
+
+
+class SerialTransport(TransportBase):
+    def __init__(self, config: SessionConfig, **kwargs):
+        super().__init__(config, **kwargs)
+        self._port: serial.Serial | None = None
+        self._reader: threading.Thread | None = None
+        self._stop = threading.Event()
+
+    @property
+    def is_open(self) -> bool:
+        return (
+            self._port is not None
+            and self._port.is_open
+            and not self._stop.is_set()
+        )
+
+    def open(self) -> None:
+        cfg = self.config
+        try:
+            port = serial.Serial(
+                port=cfg.device,
+                baudrate=int(cfg.baudrate),
+                bytesize=int(cfg.bytesize),
+                parity=cfg.parity,
+                stopbits=int(cfg.stopbits),
+                timeout=READ_TIMEOUT,
+                write_timeout=WRITE_TIMEOUT,
+            )
+        except (serial.SerialException, OSError, ValueError) as exc:
+            raise ConnectionError(f"cannot open {cfg.device}: {exc}") from exc
+
+        self._port = port
+        self._stop.clear()
+        self._reader = threading.Thread(
+            target=self._read_loop, name=f"serial-read-{cfg.name}", daemon=True
+        )
+        self._reader.start()
+        self._emit("connected", cfg.summary())
+
+    def _read_loop(self) -> None:
+        port = self._port
+        try:
+            while not self._stop.is_set():
+                try:
+                    chunk = port.read(4096)
+                except (serial.SerialException, OSError, TypeError):
+                    if self._stop.is_set():
+                        break
+                    self._emit("error", "serial port read failed")
+                    break
+                if chunk:
+                    cb = self.on_data
+                    if cb:
+                        cb(chunk)
+            if not self._stop.is_set():
+                self._emit("disconnected", "device disappeared")
+        except Exception as exc:
+            if not self._stop.is_set():
+                self._emit("error", f"reader thread: {exc}")
+        finally:
+            self._stop.set()
+
+    def write(self, data: bytes) -> None:
+        if self.is_open:
+            try:
+                self._port.write(data)
+                if self.config.local_echo and self.on_data:
+                    self.on_data(data)
+            except (serial.SerialException, OSError) as exc:
+                self._emit("error", f"write failed: {exc}")
+
+    def resize(self, cols: int, rows: int) -> None:
+        self.cols, self.rows = cols, rows  # no pty geometry on a serial line
+
+    def close(self) -> None:
+        self._stop.set()
+        port, self._port = self._port, None
+        if port is not None:
+            try:
+                port.close()
+            except Exception:
+                pass
+        if self._reader and self._reader.is_alive():
+            self._reader.join(timeout=1.0)
+        self._emit("disconnected", "")

xshell/core/session.py

@@ -0,0 +1,199 @@
+"""Session data model: SSH / serial connection config with persistence support."""
+from __future__ import annotations
+
+import base64
+import time
+import uuid
+from dataclasses import asdict, dataclass, field, fields
+from typing import Any, Dict
+
+TYPE_SSH = "ssh"
+TYPE_SERIAL = "serial"
+
+TYPE_BADGE = {TYPE_SSH: "[SSH]", TYPE_SERIAL: "[串口]"}
+
+
+def parse_ssh_target(text: str) -> SessionConfig:
+    """Parse a quick-connect string into a session config.
+
+    Accepted forms (leading 'ssh ' optional):
+        ts@10.0.28.34            user@host            (passwordless key/agent auth)
+        ts@10.0.28.34:2222       user@host:port
+        ssh -p 2222 ts@10.0.28.34                   (-p flag, before or after target)
+    """
+    raw = (text or "").strip()
+    if raw.lower().startswith("ssh "):
+        raw = raw[4:].strip()
+    if not raw or raw.lower() == "ssh":
+        raise ValueError("请输入连接目标，如 ssh ts@10.0.28.34")
+
+    port = 22
+    tokens = raw.split()
+    # pull out an optional -p <port> / -p<port> flag wherever it appears
+    i = 0
+    targets: list = []
+    while i < len(tokens):
+        tok = tokens[i]
+        if tok == "-p":
+            if i + 1 >= len(tokens):
+                raise ValueError("-p 缺少端口号")
+            port = int(tokens[i + 1])
+            i += 2
+            continue
+        if tok.startswith("-p") and tok != "-p" and tok[2:].isdigit():
+            port = int(tok[2:])
+            i += 1
+            continue
+        if tok.startswith("-"):
+            raise ValueError(f"暂不支持参数: {tok}")
+        targets.append(tok)
+        i += 1
+    if not targets:
+        raise ValueError("缺少主机地址，如 ssh ts@10.0.28.34")
+    if len(targets) > 1:
+        raise ValueError(f"一次只能连接一个目标，收到: {' '.join(targets)}")
+
+    target = targets[0]
+    if ":" in target:
+        target, _, port_part = target.rpartition(":")
+        if not port_part.isdigit():
+            raise ValueError(f"端口不合法: {port_part}")
+        port = int(port_part)
+        target = target.strip("[]")  # bare [ipv6]:port
+    if "@" in target:
+        username, _, host = target.partition("@")
+    else:
+        username, host = "", target
+    if not host:
+        raise ValueError("缺少主机地址")
+    if not username:
+        import getpass
+
+        username = getpass.getuser()
+
+    return SessionConfig(
+        name=f"{username}@{host}" if port == 22 else f"{username}@{host}:{port}",
+        type=TYPE_SSH,
+        host=host,
+        port=port,
+        username=username,
+        auth_method="auto",  # passwordless first: agent + default keys
+    )
+
+
+def _encode_secret(plain: str) -> str:
+    """Light obfuscation (base64) — not encryption; use key auth for real security."""
+    return base64.b64encode(plain.encode("utf-8")).decode("ascii") if plain else ""
+
+
+def _decode_secret(stored: str) -> str:
+    try:
+        return base64.b64decode(stored.encode("ascii")).decode("utf-8") if stored else ""
+    except (ValueError, UnicodeDecodeError):
+        return ""
+
+
+@dataclass
+class SessionConfig:
+    """One saved connection (SSH or serial). All fields JSON-serializable."""
+
+    name: str = ""
+    type: str = TYPE_SSH
+    id: str = field(default_factory=lambda: uuid.uuid4().hex)
+
+    # --- SSH specific ---
+    host: str = ""
+    port: int = 22
+    username: str = ""
+    auth_method: str = "password"  # "password" | "key"
+    password_enc: str = ""  # base64-obfuscated password, never plain in JSON
+    key_path: str = ""
+
+    # --- Serial specific ---
+    device: str = "/dev/ttyUSB0"
+    baudrate: int = 115200
+    bytesize: int = 8
+    parity: str = "N"  # N / E / O
+    stopbits: int = 1
+
+    # --- Common ---
+    encoding: str = "utf-8"
+    local_echo: bool = False  # serial devices often need it; SSH remote echoes
+    group: str = ""
+    created_at: float = field(default_factory=time.time)
+    last_used: float = 0.0
+
+    # ---------- persistence ----------
+
+    def to_dict(self) -> Dict[str, Any]:
+        d = asdict(self)
+        return d
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> "SessionConfig":
+        known = {f.name for f in fields(cls)}
+        filtered = {k: v for k, v in d.items() if k in known}
+        # tolerate hand-edited files: coerce types, drop fields that stay garbage
+        type_hints = {f.name: f.type for f in fields(cls)}
+        for k, v in list(filtered.items()):
+            hint = str(type_hints.get(k, ""))
+            try:
+                if "bool" in hint:
+                    filtered[k] = bool(v)
+                elif "int" in hint:
+                    filtered[k] = int(v)
+                elif "float" in hint:
+                    filtered[k] = float(v)
+                elif "str" in hint:
+                    filtered[k] = "" if v is None else str(v)
+            except (TypeError, ValueError):
+                del filtered[k]  # fall back to the dataclass default
+        stype = filtered.get("type", TYPE_SSH)
+        if stype not in (TYPE_SSH, TYPE_SERIAL):
+            raise ValueError(f"unknown session type: {stype!r}")
+        return cls(**filtered)
+
+    # ---------- duplication avoidance (R6) ----------
+
+    def same_identity(self, other: "SessionConfig") -> bool:
+        """Two sessions are 'the same connection' if their identity matches."""
+        if self is other:
+            return True
+        if self.type != other.type:
+            return False
+        if self.type == TYPE_SSH:
+            return (
+                self.host == other.host
+                and int(self.port) == int(other.port)
+                and self.username == other.username
+            )
+        return self.device == other.device and int(self.baudrate) == int(other.baudrate)
+
+    # ---------- convenience ----------
+
+    @property
+    def password(self) -> str:
+        return _decode_secret(self.password_enc)
+
+    @password.setter
+    def password(self, plain: str) -> None:
+        self.password_enc = _encode_secret(plain)
+
+    def display_name(self) -> str:
+        if self.type == TYPE_SSH:
+            return f"{self.name or self.host}"
+        return f"{self.name or self.device}"
+
+    def summary(self) -> str:
+        if self.type == TYPE_SSH:
+            return f"ssh://{self.username}@{self.host}:{self.port}"
+        return f"{self.device}@{self.baudrate} {self.parity}{self.bytesize}{self.stopbits}"
+
+    def clone(self, new_name: str | None = None) -> "SessionConfig":
+        """Copy with a fresh id — batch-creating similar devices only edits host/IP."""
+        data = self.to_dict()
+        data["id"] = uuid.uuid4().hex
+        data["name"] = new_name if new_name is not None else f"{self.name} copy"
+        data["created_at"] = time.time()
+        data["last_used"] = 0.0
+        return SessionConfig.from_dict(data)

xshell/core/sftp.py

@@ -0,0 +1,123 @@
+"""SFTP file transfer over an established SSH connection (paramiko SFTPClient)."""
+from __future__ import annotations
+
+import os
+import posixpath
+import stat as statmod
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Callable, List, Optional
+
+import paramiko
+
+CHUNK = 32768
+
+
+@dataclass
+class FileEntry:
+    name: str
+    path: str
+    size: int
+    is_dir: bool
+    mtime: float
+
+    @property
+    def size_human(self) -> str:
+        if self.is_dir:
+            return "<dir>"
+        for unit in ("B", "KB", "MB", "GB"):
+            if self.size < 1024 or unit == "GB":
+                return f"{self.size:.0f}{unit}" if unit == "B" else f"{self.size / 1:.1f}{unit}"
+            self.size /= 1024
+        return f"{self.size}B"
+
+    @property
+    def mtime_human(self) -> str:
+        return datetime.fromtimestamp(self.mtime).strftime("%Y-%m-%d %H:%M")
+
+
+class SftpClient:
+    """Reuses the SSH connection of an open SshTransport."""
+
+    def __init__(self, ssh_transport) -> None:
+        client = getattr(ssh_transport, "_client", None)
+        if client is None:
+            raise ConnectionError("SSH transport is not open")
+        self._sftp: paramiko.SFTPClient = client.open_sftp()
+
+    # ---------- browsing ----------
+
+    def listdir(self, path: str = ".") -> List[FileEntry]:
+        entries: List[FileEntry] = []
+        for attr in self._sftp.listdir_attr(path):
+            full = posixpath.join(path, attr.filename)
+            entries.append(
+                FileEntry(
+                    name=attr.filename,
+                    path=full,
+                    size=attr.st_size or 0,
+                    is_dir=statmod.S_ISDIR(attr.st_mode or 0),
+                    mtime=attr.st_mtime or 0,
+                )
+            )
+        dirs = [e for e in entries if e.is_dir]
+        files = [e for e in entries if not e.is_dir]
+        return sorted(dirs, key=lambda e: e.name.lower()) + sorted(
+            files, key=lambda e: e.name.lower()
+        )
+
+    @staticmethod
+    def join(path: str, name: str) -> str:
+        return posixpath.join(path, name)
+
+    @staticmethod
+    def parent(path: str) -> str:
+        parent = posixpath.dirname(path.rstrip("/"))
+        return parent or "/"
+
+    # ---------- transfer ----------
+
+    def upload(self, local_path: str, remote_path: str,
+               progress: Optional[Callable[[int, int], None]] = None) -> None:
+        total = os.path.getsize(local_path)
+        done = 0
+        with open(local_path, "rb") as lf, self._sftp.open(remote_path, "wb") as rf:
+            while True:
+                chunk = lf.read(CHUNK)
+                if not chunk:
+                    break
+                rf.write(chunk)
+                done += len(chunk)
+                if progress:
+                    progress(done, total)
+
+    def download(self, remote_path: str, local_path: str,
+                 progress: Optional[Callable[[int, int], None]] = None) -> None:
+        total = self._sftp.stat(remote_path).st_size
+        done = 0
+        with self._sftp.open(remote_path, "rb") as rf, open(local_path, "wb") as lf:
+            while True:
+                chunk = rf.read(CHUNK)
+                if not chunk:
+                    break
+                lf.write(chunk)
+                done += len(chunk)
+                if progress:
+                    progress(done, total)
+
+    # ---------- maintenance ----------
+
+    def mkdir(self, remote_path: str) -> None:
+        self._sftp.mkdir(remote_path)
+
+    def remove_file(self, remote_path: str) -> None:
+        self._sftp.remove(remote_path)
+
+    def remove_dir(self, remote_path: str) -> None:
+        self._sftp.rmdir(remote_path)
+
+    def close(self) -> None:
+        try:
+            self._sftp.close()
+        except Exception:
+            pass