ot-cli 0.2.1__py3-none-any.whl

openterminal/session/ssh.py

@@ -0,0 +1,321 @@
+"""远端 Linux 持久 shell：asyncssh + PTY 通道，断线重连一次。"""
+
+from __future__ import annotations
+
+import asyncio
+import base64
+import binascii
+import hashlib
+import hmac
+from collections.abc import Callable
+from pathlib import Path
+
+from .base import BasePtySession, CommandResult
+
+
+def known_hosts_path() -> Path:
+    """asyncssh 默认校验的 known_hosts 文件。"""
+    return Path.home() / ".ssh" / "known_hosts"
+
+
+def _hashed_entry_matches(token: str, wanted: set[str]) -> bool:
+    """HashKnownHosts 条目（|1|盐b64|摘要b64，HMAC-SHA1）是否命中主机名。
+
+    OpenSSH 对盐做 HMAC-SHA1(主机名) 后与摘要比对；主机名候选含
+    host 与 [host]:port 两种形式（调用方拼好放进 wanted）。
+    畸形条目（版本号不符/base64 非法）返回 False，不抛。
+    """
+    parts = token.split("|")
+    if len(parts) != 4 or parts[0] != "" or parts[1] != "1":
+        return False
+    try:
+        salt = base64.b64decode(parts[2], validate=True)
+        digest = base64.b64decode(parts[3], validate=True)
+    except (binascii.Error, ValueError):
+        return False
+    return any(
+        hmac.compare_digest(
+            hmac.new(salt, name.encode("utf-8"), hashlib.sha1).digest(),
+            digest)
+        for name in wanted)
+
+
+def known_hosts_has_entry(path: Path, host: str, port: int | None = None) -> bool:
+    """known_hosts 中是否已有该主机（[host]:port 形式也认）。
+
+    支持哈希条目（HashKnownHosts=yes，|1|盐|摘要）：此前一律视为「无条目」，
+    会让 TOFU 的「已收录但不符 → 硬失败」防线被绕过（对哈希条目库的主机
+    密钥变更误走 TOFU 询问），无头面预检同因假阴性直接 exit 69。
+    """
+    if not path.exists():
+        return False
+    wanted = {host}
+    if port and port != 22:
+        wanted.add(f"[{host}]:{port}")
+    for raw in path.read_text(encoding="utf-8").splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#") or line.startswith("@"):
+            continue
+        token = line.split()[0]
+        if token.startswith("|"):
+            if _hashed_entry_matches(token, wanted):
+                return True
+            continue
+        if wanted & set(token.split(",")):
+            return True
+    return False
+
+
+def format_known_host_line(host: str, port: int | None, key) -> str:
+    """按 OpenSSH known_hosts 格式拼一行（非标准端口用 [host]:port）。"""
+    name = f"[{host}]:{port}" if port and port != 22 else host
+    algorithm = key.algorithm.decode() if isinstance(key.algorithm, bytes) else key.algorithm
+    blob = binascii.b2a_base64(key.public_data).decode().strip()
+    return f"{name} {algorithm} {blob}\n"
+
+
+def _default_host_key_prompt(message: str) -> bool:
+    return input(message).strip().lower() in {"y", "yes"}
+
+
+class SshPtySession(BasePtySession):
+    def __init__(
+        self,
+        host: str,
+        *,
+        username: str | None = None,
+        port: int | None = None,
+        config_files: tuple[str, ...] = ("~/.ssh/config",),
+        rows: int = 40,
+        cols: int = 120,
+        host_key_prompt: Callable[[str], bool] | None = None,
+        password: str | None = None,
+        password_prompt: Callable[[str], str | None] | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.host = host
+        self.username = username
+        self.port = port
+        # password：系统凭据库里的记住密码，先于交互提示尝试；
+        # last_password：本次连接实际使用的密码（连接成功后供 CLI 存回凭据库）
+        self.password = password
+        self.last_password = password
+        self._ask_password = password_prompt or self._default_password_prompt
+        self.config_files = [str(Path(p).expanduser()) for p in config_files]
+        self.rows, self.cols = rows, cols
+        self._ask_host_key = host_key_prompt or _default_host_key_prompt
+        self._conn = None
+        self._proc = None
+        # SFTP 客户端缓存：懒打开；断线重连重建 _conn 后按对象比对自动重开
+        self._sftp = None
+        self._sftp_conn = None
+
+    @staticmethod
+    def _default_password_prompt(label: str) -> str:
+        import getpass
+
+        return getpass.getpass(label)
+
+    async def _maybe_await(self, fn, *args):
+        if asyncio.iscoroutinefunction(fn):
+            return await fn(*args)
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, fn, *args)
+
+    async def _connect_one(self, *, host, username, port, password,
+                           record_last=None):
+        import getpass
+
+        import asyncssh
+
+        kwargs: dict = {"keepalive_interval": 30}
+        if self._config_paths:
+            kwargs["config"] = self._config_paths
+        if username:
+            kwargs["username"] = username
+        if port:
+            kwargs["port"] = port
+        if password:
+            kwargs["password"] = password
+        # 加密私钥口令：保持 getpass（Web 端为已知限制：走服务进程控制台）
+        kwargs["passphrase"] = lambda: getpass.getpass(f"密钥口令 ({host}): ")
+
+        # 密码重试上限：对齐 OpenSSH 默认 NumberOfPasswordPrompts=3——错密后
+        # 前端重讨提示符（Permission denied 行 + 新提示符），三次全错才判失败
+        async def _open(tofu_allowed: bool, tries: int):
+            try:
+                return await asyncssh.connect(host, **kwargs)
+            except asyncssh.PermissionDenied:
+                if tries >= 3:
+                    raise
+                label = f"{(username + '@') if username else ''}{host} 密码: "
+                pw = await self._maybe_await(self._ask_password, label)
+                kwargs["password"] = pw
+                if record_last is not None:
+                    record_last(pw)
+                return await _open(tofu_allowed=True, tries=tries + 1)
+            except asyncssh.HostKeyNotVerifiable:
+                if not tofu_allowed:
+                    raise
+                return await self._trust_unknown_host(host, port, kwargs, _open)
+
+        return await _open(tofu_allowed=True, tries=0)
+
+    def _set_target_password(self, pw: str) -> None:
+        self.last_password = pw
+
+    async def start(self) -> None:
+        self._config_paths = [p for p in self.config_files if Path(p).exists()]
+        # 重连用 last_password：构造时的 password 是旧值/None，现场重输的
+        # 密码只落在 last_password；否则断线重连会重新要密码（见 _recover_connection）
+        self._conn = await self._connect_one(
+            host=self.host, username=self.username, port=self.port,
+            password=self.last_password,
+            record_last=self._set_target_password,
+        )
+        self._proc = await self._conn.create_process(
+            term_type="xterm-256color",
+            # asyncssh term_size 语义是 (width, height)：传 (rows, cols) 会
+            # 把远端 tty 变成 120 行×40 列（stty size 打出 "120 40"），
+            # vim/less 等全屏程序按远端尺寸绘制后又被前端 xterm 折行
+            term_size=(self.cols, self.rows),
+            encoding=None,  # 字节流：stdin/stdout 与 PTY 透传数据均按 bytes 处理
+        )
+        # pwd 探测走 _run_locked（不加锁）：start() 会在 _recover_connection
+        # 内被调用，彼时 _run_lock 已被外层 run() 持有——asyncio.Lock 不可
+        # 重入，再走 run() 会与自身死锁。start() 串行调用，无并发竞争。
+        probe = await self._run_locked("pwd")
+        self.cwd = probe.cwd or ""
+
+    async def _trust_unknown_host(self, host, port, kwargs, open_conn) -> object:
+        """TOFU：未知主机 → 取指纹询问用户 → 接受则写入 known_hosts 并复用连接。
+
+        已有条目却校验失败（主机密钥变更）时硬失败，绝不静默覆盖。
+        """
+        import asyncssh
+
+        kh = known_hosts_path()
+        if known_hosts_has_entry(kh, host, port):
+            raise asyncssh.HostKeyNotVerifiable(
+                f"主机 {host} 密钥与 {kh} 中记录不符（可能是重装系统或中间人），"
+                "请人工核实后手动更新 known_hosts"
+            )
+        # 临时不校验以取得服务器公钥（同时可能完成密码认证，连接直接复用）。
+        # _open 闭包按引用读取 kwargs，因此原地改写即可。
+        saved = dict(kwargs)
+        kwargs.update(known_hosts=None)
+        conn = await open_conn(tofu_allowed=False, tries=0)
+        key = conn.get_server_host_key()
+        algorithm = (
+            key.algorithm.decode() if isinstance(key.algorithm, bytes) else key.algorithm
+        )
+        fp = base64.b64encode(hashlib.sha256(key.public_data).digest()).decode().strip("=")
+        message = (
+            f"主机 {host} 的密钥未知（{algorithm} SHA256:{fp}）。\n"
+            "信任并写入 known_hosts？[y/N]: "
+        )
+        accepted = await self._maybe_await(self._ask_host_key, message)
+        if not accepted:
+            conn.close()
+            raise asyncssh.HostKeyNotVerifiable("用户拒绝信任未知主机密钥")
+        kh.parent.mkdir(parents=True, exist_ok=True)
+        with kh.open("a", encoding="utf-8") as f:
+            f.write(format_known_host_line(host, port, key))
+        # 后续本进程内重连沿用已建立的连接；下次 start() 会重新走默认校验。
+        kwargs.clear()
+        kwargs.update(saved)
+        return conn
+
+    async def _write_raw(self, data: bytes) -> None:
+        if self._proc is None:
+            raise ConnectionError("SSH 进程未启动")
+        self._proc.stdin.write(data)
+        await self._proc.stdin.drain()
+
+    async def _read_some(self, idle_timeout: float) -> bytes:
+        if self._proc is None:
+            raise ConnectionError("SSH 进程未启动")
+        data = await asyncio.wait_for(self._proc.stdout.read(65_536), idle_timeout)
+        if not data:
+            raise EOFError("SSH 通道 EOF")
+        return data
+
+    async def _interrupt(self) -> None:
+        if self._proc is not None:
+            self._proc.stdin.write(b"\x03")
+            await self._proc.stdin.drain()
+
+    async def _recover_connection(self) -> bool:
+        await self.close()
+        for _ in range(1):  # 只自动重连一次
+            try:
+                await self.start()
+                await self._notify_reconnect()
+                return True
+            except Exception:
+                return False
+        return False
+
+    async def _handle_timeout(self) -> CommandResult:
+        # 与 LocalPtySession 的约定对齐（124/130）：超时走重连路径成功时，
+        # 基类返回 _reconnected_result（exit 1）——但会话状态确已丢失、原
+        # 命令未完成，按超时语义改回 124；否则无头消费方会把 exit 1 当
+        # 普通远程失败（命令可能其实没跑完）。
+        result = await super()._handle_timeout()
+        if result.reconnected:
+            return CommandResult(
+                output=f"{result.output}\n\n"
+                       f"[命令在 {self._default_timeout}s 后超时被中断]",
+                exit_code=124, truncated=False, cwd=result.cwd,
+                reconnected=True,
+            )
+        return result
+
+    async def resize(self, rows: int, cols: int) -> None:
+        self.rows, self.cols = rows, cols
+        if self._proc is not None:
+            # asyncssh change_terminal_size 是同步方法（发 window-change 请求）
+            self._proc.change_terminal_size(cols, rows)
+
+    async def send_raw(self, data: bytes) -> None:
+        await self._write_raw(data)
+
+    async def sftp_client(self):
+        """返回可用的 SFTP 客户端（懒打开、按连接缓存）。
+
+        断线重连会重建 self._conn：这里按对象比对失效旧客户端，因此无需
+        侵入 _recover_connection 主流程。文件传输走独立通道，不碰输出泵
+        与哨兵捕获机制。
+        """
+        if self._conn is None:
+            raise RuntimeError("SSH 会话未连接，无法打开 SFTP")
+        if self._sftp is not None and self._sftp_conn is self._conn:
+            return self._sftp
+        if self._sftp is not None:
+            try:
+                self._sftp.exit()
+            except Exception:
+                pass
+        self._sftp = await self._conn.start_sftp_client()
+        self._sftp_conn = self._conn
+        return self._sftp
+
+    async def close(self) -> None:
+        if self._sftp is not None:
+            try:
+                self._sftp.exit()
+            except Exception:
+                pass
+        self._sftp = self._sftp_conn = None
+        if self._proc is not None:
+            try:
+                self._proc.close()
+            except Exception:
+                pass
+        if self._conn is not None:
+            try:
+                self._conn.close()
+            except Exception:
+                pass
+        self._proc = self._conn = None

