ot-cli 0.2.1__py3-none-any.whl

openterminal/agent/runner.py

@@ -0,0 +1,340 @@
+"""有界任务执行器：处理流式事件、中断暴露、resume 与轮次预算。
+
+智能体构建（build_agent）、中间件（DenyMiddleware/ToolErrorRetryMiddleware）、
+系统提示词（build_system_prompt）、模型工厂（build_chat_model）已拆出本文件。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import dataclass, field
+from typing import Callable
+
+from langchain_core.messages import AIMessage, ToolMessage
+from langgraph.errors import GraphRecursionError
+
+from .token_est import count_tokens
+from ..core.messages import _dbg
+
+# 任务卡死兜底（astream 自身无超时）：静默到点即中止任务并给前端 error 收尾，
+# 否则「AI 正在思考」永久不收。两档：无在途工具=模型挂起；有=工具没回。
+AGENT_STALL_TIMEOUT = 120.0   # 无在途工具的静默上限(秒)
+AGENT_TOOL_TIMEOUT = 1800.0   # 有在途工具的静默上限(秒)
+
+
+class _Stalled(Exception):
+    """流静默超时：转成 TaskEvent(error) 收尾，不外抛给 core。"""
+
+
+@dataclass
+class TaskEvent:
+    kind: str
+    text: str = ""
+    command: str = ""
+    reasons: list[str] = field(default_factory=list)
+    name: str = ""      # tool_start/tool_end：工具名
+    index: int = 0      # tool_start/tool_end：start/end 配对序号
+    failed: bool = False  # tool_end：ToolMessage status=error
+
+
+def _tool_args_summary(name: str, args: dict) -> str:
+    """工具卡参数摘要：逐工具取关键参数（deepagents 内置文件工具的路径
+    参数名是 file_path），未命中按常见参数名兜底，再取首个非空字符串值。"""
+    keyed = {"read_file": "file_path", "write_file": "file_path",
+             "edit_file": "file_path", "ls": "path", "glob": "pattern",
+             "grep": "pattern", "load_skill": "file_path"}
+    for key in (keyed.get(name), "file_path", "path", "pattern"):
+        v = args.get(key) if key else None
+        if isinstance(v, str) and v:
+            return v[:120]
+    return next((v[:120] for v in args.values() if isinstance(v, str) and v), "")
+
+
+class _ToolClaimIndex:
+    """(name, command) → 有序 seq 队列：审批认领表。
+
+    HITL 的 ActionRequest 不带 tool_call id，无法直接对回工具宣告；
+    同串并行命令（模型一轮发两条同命令）按宣告序消歧——审批按进队序
+    配对到工具卡，不许错位。"""
+
+    def __init__(self) -> None:
+        self._q: dict[tuple[str, str], list[int]] = {}
+
+    def register(self, name: str, command: str, seq: int) -> None:
+        self._q.setdefault((name, command), []).append(seq)
+
+    def claim(self, name: str, command: str) -> int | None:
+        q = self._q.get((name, command))
+        return q.pop(0) if q else None
+
+
+class TaskRunner:
+    """一次用户任务的执行器：处理流式事件、中断暴露、resume 与轮次预算。"""
+
+    def __init__(
+        self, agent, thread_id: str, max_tool_turns: int = 10, *,
+        on_event: Callable[[TaskEvent], None] | None = None,
+    ) -> None:
+        self.agent = agent
+        self.cfg = {"configurable": {"thread_id": thread_id}}
+        self.max_tool_turns = max_tool_turns
+        self.on_event = on_event
+        self.interrupt_payload: dict | None = None
+        self._tool_calls = 0
+        # 非 execute 工具的 start/end 配对记账（前端工具调用小卡）
+        self._tool_seq = 0
+        self._pending_tools: dict[str, tuple[int, str]] = {}
+        self._claims = _ToolClaimIndex()   # 审批认领表（(name,command)→seq 序列）
+        self._tool_seen: set[str] = set()   # 已宣告 tool_call_id（只增不减）
+        self.input_tokens = 0    # 本次任务的累计输入 token（usage_metadata）
+        self.output_tokens = 0   # 本次任务的累计输出 token
+        # 会话栏 token 估算（tiktoken，token_est）：网关不回传 usage_metadata
+        # 时的兜底口径。攒本轮驱动新流入的双向文本，驱动结束一次计价。
+        self.est_input_tokens = 0
+        self.est_output_tokens = 0
+        self._est_in: list[str] = []
+        self._est_out: list[str] = []
+        self._last_progress = time.monotonic()   # 最近一次流片段(静默判据)
+
+    def claim_seq(self, name: str, command: str) -> int | None:
+        """审批认领：(name, command) 按进队序弹出 tool_start 序号（无卡=None）。"""
+        return self._claims.claim(name, command)
+
+    def _add(self, events: list[TaskEvent], ev: TaskEvent) -> None:
+        """live 事件：收集进返回列表的同时实时投递给展示层。"""
+        events.append(ev)
+        if self.on_event is not None:
+            self.on_event(ev)
+
+    def _config(self) -> dict:
+        # 每个模型+工具往返约消耗 2 个 superstep，加固定余量
+        return self.cfg
+
+    async def run(self, text: str) -> list[TaskEvent]:
+        self._est_in.append(text)
+        return await self._drive(
+            {"messages": [{"role": "user", "content": text}]}
+        )
+
+    async def resume(self, decisions: list[dict]) -> list[TaskEvent]:
+        from langgraph.types import Command
+
+        return await self._drive(Command(resume={"decisions": decisions}))
+
+    async def _drive(self, payload) -> list[TaskEvent]:
+        events: list[TaskEvent] = []
+        self.interrupt_payload = None
+        # 偏离计划（最小）：langgraph 1.2.11 中 astream(recursion_limit=...)
+        # 属于已废弃且被静默忽略的 kwarg（实测不会生效，图会跑到默认上限），
+        # 必须写进 config 顶层键才生效；实测每轮模型+工具约耗 3 个 superstep。
+        run_cfg = {**self.cfg, "recursion_limit": self.max_tool_turns * 2 + 4}
+        self._last_progress = time.monotonic()
+        q: asyncio.Queue = asyncio.Queue()
+        _dbg("drive: astream start")
+
+        async def _pump_stream() -> None:
+            try:
+                async for mode, chunk in self.agent.astream(
+                        payload, run_cfg,
+                        stream_mode=["updates", "messages"]):
+                    self._last_progress = time.monotonic()
+                    await q.put(("item", mode, chunk))
+            except asyncio.CancelledError:
+                raise
+            except BaseException as e:  # noqa: BLE001 - 原样交回主循环再抛
+                q.put_nowait(("err", e, None))
+            else:
+                q.put_nowait(("end", None, None))
+
+        feeder = asyncio.create_task(_pump_stream())
+        try:
+            while True:
+                try:
+                    kind, a, b = await asyncio.wait_for(q.get(), 1.0)
+                except asyncio.TimeoutError:
+                    self._check_stall()
+                    continue
+                if kind == "end":
+                    break
+                if kind == "err":
+                    raise a
+                mode, chunk = a, b
+                if mode == "messages":
+                    msg, meta = chunk
+                    if isinstance(msg, AIMessage) and msg.content and \
+                            meta.get("langgraph_node") == "model":
+                        # 思考块与正文分开流式：思考过程实时进前端分析卡
+                        # （中间过程可见），正文继续走 token 通道
+                        think, text = _split_content(msg.content)
+                        if think:
+                            self._est_out.append(think)
+                            self._add(events, TaskEvent("think", think))
+                        if text:
+                            self._est_out.append(text)
+                            self._add(events, TaskEvent("token", text))
+                    # Anthropic 流式在 chunk 的 usage_metadata 里累计
+                    # input/output token，取峰值即为该次调用的完整用量
+                    usage = getattr(msg, "usage_metadata", None) or {}
+                    if usage:
+                        self.input_tokens = max(
+                            self.input_tokens, usage.get("input_tokens") or 0)
+                        self.output_tokens = max(
+                            self.output_tokens, usage.get("output_tokens") or 0)
+                elif mode == "updates":
+                    for node, val in (chunk or {}).items():
+                        for m in val.get("messages", []) if isinstance(val, dict) else []:
+                            await self._absorb(m, node, events)
+        except _Stalled as e:
+            self._flush_est()
+            self._add(events, TaskEvent("error", str(e)))
+            return events
+        except GraphRecursionError:
+            self._flush_est()
+            self._add(events, TaskEvent(
+                "limit",
+                f"已达到工具调用预算（{self.max_tool_turns} 轮），任务停止。"
+                "请缩小目标或换一种问法。",
+            ))
+            return events
+        finally:
+            feeder.cancel()
+        self._flush_est()
+
+        _dbg("drive: astream done, querying state")
+        state = await self.agent.aget_state(self.cfg)
+        _dbg("drive: state queried")
+        for task in state.tasks:
+            if task.interrupts:
+                self.interrupt_payload = task.interrupts[0].value
+                ar = self.interrupt_payload.get("action_requests", [{}])[0]
+                events.append(TaskEvent(
+                    "interrupt", command=ar.get("args", {}).get("command", ""),
+                ))
+        if not self.interrupt_payload:
+            final = self._final_text(state)
+            if final:
+                events.append(TaskEvent("final", final))
+        return events
+
+    def _check_stall(self) -> None:
+        """静默超时判定：到点抛 _Stalled，由 _drive 转 error 事件收尾。
+
+        无在途工具＝卡在模型调用（网关挂起/连接半死），短阈值即可判定；
+        有在途工具＝命令真在跑（长构建合法），给足工具阈值。"""
+        idle = time.monotonic() - self._last_progress
+        if self._pending_tools:
+            if idle > AGENT_TOOL_TIMEOUT:
+                raise _Stalled(
+                    f"工具执行超过 {int(AGENT_TOOL_TIMEOUT)} 秒无响应，任务已中止。"
+                    "可按 ⏹ 中断后缩小命令范围重试。")
+            return
+        if idle > AGENT_STALL_TIMEOUT:
+            raise _Stalled(
+                f"模型超过 {int(AGENT_STALL_TIMEOUT)} 秒无响应，任务已中止。"
+                "请稍后重试，或按 ⏹ 重新提问。")
+
+    def _flush_est(self) -> None:
+        """把本轮驱动攒下的双向文本一次计价（tiktoken 按整段切，边界准确）。"""
+        if self._est_in:
+            self.est_input_tokens += count_tokens("".join(self._est_in))
+            self._est_in = []
+        if self._est_out:
+            self.est_output_tokens += count_tokens("".join(self._est_out))
+            self._est_out = []
+
+    async def _absorb(self, m, node: str, events: list[TaskEvent]) -> None:
+        if isinstance(m, ToolMessage):
+            # 工具结果回灌模型上下文 = 下轮输入 token 的大头（命令输出）
+            self._est_in.append(m.content if isinstance(m.content, str)
+                                else str(m.content))
+            # start/end 按 tool_call_id 配对：execute 也发（远程目标上模型几乎
+            # 只走 execute，不发卡则全程无工具卡可见），命令本体展示仍走
+            # ai_collapse/输出流原生路径，卡片只做状态 Trail
+            pending = self._pending_tools.pop(m.tool_call_id, None)
+            if pending is not None:
+                self._add(events, TaskEvent(
+                    "tool_end", name=pending[1], index=pending[0],
+                    failed=m.status == "error"))
+        if isinstance(m, AIMessage) and m.tool_calls:
+            for tc in m.tool_calls:
+                tid = tc.get("id")
+                # HITL after_model 在 resume 后把同一 AIMessage 回灌 updates 流
+                # （langchain HumanInTheLoopMiddleware.after_model 返回
+                # {"messages": [last_ai_msg, ...]}）——按 tool_call_id 幂等：
+                # 每个调用全任务只宣告一次；跳过时不动 _tool_seq/_pending_tools，
+                # 配对保持指向首次 index，tool_end 才能换徽标回原卡
+                if tid and tid in self._tool_seen:
+                    continue
+                if tid:
+                    self._tool_seen.add(tid)
+                if tc["name"] == "execute":
+                    self._tool_calls += 1
+                    self._add(events, TaskEvent(
+                        "tool_call", command=tc["args"].get("command", "")
+                    ))
+                    self._tool_seq += 1
+                    self._pending_tools[tc["id"]] = (self._tool_seq, "execute")
+                    self._claims.register("execute", tc["args"].get("command", ""),
+                                          self._tool_seq)
+                    self._add(events, TaskEvent(
+                        "tool_start", name="execute",
+                        # 完整 command（不截）：审批关联按串匹配，截 120 字符
+                        # 会让长命令断链（text 仍是 120 字符展示摘要）
+                        command=tc["args"].get("command", ""),
+                        text=tc["args"].get("command", "")[:120],
+                        index=self._tool_seq,
+                    ))
+                else:
+                    self._tool_seq += 1
+                    self._pending_tools[tc["id"]] = (self._tool_seq, tc["name"])
+                    self._claims.register(tc["name"], "", self._tool_seq)
+                    self._add(events, TaskEvent(
+                        "tool_start", name=tc["name"],
+                        text=_tool_args_summary(tc["name"], tc.get("args", {})),
+                        index=self._tool_seq,
+                    ))
+        if isinstance(m, ToolMessage) and m.status == "error" and "安全策略拒绝" in m.content:
+            self._add(events, TaskEvent("denied", text=m.content))
+
+    def _final_text(self, state) -> str:
+        for m in reversed(state.values.get("messages", [])):
+            if isinstance(m, AIMessage) and m.content and not m.tool_calls:
+                return message_text(m)
+        return ""
+
+
+def _split_content(content) -> tuple[str, str]:
+    """消息 content 拆成 (思考, 正文) 两段。
+
+    网关模型的 content 有多种形态（实测 127.0.0.1:15721 网关）：
+    - 字符串：纯正文；
+    - block 列表：[{'type': 'thinking', 'thinking': ...}, {'type': 'text',
+      'text': ...}]（ainvoke/state 消息形态）；
+    - 裸字符串混排列表：['', {'type': 'thinking', ...}, '正文']（astream
+      chunk 合并形态——正文是裸 str 元素而非 text 块）。
+    思考块单独返回，供前端分析卡展示模型的中间过程。
+    """
+    if isinstance(content, str):
+        return "", content
+    thinks: list[str] = []
+    texts: list[str] = []
+    for block in content or []:
+        if isinstance(block, dict):
+            if block.get("type") == "thinking":
+                thinks.append(block.get("thinking", ""))
+            elif block.get("type") == "text":
+                texts.append(block.get("text", ""))
+        elif isinstance(block, str):
+            texts.append(block)
+    return "".join(thinks), "".join(texts)
+
+
+def message_text(msg: AIMessage) -> str:
+    """从 AIMessage 取纯文本正文（思考块不进 final 总结）。"""
+    return _split_content(msg.content)[1]
+
+
+def thinking_text(msg: AIMessage) -> str:
+    """从 AIMessage 取思考过程文本（无则空串）。"""
+    return _split_content(msg.content)[0]

openterminal/agent/sysprobe.py

@@ -0,0 +1,164 @@
+"""目标系统画像：发行版/包管理器/服务管理器/可用工具。"""
+
+from __future__ import annotations
+
+import os
+import sys
+import tomllib
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+
+_DEBIAN_LIKE = {"debian", "ubuntu", "raspbian", "linuxmint", "pop"}
+_RHEL_LIKE = {"centos", "rhel", "fedora", "rocky", "almalinux", "ol", "amzn"}
+
+
+@dataclass
+class SysFacts:
+    os_id: str
+    version_id: str
+    pretty_name: str
+    uname_s: str
+    kernel: str
+    shell: str
+    available: list[str] = field(default_factory=list)
+
+
+@dataclass
+class SystemProfile:
+    host: str
+    os_family: str
+    distro: str
+    version: str
+    kernel: str
+    pkg_manager: str
+    service_mgr: str
+    shell: str
+    tools: dict[str, str] = field(default_factory=dict)
+
+
+# 本地目标的画像：不跑探针（POSIX 探针语句在 PowerShell 下无哨兵输出，
+# 会挂满超时），直接用平台常量。CLI 与 Web worker 共用。
+if sys.platform == "win32":
+    LOCAL_PROFILE = SystemProfile(
+        host="local",
+        os_family="windows", distro="Windows", version="", kernel="",
+        pkg_manager="winget", service_mgr="sc", shell="powershell",
+        tools={},
+    )
+else:
+    LOCAL_PROFILE = SystemProfile(
+        host="local",
+        os_family="darwin" if sys.platform == "darwin" else "linux",
+        distro="Local", version="", kernel="",
+        pkg_manager="brew" if sys.platform == "darwin" else "apt",
+        service_mgr="launchd" if sys.platform == "darwin" else "systemd",
+        shell=os.environ.get("SHELL", "/bin/bash"), tools={},
+    )
+
+
+def profile_from_facts(host: str, f: SysFacts) -> SystemProfile:
+    avail = set(f.available)
+    if f.uname_s == "Darwin":
+        family, pkg, svc = "darwin", "brew", "launchd"
+    elif f.os_id in _DEBIAN_LIKE:
+        family, pkg, svc = "debian", "apt", "systemd"
+    elif f.os_id in _RHEL_LIKE:
+        family = "rhel"
+        # RHEL8+/Fedora/Rocky/Alma 默认 dnf；CentOS 7 只有 yum
+        pkg = "dnf" if "dnf" in avail else ("yum" if "yum" in avail else "dnf")
+        if f.os_id == "centos" and f.version_id.startswith("7"):
+            pkg = "yum"
+        svc = "systemd"
+    elif f.os_id == "alpine":
+        family, pkg, svc = "alpine", "apk", "openrc"
+    elif f.os_id in {"arch", "manjaro"}:
+        family, pkg, svc = "arch", "pacman", "systemd"
+    elif "suse" in f.os_id:
+        family, pkg, svc = "suse", "zypper", "systemd"
+    else:
+        family, pkg, svc = "unknown", "yum" if "yum" in avail else "apt", "systemd"
+
+    tools: dict[str, str] = {}
+    for t in ("python3", "python", "docker", "node", "git", "make"):
+        if t in avail:
+            tools[t] = "yes"
+    return SystemProfile(
+        host=host, os_family=family,
+        distro=f.pretty_name or f.os_id, version=f.version_id,
+        kernel=f.kernel, pkg_manager=pkg, service_mgr=svc,
+        shell=f.shell, tools=tools,
+    )
+
+
+MANUAL_PRESETS: dict[str, dict] = {
+    "ubuntu": {"os_family": "debian", "pkg_manager": "apt", "service_mgr": "systemd"},
+    "debian": {"os_family": "debian", "pkg_manager": "apt", "service_mgr": "systemd"},
+    "centos7": {"os_family": "rhel", "pkg_manager": "yum", "service_mgr": "systemd"},
+    "rocky9": {"os_family": "rhel", "pkg_manager": "dnf", "service_mgr": "systemd"},
+    "alpine": {"os_family": "alpine", "pkg_manager": "apk", "service_mgr": "openrc"},
+    "arch": {"os_family": "arch", "pkg_manager": "pacman", "service_mgr": "systemd"},
+    "macos": {"os_family": "darwin", "pkg_manager": "brew", "service_mgr": "launchd"},
+}
+
+
+_PROBE_STATEMENTS = [
+    "[ -r /etc/os-release ] && . /etc/os-release || true",
+    "printf '%s\\n' \"${ID:-}\" \"${VERSION_ID:-}\" \"${PRETTY_NAME:-}\"",
+    "uname -s",
+    "uname -r",
+    "printf '%s\\n' \"${SHELL:-}\"",
+    "for c in apt-get dnf yum apk pacman zypper brew systemctl docker python3 "
+    "python node git make; do command -v \"$c\" >/dev/null 2>&1 && echo \"$c\"; done",
+    "printf '%s\\n' \"__OT_PROBE_DONE__\"",
+]
+
+
+async def probe_profile(session, host: str) -> SystemProfile:
+    """在会话上执行探测命令并解析为 SystemProfile。"""
+    # 必须用 '; ' 连接：每条都是完整语句，拼成单行（不能用空格，否则上一条
+    # 会把下一条当成自己的参数，整句语法错误导致哨兵不打印、run 超时）。
+    res = await session.run("; ".join(_PROBE_STATEMENTS))
+    lines = [l.strip() for l in res.output.splitlines()]
+    if "__OT_PROBE_DONE__" in lines:
+        lines = lines[: lines.index("__OT_PROBE_DONE__")]
+    # 字段：os_id / version / pretty / uname_s / kernel / shell / tools...
+    def get(i: int) -> str:
+        return lines[i] if i < len(lines) else ""
+    facts = SysFacts(
+        os_id=get(0), version_id=get(1), pretty_name=get(2),
+        uname_s=get(3), kernel=get(4), shell=get(5),
+        available=lines[6:],
+    )
+    if facts.uname_s == "":
+        facts.uname_s = "Linux"
+    return profile_from_facts(host, facts)
+
+
+def _toml_escape(v: str) -> str:
+    return v.replace("\\", "\\\\").replace('"', '\\"')
+
+
+def save_host_cache(path: Path, host: str, p: SystemProfile) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    block = ["\n[hosts.{}]".format(host.replace(".", "_")),
+             f'host = "{_toml_escape(host)}"']
+    for k, v in asdict(p).items():
+        # host 已显式写入；tools 不进缓存（均跳过，避免 TOML 键重复）
+        if k in ("tools", "host"):
+            continue
+        block.append(f'{k} = "{_toml_escape(str(v))}"')
+    block.append("")
+    with path.open("a", encoding="utf-8") as f:
+        f.write("\n".join(block))
+
+
+def load_host_cache(path: Path) -> dict[str, SystemProfile]:
+    if not path.exists():
+        return {}
+    data = tomllib.loads(path.read_text(encoding="utf-8"))
+    out: dict[str, SystemProfile] = {}
+    for _table, m in data.get("hosts", {}).items():
+        host = m.get("host", _table)
+        out[host] = SystemProfile(host=host, tools={}, **{k: v for k, v in m.items()
+                                                          if k != "host"})
+    return out

openterminal/agent/token_est.py

@@ -0,0 +1,49 @@
+"""tiktoken 本地 token 估算：状态栏「本次会话消耗」的兜底口径。
+
+真实 usage_metadata 只在模型网关回传时可得；本地代理/第三方聚合网关经常
+不回传，此时按 tiktoken 对「我们能看到的双向文本」（任务文本+工具输出 ↔
+思考+正文）估算。BPE 词表首次使用需联网下载，之后走 TIKTOKEN_CACHE_DIR
+本地缓存（落在应用数据目录，离线可用）；tiktoken 未安装或词表不可得时
+退化为字符启发式——估算绝不能打死主流程。
+"""
+import os
+
+from ..config import app_dir
+
+os.environ.setdefault("TIKTOKEN_CACHE_DIR", str(app_dir() / "tiktoken_cache"))
+
+_enc = None
+_enc_failed = False
+
+
+def _encoding():
+    """懒加载 cl100k_base 编码器；不可用返回 None（进程内只试一次）。"""
+    global _enc, _enc_failed
+    if _enc is not None:
+        return _enc
+    if _enc_failed:
+        return None
+    try:
+        import tiktoken
+        _enc = tiktoken.get_encoding("cl100k_base")
+    except Exception:            # noqa: BLE001 - 未安装/离线无词表：退化启发式
+        _enc_failed = True
+        _enc = None
+    return _enc
+
+
+def count_tokens(text: str) -> int:
+    """文本 → token 数（估算口径）。"""
+    if not text:
+        return 0
+    enc = _encoding()
+    if enc is not None:
+        try:
+            # disallowed_special=()：正文里的 "<|...|>" 形态按普通文本计价，
+            # 不当特殊 token 抛错
+            return len(enc.encode(text, disallowed_special=()))
+        except Exception:        # noqa: BLE001 - 编码失败走启发式
+            pass
+    cjk = sum(1 for ch in text if "一" <= ch <= "鿿")
+    other = len(text) - cjk
+    return max(1, int(cjk * 1.6) + (other + 3) // 4)

openterminal/app.py

@@ -0,0 +1,52 @@
+"""ot / openterminal 入口。"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+from .config import Config, app_dir
+
+
+def main() -> None:
+    for p in (Path.cwd() / ".env", app_dir() / ".env"):
+        if p.exists():
+            load_dotenv(p)
+    cfg = Config.load()
+    # ot web [--host X] [--port N] [--token T] [--no-open]
+    if len(sys.argv) >= 2 and sys.argv[1] == "web":
+        from .web.server import run_web
+
+        run_web(cfg, argv=sys.argv[2:])
+        return
+    # ot exec -t <目标> -c <命令> / ot list targets —— 无头执行面（headless.py）
+    # 输出要保持纯净供脚本消费，不打印欢迎横幅
+    if len(sys.argv) >= 2 and sys.argv[1] in {"exec", "list"}:
+        from .frontend.headless import run_headless
+
+        raise SystemExit(run_headless(sys.argv[1:], cfg=cfg))
+    from .frontend.banner import print_banner
+
+    print_banner()
+    # ot connect <ssh配置别名> / ot ssh user@host:port
+    initial = None
+    if len(sys.argv) >= 3 and sys.argv[1] in {"connect", "ssh"}:
+        initial = sys.argv[2]
+    # 无目标参数 → 启动选择框（local / 记住的连接 / 添加新连接）
+    # Cli 惰性导入：cli→term_frontend→core 链很重，只有交互 CLI 分支才需要；
+    # `ot list`/`ot exec`/`ot web` 走上面的早返回，不该付这份导入成本。
+    from .cli import Cli
+
+    cli = Cli(cfg, initial_target=initial)
+    try:
+        asyncio.run(cli.loop())
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

openterminal/approval.py

@@ -0,0 +1,7 @@
+"""旧路径壳（阶段二 Task 15）：实现已迁至 frontend/approval.py。"""
+
+from .frontend.approval import *  # noqa: F401,F403
+from .frontend import approval as _impl  # noqa: F401
+
+def __getattr__(name):
+    return getattr(_impl, name)

openterminal/backend.py

@@ -0,0 +1,3 @@
+"""旧路径壳（阶段二 Task 14）：实现已迁至 agent/backend.py。"""
+
+from .agent.backend import PtyShellBackend  # noqa: F401

openterminal/banner.py

@@ -0,0 +1,7 @@
+"""旧路径壳（阶段二 Task 15）：实现已迁至 frontend/banner.py。"""
+
+from .frontend.banner import *  # noqa: F401,F403
+from .frontend import banner as _impl  # noqa: F401
+
+def __getattr__(name):
+    return getattr(_impl, name)