ot-cli 0.2.1__py3-none-any.whl

openterminal/core/messages.py

@@ -0,0 +1,193 @@
+"""编排层协议消息与交互式 AI 工具通道（Task 1 自 core.py 原样搬入）。
+
+搬移规则：函数体逐字节不变。_ANSI_RE 原模块有两处定义、后处覆盖前处——
+运行时生效的是连接后命令集段的富版正则，这里只保留富版（行为等价）。
+InteractiveRunner 经 worker 回指 PipelineCore（鸭子类型，无 import 环）。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import time
+from dataclasses import dataclass
+
+from ..shell.integration import agent_exec_line
+from ..session.base import CommandResult
+
+_OT_DBG = bool(os.environ.get("OT_WEB_DEBUG"))
+_OT_T0 = time.monotonic()   # _dbg 相对时间戳基准（轨迹排障用时差分析）
+
+
+def _dbg(*a) -> None:
+    """OT_WEB_DEBUG=1 时打印交互式状态机轨迹（排障用，默认静默）。"""
+    if _OT_DBG:
+        print(f"[otdbg +{time.monotonic() - _OT_T0:7.3f}s]", *a, flush=True)
+
+
+# CSI / OSC / 字符集切换等转义:提示符重绘、PSReadLine 上色都会带上,剥掉才
+# 判得出「提示符在行尾」(见 PipelineCore._cs_text)
+_ANSI_RE = re.compile(
+    r"\x1b\[[0-9;:?]*[A-Za-z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|"
+    r"\x1b[()#][0-9A-Za-z]|\x1b[=>78M]")
+
+
+
+def _ansi_free(s: str) -> str:
+    return _ANSI_RE.sub("", s)
+
+
+class PasswordCancelled(ConnectionError):
+    """终端内联密码输入的 Ctrl+C：用户主动中止连接尝试（区别于连接意外
+    关闭——_run 捕获后向前端发「连接已取消」而非「连接失败：…」）。"""
+
+
+_PROBE_TIMEOUT = 1.5
+#: 工具执行通道不可用的退出码（hook 不在位 / 远端 shell 已退出）
+CHANNEL_DEAD_EC = 126
+#: 通道不可用时随 CommandResult 回给工具卡的可读文案
+CHANNEL_DEAD_MSG = ("远端 shell 已退出或无 AI 集成通道，命令未执行；"
+                    "请重新登录（或回到可集成的 shell）后重试")
+
+
+
+@dataclass
+class ServerMsg:
+    type: str                      # ready | event | approval | ask_password | ask_password_dismiss | ask_host_key | status | closed | usage | cmdset | stage
+    tab_id: str = ""
+    host: str = ""
+    user: str = ""
+    distro: str = ""
+    event: dict | None = None      # 事件：task_start/ai_token/ai_think/ai_collapse/ai_tool/ai_card/final/denied/limit/error；
+                                  # term_open/term_close = 命令执行边界括号（输出归属，见 core/exec_events.py）
+    command: str = ""              # approval：待审批命令
+    reasons: str = ""
+    label: str = ""
+    message: str = ""
+    text: str = ""
+    model: str = ""                # 当前模型 id（ready）
+    models: list[str] | None = None   # 可切换模型列表（ready）
+    prompt: str = ""               # ready：真实提示符纯文本（OSC 133 B 捕获）
+    risk: str = ""                 # 审批风险级（approval）：high 红框 | normal 蓝框
+    id: int = 0                    # approval：关联命令卡 id（ai_tool start 同 id，无卡=0）
+    tokens_in: int = 0             # 会话累计输入 token（usage）
+    tokens_out: int = 0            # 会话累计输出 token（usage）
+    estimated: bool = False        # usage：当前累计为 tiktoken 估算口径（前端加 ≈）
+    interactive: int = 0           # ready：hook 集成就绪（1 = AI 可用）
+    state: str = ""                # cmdset:running | done
+    cmd: str = ""                  # cmdset:running 当前命令原文(应答行为空,防泄密)
+    index: int = 0                 # cmdset 当前行号（1 起；encode_server 省略 0）
+    total: int = 0                 # cmdset 总行数
+    auth_kind: str = ""            # ask_password：省略=主机认证；"cmdset"=命令集密码弹窗
+
+
+@dataclass
+class ClientMsg:
+    type: str                      # raw(键盘字节) | decision | auth | interrupt | mode | resize | change_model | close | submit | pad | boundary_settled | new_session
+    text: str = ""                 # mode: "ssh" | "agent"；auth: 密码文本；submit: 前端拦截的自然语言整行
+    data: bytes = b""              # raw 按键字节（二进制帧整帧直发 PTY）
+    decision: dict | None = None
+    auth_kind: str = ""            # password | password_remember | password_cancel
+                                   # | nested_password(_cancel) | remember_yes/no
+                                   # | host_key | cmdset
+    remember: bool = False         # auth 密码勾选「记住」→ 写入 keyring
+    model: str = ""                # change_model：目标模型 id
+    cols: int = 0
+    rows: int = 0
+    pad: int = 0                   # pad：请求 shell 打印 N 个空行（卡片占位行）
+    mirror: str | None = None      # pad：前端可信的半行镜像（"" = 空半行不必收纳；
+                                   # None = 镜像不可信，worker 走 \x15 丢弃旧路径）
+    dirty: bool = False            # submit：半行缓冲被转义/控制键清过（历史召回
+                                   # 后镜像不可信）→ worker 走 \x03 安全路径不补 \r
+    accept: bool = False           # rescue：失败救援卡决策（true = 交给 AI）
+
+
+class InteractiveRunner:
+    """交互式模式的 AI 工具通道：为 PtyShellBackend 鸭子类型 ShellSession。
+
+    工具命令经 ``__ot_exec__ `` 通道注入同一个 PTY（与用户共享 shell 状态：
+    cd/环境变量/别名全部生效）；Ctrl+U / Ctrl+Y 括号保护用户已输入的半行。
+    输出由泵按 EXEC 相位字节捕获并直写主 xterm，OSC 133 C…D 标记界定结束
+    与退出码。超时发 Ctrl+C 中断再宽限 3s，仍无 D 标记则按 130 返回。
+    """
+
+    def __init__(self, worker: "PipelineCore") -> None:
+        self.w = worker
+        self.cwd = ""
+
+    async def run(self, command: str, *, timeout: int | None = None,
+                  on_output=None) -> CommandResult:
+        # on_output：backend.run 的兼容参数。单管线后命令输出由 exec 状态机
+        # 直写主 xterm，不再经回调旁路转发，这里仅接受不使用。
+        w = self.w
+        to = timeout or w.cfg.shell.timeout_default
+        async with w._runner_lock:
+            if not await w.ai._wait_exec_idle(to):
+                return CommandResult(
+                    output="[ot] 目标 shell 正忙（命令或 AI 执行中），请稍后重试",
+                    exit_code=124, truncated=False, cwd=self.cwd)
+            if not await self._hook_channel_ready():
+                # hook 不在位（TMOUT 登出 / 换壳 / 陈旧）：盲注入会把
+                # __ot_exec__、\x03、__ot_pad 全落进裸壳——command not found
+                # 刷屏，命令本体还被裸壳拆段照常执行（真机截图）。重注入救不
+                # 回就快速失败，工具卡显示可读原因而不是注垃圾进终端后超时 130
+                return CommandResult(
+                    output=CHANNEL_DEAD_MSG, exit_code=CHANNEL_DEAD_EC,
+                    truncated=False, cwd=self.cwd)
+            w._exec_buf = bytearray()
+            w._exec_truncated = False
+            fut = asyncio.get_running_loop().create_future()
+            w._exec_future = fut
+            try:
+                # 不吞回显：注入行的 tty 回显必须原样进 xterm——Windows ConPTY
+                # 按自己的缓冲区模型发绝对光标定位重绘，吞字节会让 xterm 光标
+                # 与 ConPTY 失步（实测提示符叠印/内容覆盖的根因）
+                await w.session.send_raw(b"\x15")     # 收纳用户半行输入
+                await w.session.send_raw(
+                    agent_exec_line(w._shell_kind, command, w._b64flag))
+                try:
+                    res = await asyncio.wait_for(asyncio.shield(fut), to)
+                except asyncio.TimeoutError:
+                    if w.hook._hook_ok():
+                        # hook 不在位时 \x03 也是落进裸壳的垃圾（P2-5）
+                        await w.session.send_raw(b"\x03")  # 中断工具命令
+                    try:
+                        res = await asyncio.wait_for(asyncio.shield(fut), 3.0)
+                    except asyncio.TimeoutError:
+                        res = CommandResult(
+                            output=bytes(w._exec_buf).decode("utf-8", "replace"),
+                            exit_code=130, truncated=False, cwd=self.cwd)
+            finally:
+                w._exec_future = None
+                # \x19 接回 \x15 收走的半行：hook 已把 ^Y 重绑为「恢复注入前
+                # 半行」（存档非空才接回，空行零副作用，不经 kill ring）——
+                # 任务期用户打字与注入交错时打字内容原样接回行首（真机「任务
+                # 跑着打字只剩尾巴」根因）。原生 ^Y 会复活 kill ring 旧内容，
+                # hook 不在位（su - 重置）时不发，保持旧的原生丢弃语义。
+                if w.hook._hook_ok():
+                    await w.session.send_raw(b"\x19")
+            if res.cwd:
+                self.cwd = res.cwd
+            return res
+
+    async def _hook_channel_ready(self) -> bool:
+        """工具注入前的 hook 活性门禁：不在位先试一次重注入自愈。
+
+        须在 _runner_lock 内调用（run 已持有）——_ensure_integrated_locked
+        不取锁，避免与 run / _shell_pad 的注入序列重入死锁。
+        结构性不可集成（_hook_gone＝探测判定换了壳/旧版 shell）不空转注入，
+        保证该路径下 PTY 输入流一个字节都不发。
+        """
+        w = self.w
+        if w.hook._hook_ok():
+            w._hook_seen = True
+            return True
+        if w._hook_gone:
+            return False
+        try:
+            await w.hook._ensure_integrated_locked()
+        except Exception:  # noqa: BLE001 - 重注入失败即通道不可用
+            return False
+        return w.hook._hook_ok()
+

openterminal/core/nested_ssh.py

@@ -0,0 +1,178 @@
+"""嵌套 SSH 帧解析：跳板机/嵌套登录的帧记账与目标解析（Task 2 自
+core.py 原样搬入）。
+
+纯分析、无 I/O；跨域状态经 core 读：_open_cmds/_open_cmd_at（用户命令
+记账，Task 4 归 ExecEvents）、_last_mark_at（hook 活性时间戳，Task 5 归
+HookGate）、_target_host（PipelineCore 自持）。方法名去前导下划线做
+组件公开接口，语义与原 PipelineCore 私有方法一致。
+"""
+
+from __future__ import annotations
+
+import os
+
+from ..connections import parse_user_at_host
+from ..shell.integration import is_internal_line
+
+
+class NestedSshTracker:
+    def __init__(self, core) -> None:
+        self.core = core
+
+    # --- 单行解析（静态方法） ---
+
+    @staticmethod
+    def parse_ssh_cmd_target(line: str
+                              ) -> tuple[str | None, str | None, int | None] | None:
+        """单条命令行解析 ssh 族命令的目标；非 ssh 族返回 None。
+
+        ssh 族但目标解析不出（空行、`ssh` 无目标、别名目标读不到等）
+        返回 (None, None, None)。调用方按各自语义处置：_nested_ssh_target
+        据此向外层帧继续找（既有行为），_ssh_frame_host 跳过本帧找最近的
+        ssh 帧。端口取 dest 的 :port 或 -p/-P/--port= 选项。
+        """
+        import shlex
+
+        try:
+            parts = shlex.split(line)
+        except ValueError:
+            parts = line.split()
+        if not parts:
+            return None, None, None
+        cmd = os.path.basename(parts[0])
+        if cmd not in ("ssh", "scp", "rsync", "sftp"):
+            return None   # 非 ssh 类（sudo/su 等）：不算 ssh 帧
+        val_opts = {"b", "c", "D", "e", "F", "i", "J", "l", "L", "m",
+                    "o", "p", "P", "R", "S", "W"}
+        argv = parts[1:]
+        i = 0
+        dest = None
+        bare_args: list[str] = []
+        while i < len(argv):
+            a = argv[i]
+            if a == "--":
+                i += 1
+                if i < len(argv):
+                    bare_args.append(argv[i])
+                break
+            if a.startswith("-") and len(a) > 1:
+                if a[1] in val_opts and len(a) == 2:
+                    i += 2   # 带值短选项：连值一起跳过
+                else:
+                    i += 1   # 无值开关（-t/-A/-4…）或合写带值（-oVal）
+                continue
+            bare_args.append(a)
+            i += 1
+        if cmd in ("scp", "rsync"):
+            # 源/目的都可能带远端路径：挑带 @ 的（user@host:path），
+            # 其次带 : 的（host:path）；纯本地路径跳过
+            remote = [a for a in bare_args if "@" in a] or \
+                [a for a in bare_args if ":" in a]
+            dest = remote[0] if remote else None
+        else:
+            dest = bare_args[0] if bare_args else None
+        if dest is None:
+            return None, None, None
+        if cmd in ("scp", "rsync") and ":" in dest:
+            dest = dest.rsplit(":", 1)[0]   # 去掉远端路径
+        host, user, port = parse_user_at_host(dest)
+        if port is None:
+            # ssh -p/--port 端口在选项里
+            for j, a in enumerate(argv):
+                if a == "-p" and j + 1 < len(argv) and argv[j + 1].isdigit():
+                    port = int(argv[j + 1])
+                elif a.startswith("--port=") and a[7:].isdigit():
+                    port = int(a[7:])
+                elif a == "-P" and j + 1 < len(argv) and argv[j + 1].isdigit():
+                    port = int(argv[j + 1])
+        return host, user, port
+
+
+    def innermost_ssh_frame(self) -> int | None:
+        """最内层未闭合用户帧若是 ssh 类返回其 inst（嵌套会话存续判定）。"""
+        if not self.core._open_cmds:
+            return None
+        inst = next(reversed(self.core._open_cmds))
+        line = (self.core._open_cmds[inst] or "").strip()
+        if not line or is_internal_line(line):
+            return None
+        if os.path.basename(line.split()[0]) not in ("ssh", "scp", "rsync", "sftp"):
+            return None
+        return inst
+
+
+    def inner_ssh_prompt_live(self) -> bool:
+        """最内层未闭合用户帧是 ssh 类且开帧后出现过提示符标记（= 内层 hook
+        活在 readline 提示符上）：嵌套会话的自然语言放行健康路径。
+
+        _open_cmds 门闩本防 \\r 落进前台命令 stdin（su - 整段会话），但 ssh
+        跳板机帧同样整段开着——一刀切会让嵌套会话里每次自然语言都走降级
+        （\\x03 + 0.4s + 探测 + 分片重注入，秒级，真机「等几秒才出分析卡」
+        根因之一）。su - 帧非 ssh 族仍锁；内层前台命令（top/mysql）会开自己
+        的帧，最内层非 ssh 族亦仍锁；外族 PS1 假标记只随 su - 出现，进不来。"""
+        inst = self.innermost_ssh_frame()
+        if inst is None:
+            return False
+        return self.core._last_mark_at > self.core._open_cmd_at.get(inst, 0.0) + 0.05
+
+
+
+    def nested_ssh_target(self) -> tuple[str | None, str | None, int | None]:
+        """从**最内层**未闭合用户命令行解析 ssh 类命令的目标 (host, user, port)。
+
+        只认最内层帧：嵌套会话里外层 `ssh 跳板机` 帧始终开着，若它兜底
+        吸收了内层 sudo 的密码提示，就会把跳板机的凭据错填给 sudo。
+        解析不出（sudo、ssh 目标是别名走 ~/.ssh/config 等）返回 (None,...)
+        ——密码仍可弹窗代答，只是「记住」没有可靠的键。
+        （单行解析抽在 _parse_ssh_cmd_target；本方法的最内层帧防线不得
+        放宽——外层 ssh 凭据绝不与内层 sudo/嵌套混用。）"""
+        for line in reversed(list(self.core._open_cmds.values())):
+            parsed = self.parse_ssh_cmd_target(line)
+            if parsed is None:
+                return None, None, None   # 最内层不是 ssh 类：不解析
+            host, user, port = parsed
+            if host:
+                return host, user, port
+        return None, None, None
+
+    def ssh_frame_target(self) -> tuple[str | None, str | None, int | None]:
+        """最近一层未闭合 ssh 帧的完整目标 (host, user, port)。
+
+        与 ``nested_ssh_target`` 的「最内层非 ssh 即止」不同：这里**跳过
+        非 ssh 帧向外找**——`ssh B` 之后再 `sudo su -`，终端仍停在 B 上，
+        文件面板要连的就是 B。真机踩过：面板按 nested_ssh_target 取目标，
+        `sudo su -` 一开帧就解析成 None、退回跳板机，用户看到的是跳板机的
+        家目录。凭据代答仍用 nested_ssh_target 的严格语义（防跳板机凭据
+        错填给内层 sudo），两条语义不混用。
+        """
+        for line in reversed(list(self.core._open_cmds.values())):
+            parsed = self.parse_ssh_cmd_target(line)
+            if parsed is not None and parsed[0]:
+                return parsed
+        return None, None, None
+
+    def ssh_frame_host(self) -> str | None:
+        """最内层未闭合 ssh 族命令的目标主机（都解析不出返回 None）。
+
+        跳过非 ssh 帧（sudo/su 自身）向外找最近的 ssh 帧——sudo 就跑在那台机
+        上，是 sudo 凭据键的落名依据（P1-3）。"""
+        return self.ssh_frame_target()[0]
+
+    def sudo_pw_key(self) -> tuple[str, str, int | None] | None:
+        """sudo/su 类无主机提示符的凭据键：(host, "sudo", None) → sudo@host。
+
+        提示符不带 user@host（[sudo] password for user:），凭据归属只有
+        两条线索：最近一层 ssh 帧的目标（sudo 就跑在那台机上；跳板拓扑
+        里命令集 ssh 进内层机再 sudo，会话目标主机反而是跳板），无 ssh
+        帧则会话目标主机（sudo 直接跑在目标机上）。
+
+        user 恒为 "sudo"——sudo 专用命名空间（display_name 拼出
+        ``sudo@host``），绝不与 ssh 登录凭据键（user@host）混用，外层
+        跳板凭据也就不会被错填给内层 sudo（P1-3 不变量）。键按「sudo
+        实际所在主机」命名：同跳板下多台内层机各记各的 sudo 密码，
+        不互相覆盖误填。
+        """
+        host = self.ssh_frame_host() or self.core._target_host or None
+        if not host:
+            return None
+        return (host, "sudo", None)