openterminal/shell/__init__.py

@@ -0,0 +1,17 @@
+"""shell 域（阶段二 Task 13 重组）。
+
+integration.py——shell 集成脚本（bash/zsh/powershell 注入）、exec/探针/
+内部行判别与 StreamRouter 输出分流；cmdset.py——连接后命令集的内联密码
+抽取与 @引用解析。
+本 __init__ 再导出两模块全部公开名，旧 import 路径
+（``from openterminal.shell_integration import ...`` /
+``from openterminal.cmdset import ...``）不因拆包而变。
+"""
+
+from .cmdset import extract_inline_secrets, resolve_answer  # noqa: F401
+from .integration import (  # noqa: F401
+    EXEC_PREFIX, KIND_AI, KIND_CMD, KIND_EXEC, PROBE_TAG, StreamRouter,
+    agent_exec_line, build_script, history_inject_line, history_quiet_line,
+    injection_line, injection_lines, is_internal_line, parse_probe,
+    probe_command, strip_ansi, toggle_line,
+)

openterminal/shell/cmdset.py

@@ -0,0 +1,49 @@
+"""连接后命令集:内联密码抽取与 @引用解析(纯函数,可单测)。
+
+密码永不明文落库:表单里写 `> @名称=密码`,保存时抽取入系统凭据库
+(keyring,键 `cmdset:名称`),落库文本只留 `> @名称` 引用。凭据库
+不可用时静默降级——行照改写、密码丢弃,由 API 层上报 warning。
+"""
+from __future__ import annotations
+
+import re
+
+from ..connections import find_saved_target
+from ..connections.secrets import load_password, store_password
+
+_CMDSET_KEY_PREFIX = "cmdset:"
+# `> @名称=密码`:名称限字母数字_.-,避免把 `> @a b=c` 之类误当引用
+_INLINE_SECRET_RE = re.compile(r"^>\s*@([A-Za-z0-9_.\-]+)\s*=(.*)$")
+
+
+def extract_inline_secrets(text: str) -> tuple[str, list[str]]:
+    """抽取内联密码入 keyring 并改写为引用,返回 (改写文本, 写失败的引用名)。
+
+    CRLF/CR 归一为 LF(Windows 表单粘贴);密码为空串视为纯引用不写库。
+    """
+    out: list[str] = []
+    failed: list[str] = []
+    for line in text.replace("\r\n", "\n").replace("\r", "\n").split("\n"):
+        m = _INLINE_SECRET_RE.match(line.strip())
+        if m is None:
+            out.append(line)
+            continue
+        name, secret = m.group(1), m.group(2).strip()
+        if secret and not store_password(f"{_CMDSET_KEY_PREFIX}{name}",
+                                         None, None, secret):
+            failed.append(name)     # 凭据库缺席:丢弃密码,行照改写
+        out.append(f"> @{name}")
+    return "\n".join(out), failed
+
+
+def resolve_answer(name: str) -> str | None:
+    """@引用 → 应答内容:先命令集命名空间,再已保存主机的记住密码。"""
+    pw = load_password(f"{_CMDSET_KEY_PREFIX}{name}", None, None)
+    if pw:
+        return pw
+    t = find_saved_target(name)
+    if t is not None:
+        pw = load_password(t.host or t.name, t.user, t.port)
+        if pw:
+            return pw
+    return None