@xiaoqiong0v0/opencode-ssh-tool 0.4.0 → 0.5.0

package/README.md

@@ -4,7 +4,7 @@ opencode 插件：让 opencode 像人一样操作**长驻交互式终端会话**
 
 ## 特性
 
-- **长驻会话**：`ssh_cli connect` 建立连接后，`ssh_cli exec` 在同一会话执行命令，保留 cwd/环境/后台进程/sudo 缓存
+- **长驻会话**：`term_cli connect` 建立连接后，`term_cli exec` 在同一会话执行命令，保留 cwd/环境/后台进程/sudo 缓存
 - **PTY 交互**：分配伪终端，可处理 sudo 密码、vi、top 等交互程序
 - **权限管控**：只读白名单直接放行、危险命令黑名单硬拒、其余走 `context.ask()` 用户审批
 - **命令完成判定**：哨兵标记 + 静默窗口 + 超时三重兜底，动画输出（进度条等）自动识别
@@ -27,17 +27,17 @@ opencode 插件：让 opencode 像人一样操作**长驻交互式终端会话**
 
 | 工具 | 入参 | 行为 |
 |---|---|---|
-| `ssh_cli` | `args`（完整命令行字符串） | **CLI 风格单工具**：SSH / 本地 / 容器终端会话。子命令：`connect` / `local` / `exec` / `read` / `send` / `status` / `disconnect` / `help`；用 `help` 查看完整用法 |
+| `term_cli` | `args`（完整命令行字符串） | **CLI 风格单工具**：SSH / 本地 / 容器终端会话。子命令：`connect` / `local` / `exec` / `read` / `send` / `status` / `disconnect` / `help`；用 `help` 查看完整用法 |
 
 ```text
-ssh_cli connect root@host:22 [-n name] [-p password|file:path]   # SSH 连接
-ssh_cli local "pwsh|docker exec -it <容器> sh" [-n name] [-c cwd] # 本地/容器终端
-ssh_cli exec "<command>" [-n name] [-w]                          # 执行命令
-ssh_cli read [-n name] [-s buffer|history] [-l limit] [--head]   # 读输出
-ssh_cli send "<text>" [-n name]                                  # 发送按键（sudo 密码等）
-ssh_cli status [-n name]                                         # 状态
-ssh_cli disconnect [-n name]                                     # 断开
-ssh_cli help                                                     # 完整用法
+term_cli connect root@host:22 [-n name] [-p password|file:path]   # SSH 连接
+term_cli local "pwsh|docker exec -it <容器> sh" [-n name] [-c cwd] # 本地/容器终端
+term_cli exec "<command>" [-n name] [-w]                          # 执行命令
+term_cli read [-n name] [-s buffer|history] [-l limit] [--head]   # 读输出
+term_cli send "<text>" [-n name]                                  # 发送按键（sudo 密码等）
+term_cli status [-n name]                                         # 状态
+term_cli disconnect [-n name]                                     # 断开
+term_cli help                                                     # 完整用法
 ```
 
 > 一个 opencode 会话可创建**多个命名终端**（如 `db`、`web`、`prod`），用不同 `name` 并行维护；同名重复创建会先关闭旧的。工具只暴露一个 `args` 字符串参数，模型像敲命令行一样调用，`help` 引导其学会所有用法（单工具多命令模式，省 token）。
@@ -92,7 +92,7 @@ ssh_cli help                                                     # 完整用法
 3. **环境变量密码**：`SSH_PASS_<HOST大写>` 优先，回退 `SSH_PASSWORD`
 
 > [!WARNING] 风险警告
-> `ssh_cli connect` 的 `password` 参数（明文或 `file:` 路径）允许模型直接凭密码建立连接，**绕过密钥认证，一旦建立便无法像正常会话那样可靠授权与撤销**——远程主机上的命令操作难以被 opencode 权限系统有效管控。
+> `term_cli connect` 的 `password` 参数（明文或 `file:` 路径）允许模型直接凭密码建立连接，**绕过密钥认证，一旦建立便无法像正常会话那样可靠授权与撤销**——远程主机上的命令操作难以被 opencode 权限系统有效管控。
 >
 > **最佳用途**：仅用于一次性**辅助安装 opencode 到远程目标**（bootstrap），或完全可信的临时环境。
 >
@@ -101,7 +101,7 @@ ssh_cli help                                                     # 完整用法
 ## 权限管控
 
 ```text
-ssh_cli exec(command)
+term_cli exec(command)
   ├─ 命中 DENY 黑名单（rm -rf / shutdown reboot mkfs 等） → 直接拒绝
   ├─ 命中只读白名单 且 无 shell 元字符 → 直接放行
   └─ 其他 → context.ask() 用户审批（:allow / :deny / :always）
@@ -109,11 +109,11 @@ ssh_cli exec(command)
 
 - 只读白名单：`ls|cd|cat|grep|tail|head|ps|df|free|pwd|env|echo|curl|wget|git status|whoami|hostname|date|uname|uptime`
 - 命令含 `;` `&&` `|` `$()` 等 shell 元字符 → 降级走 ask（防拼接绕过）
-- 高危命令不进 ask 直接拒，`ssh_cli connect` 也走审批
+- 高危命令不进 ask 直接拒，`term_cli connect` 也走审批
 
 ## HTTP 终端查看
 
-服务默认开启（配置 `server.enabled`）。`ssh_cli status` / `ssh_cli read`（history 模式）会返回实际地址（端口 0 时自动分配，避免冲突）：
+服务默认开启（配置 `server.enabled`）。`term_cli status` / `term_cli read`（history 模式）会返回实际地址（端口 0 时自动分配，避免冲突）：
 
 ```
 浏览器访问 http://127.0.0.1:<port> 查看可滚动、每 2s 自动刷新的终端记录
@@ -155,16 +155,16 @@ npm publish      # 只发布 dist/
 
 需真实 SSH 主机（可用 Docker 测试环境，见 `.tmp/ssh-test-docker.ps1`）：
 
-- [ ] `ssh_cli connect` → 登录成功，cwd 为登录目录
-- [ ] `ssh_cli exec("ls")` 连续多次，确认永不重连（同一会话）
-- [ ] `ssh_cli exec("cd /var/log && pwd")` 后 `ssh_cli exec("pwd")` = `/var/log`（目录保持）
-- [ ] 交互场景：`ssh_cli exec("sudo ...")` 触发密码提示 → `ssh_cli read` 配合
+- [ ] `term_cli connect` → 登录成功，cwd 为登录目录
+- [ ] `term_cli exec("ls")` 连续多次，确认永不重连（同一会话）
+- [ ] `term_cli exec("cd /var/log && pwd")` 后 `term_cli exec("pwd")` = `/var/log`（目录保持）
+- [ ] 交互场景：`term_cli exec("sudo ...")` 触发密码提示 → `term_cli read` 配合
 - [ ] 白名单命令不弹审批直接执行；`rm -rf` 被拒绝
 - [ ] 白名单外命令弹 `context.ask()`，`:deny` 拒绝 / `:allow` 放行
-- [ ] 长命令超时：`ssh_cli exec("sleep 60")` 30s 超时返回，不挂死会话
-- [ ] `ssh_cli read` 取前/后 N 条历史输出（含 `includeCommand`、`source=buffer`）
-- [ ] `ssh_cli status` / HTTP 页面浏览器可访问
-- [ ] `ssh_cli disconnect` 后连接释放
+- [ ] 长命令超时：`term_cli exec("sleep 60")` 30s 超时返回，不挂死会话
+- [ ] `term_cli read` 取前/后 N 条历史输出（含 `includeCommand`、`source=buffer`）
+- [ ] `term_cli status` / HTTP 页面浏览器可访问
+- [ ] `term_cli disconnect` 后连接释放
 
 ## 文档
 

package/dist/base-session.d.ts

@@ -0,0 +1,128 @@
+import { SessionHistory } from "./history.js";
+import { type ShellAdapter } from "./shell-adapter.js";
+/** 命令执行结果 */
+export interface ExecResult {
+    ok: boolean;
+    output: string;
+    interactive?: boolean;
+    running?: boolean;
+    submitted?: boolean;
+    error?: string;
+    host?: string;
+    command?: string;
+    duration?: number;
+}
+/** 会话命令执行与读取的公共实现 */
+export declare abstract class BaseSession {
+    protected readonly sessionID: string;
+    protected readonly name: string;
+    protected _connected: boolean;
+    protected _remoteBusy: boolean;
+    protected _buffer: string;
+    protected _connectedAt: number;
+    protected _lastActive: number;
+    protected _runningStartPos: number | null;
+    protected _runningCommand: string;
+    protected _watchTimer: ReturnType<typeof setInterval> | null;
+    /** 下次捕获窗口起点（相对当前 buffer）：前一条命令结束后，标记/残留从此处开始 */
+    protected _cursor: number;
+    /** WS 实时流已发送位置（相对 buffer 偏移）；null = 尚未定位命令回显结束点 */
+    protected _streamPos: number | null;
+    /** Shell 适配器（探测后确定） */
+    protected _adapter: ShellAdapter | null;
+    protected _closed: boolean;
+    /** 当前运行命令的输入时刻（history 记录展示命令发起时间用） */
+    private _runningStartTs;
+    /** 连续原始字节流（从首字节起累积，含欢迎页/探测/注入/提示符/marker）；ring 裁剪 */
+    private _rawLog;
+    /** 已裁剪丢弃的字符数（前端 pos 同步用） */
+    private _rawDiscarded;
+    /** 累积原始字节总数（单调递增，前端增量游标） */
+    private _rawTotal;
+    protected readonly _history: SessionHistory;
+    constructor(sessionID: string, history: SessionHistory, name?: string);
+    /** 向传输层写入字节（子类实现：SSH 写 stream / 本地写 Bun.Terminal） */
+    protected abstract _write(data: string): void;
+    /** 关闭传输层资源（子类实现：SSH 关 client+stream / 本地关 term+proc） */
+    protected abstract _closeTransport(): void;
+    /** 结果中的类型专属字段（SSH 附加 host，本地为空） */
+    protected get _extraResult(): Partial<ExecResult>;
+    /** 忙碌提示中的状态命令名（ssh_status / local_status） */
+    protected abstract _statusCmd: string;
+    /**
+     * 异步提交命令：立即返回，命令后台执行，输出由后台监听收集进 history
+     * @param command 命令
+     * @returns 提交结果（立即返回，不等待命令完成）
+     */
+    submit(command: string): Promise<ExecResult>;
+    /**
+     * 在当前终端执行命令（同步等待），保留 cwd/环境
+     * @param command 命令
+     * @returns 执行结果
+     */
+    exec(command: string): Promise<ExecResult>;
+    /**
+     * 读取并清空未消费缓冲（交互/轮询场景）
+     * @returns 未消费输出
+     */
+    readBuffer(): Promise<{
+        ok: boolean;
+        output: string;
+        error?: string;
+    }>;
+    /**
+     * 发送文本/按键到终端（交互场景：sudo 密码、确认、中断等）
+     * 转义序列：\r 或 \n = 回车，\x03 = Ctrl-C，\x04 = Ctrl-D，\x1a = Ctrl-Z，\x1b = ESC
+     * @param text 要发送的文本或按键序列
+     * @returns 是否发送成功
+     */
+    send(text: string): {
+        ok: boolean;
+        error?: string;
+    };
+    getHistory(): SessionHistory;
+    getRunningOutput(): string;
+    getRunningCommand(): string;
+    hasRunningStream(): boolean;
+    /**
+     * 增量取运行中命令的实时输出（WS 推流用）：
+     * 首次定位命令回显结束点，后续返回增量；done 标记出现 → 返回剩余 + done
+     * @returns data 本次增量；done 命令已完成
+     */
+    getRunningStream(): {
+        data: string;
+        done: boolean;
+    };
+    /** 关闭终端，清理会话态（幂等） */
+    close(): void;
+    /** 增量读取连续原始字节流：返回自 pos 之后的新增字节 */
+    readRawStream(pos: number): {
+        data: string;
+        pos: number;
+        reset?: boolean;
+    };
+    /** 是否连接且传输层就绪（子类检查自身传输对象） */
+    protected abstract _ready(): boolean;
+    /** 命令执行/提交前准备：裁剪已消费缓冲 + 丢弃上一条命令的迟到残留标记 */
+    private _beginCapture;
+    /** 追加输出字节：维护业务缓冲 + 连续原始流 ring */
+    protected _appendBuffer(text: string): void;
+    /** 探测 shell 类型：deadline 内循环发送探测命令并解析输出（shell 慢启动时也能等到就绪） */
+    protected _probeShell(deadline: number): Promise<ShellAdapter | null>;
+    /** 等待探测输出稳定：buffer 有内容且 500ms 不再变化则返回，超时返回 null */
+    private _waitProbeOutput;
+    /**
+   * deadline 内循环注入+等待确认，成功返回 true，超时返回 false
+   * 逐行发送避免因 shell 未就绪导致的整块丢失；每轮等待最大 3s
+   * 注入命令原样回显（不抑制），确认以 echo 唯一标识为准，避免与后续命令时序混淆
+   */
+    protected _injectAndSettle(deadline: number): Promise<boolean>;
+    /** 等待缓冲中出现指定文本（最多 maxMs） */
+    private _waitForBufferToken;
+    private _waitCompletion;
+    /** 后台监听：轮询 done 标记 → 收集输出进 history + busy=false */
+    private _startBackgroundWatch;
+    protected _clearRunningContext(): void;
+    private _truncate;
+}
+//# sourceMappingURL=base-session.d.ts.map

package/dist/base-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-session.d.ts","sourceRoot":"","sources":["../src/base-session.ts"],"names":[],"mappings":"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"}

package/dist/base-session.js

@@ -0,0 +1,414 @@
+// BaseSession：SSH(SshSession) 与本地(LocalSession) 终端的公共基类
+// 统一完成标记法：注入 PROMPT_COMMAND 脚本，命令完成时输出 <SSH_DONE:退出码>
+// 子类仅需实现：连接建立(connect)、数据写入(_write)、传输层清理(_closeTransport)、状态字段(getStatus)
+import { ANIMATION_WINDOW_MS, MAX_OUTPUT_LEN, RAW_LOG_MAX, SETTLE_TIMEOUT_MS, } from "./constants.js";
+import log from "./log.js";
+import { SessionHistory } from "./history.js";
+import { toModelText, extractOutputStart, extractOutput } from "./utils.js";
+import { findLastEndOf } from "./last-match.js";
+import { detectLastDoneMarker, stripMarkers, resolveByProbe } from "./shell-adapter.js";
+/** 交互触发词（sudo 密码 / 分页器 / 确认提示），含中英文 */
+const INTERACTIVE_RE = /(\[sudo\] password for|password for \S+:|Password:|密码:|--More--|\(END\)|\[y\/N\]|\[Y\/n\]|yes\/no|是\/否)/i;
+/** buffer 最大长度（未消费输出超限时截断头部，防内存膨胀） */
+const MAX_BUFFER_LEN = 2 * 1024 * 1024;
+/** 后台监听最长存活时间（防泄漏） */
+const MAX_WATCH_LEN = 10 * 60_000;
+/** Shell 探测等待超时 */
+const PROBE_TIMEOUT_MS = 5_000;
+/** 会话命令执行与读取的公共实现 */
+export class BaseSession {
+    sessionID;
+    name;
+    _connected = false;
+    _remoteBusy = false;
+    _buffer = "";
+    _connectedAt = 0;
+    _lastActive = 0;
+    _runningStartPos = null;
+    _runningCommand = "";
+    _watchTimer = null;
+    /** 下次捕获窗口起点（相对当前 buffer）：前一条命令结束后，标记/残留从此处开始 */
+    _cursor = 0;
+    /** WS 实时流已发送位置（相对 buffer 偏移）；null = 尚未定位命令回显结束点 */
+    _streamPos = null;
+    /** Shell 适配器（探测后确定） */
+    _adapter = null;
+    _closed = false;
+    /** 当前运行命令的输入时刻（history 记录展示命令发起时间用） */
+    _runningStartTs = 0;
+    /** 连续原始字节流（从首字节起累积，含欢迎页/探测/注入/提示符/marker）；ring 裁剪 */
+    _rawLog = "";
+    /** 已裁剪丢弃的字符数（前端 pos 同步用） */
+    _rawDiscarded = 0;
+    /** 累积原始字节总数（单调递增，前端增量游标） */
+    _rawTotal = 0;
+    _history;
+    constructor(sessionID, history, name = "default") {
+        this.sessionID = sessionID;
+        this.name = name;
+        this._history = history;
+    }
+    /** 结果中的类型专属字段（SSH 附加 host，本地为空） */
+    get _extraResult() { return {}; }
+    /**
+     * 异步提交命令：立即返回，命令后台执行，输出由后台监听收集进 history
+     * @param command 命令
+     * @returns 提交结果（立即返回，不等待命令完成）
+     */
+    async submit(command) {
+        if (!this._ready())
+            return { ok: false, output: "", error: "Not connected" };
+        if (this._remoteBusy)
+            return { ok: false, output: "", error: `Previous command still running, poll with ${this._statusCmd} first` };
+        this._beginCapture(command);
+        this._write(command + "\r");
+        this._startBackgroundWatch(0, command);
+        return { ok: true, output: "", submitted: true, command, duration: 0, ...this._extraResult };
+    }
+    /**
+     * 在当前终端执行命令（同步等待），保留 cwd/环境
+     * @param command 命令
+     * @returns 执行结果
+     */
+    async exec(command) {
+        const startTs = Date.now();
+        if (!this._ready())
+            return { ok: false, output: "", error: "Not connected" };
+        if (this._remoteBusy)
+            return { ok: false, output: "", error: `Previous command still running, poll with ${this._statusCmd} first` };
+        this._beginCapture(command);
+        const captureStart = this._buffer.length;
+        this._write(command + "\r");
+        const outcome = await this._waitCompletion(0, startTs);
+        switch (outcome.kind) {
+            case "done": {
+                this._remoteBusy = false;
+                const raw = this._buffer.slice(captureStart, outcome.markerPos ?? this._buffer.length);
+                this._cursor = Math.max(0, outcome.markerPos ?? this._buffer.length);
+                this._history.append(command, extractOutput(raw, command), this._runningStartTs, Date.now());
+                this._clearRunningContext();
+                return { ok: true, output: this._truncate(toModelText(extractOutput(raw, command))), command, duration: Date.now() - startTs, ...this._extraResult };
+            }
+            case "interactive": {
+                this._remoteBusy = false;
+                const raw = this._buffer.slice(captureStart);
+                this._cursor = this._buffer.length;
+                this._history.append(command, raw, this._runningStartTs, Date.now());
+                this._clearRunningContext();
+                return { ok: true, output: this._truncate(toModelText(extractOutput(raw, command))), interactive: true, command, duration: Date.now() - startTs, ...this._extraResult };
+            }
+            case "running": {
+                this._runningStartPos = 0;
+                this._remoteBusy = true;
+                this._cursor = this._buffer.length;
+                this._startBackgroundWatch(captureStart, command);
+                // 等待后台 watch 完成（不设硬超时，模型可通过 Ctrl-C 中断）
+                await new Promise((resolve) => {
+                    const poll = setInterval(() => {
+                        if (!this._remoteBusy) {
+                            clearInterval(poll);
+                            resolve();
+                        }
+                    }, 200);
+                });
+                // watch 已写入 history，取最后一条记录的输出
+                const pairs = this._history.getPairs();
+                const last = pairs[pairs.length - 1];
+                const output = last ? this._truncate(toModelText(stripMarkers(this._history.readOutput(last)))) : "";
+                return { ok: true, output, command, duration: Date.now() - startTs, ...this._extraResult };
+            }
+        }
+    }
+    /**
+     * 读取并清空未消费缓冲（交互/轮询场景）
+     * @returns 未消费输出
+     */
+    async readBuffer() {
+        if (!this._connected)
+            return { ok: false, output: "", error: "Not connected" };
+        let out;
+        if (this._runningStartPos !== null && this._runningCommand) {
+            const end = extractOutputStart(this._buffer.slice(this._runningStartPos), this._runningCommand);
+            const marker = end > 0
+                ? detectLastDoneMarker(this._buffer, this._runningStartPos + end)
+                : { done: false, exitCode: 0, pos: 0 };
+            if (marker.done) {
+                const raw = this._buffer.slice(this._runningStartPos, marker.pos);
+                this._buffer = this._buffer.slice(marker.pos);
+                this._cursor = 0;
+                this._clearRunningContext();
+                out = raw;
+            }
+            else {
+                out = this._buffer.slice(this._runningStartPos);
+            }
+        }
+        else {
+            out = this._buffer;
+            this._buffer = "";
+            this._cursor = 0;
+        }
+        return { ok: true, output: this._truncate(toModelText(out)) };
+    }
+    /**
+     * 发送文本/按键到终端（交互场景：sudo 密码、确认、中断等）
+     * 转义序列：\r 或 \n = 回车，\x03 = Ctrl-C，\x04 = Ctrl-D，\x1a = Ctrl-Z，\x1b = ESC
+     * @param text 要发送的文本或按键序列
+     * @returns 是否发送成功
+     */
+    send(text) {
+        if (!this._connected)
+            return { ok: false, error: "Not connected" };
+        const payload = text
+            .replace(/\\x1b/gi, "\x1b")
+            .replace(/\\x03/gi, "\x03")
+            .replace(/\\x04/gi, "\x04")
+            .replace(/\\x1a/gi, "\x1a")
+            .replace(/\\r/g, "\r")
+            .replace(/\\n/g, "\r");
+        this._write(payload);
+        this._lastActive = Date.now();
+        return { ok: true };
+    }
+    getHistory() { return this._history; }
+    getRunningOutput() {
+        if (this._runningStartPos === null || !this._connected || !this._runningCommand)
+            return "";
+        return this._buffer.slice(this._runningStartPos);
+    }
+    getRunningCommand() {
+        return this._runningStartPos !== null && this._connected ? this._runningCommand : "";
+    }
+    hasRunningStream() {
+        return this._runningStartPos !== null && this._connected && this._runningCommand !== "";
+    }
+    /**
+     * 增量取运行中命令的实时输出（WS 推流用）：
+     * 首次定位命令回显结束点，后续返回增量；done 标记出现 → 返回剩余 + done
+     * @returns data 本次增量；done 命令已完成
+     */
+    getRunningStream() {
+        if (this._runningStartPos === null || !this._connected || !this._runningCommand) {
+            this._streamPos = null;
+            return { data: "", done: false };
+        }
+        const end = extractOutputStart(this._buffer.slice(this._runningStartPos), this._runningCommand);
+        if (end <= 0)
+            return { data: "", done: false };
+        const echoEnd = this._runningStartPos + end;
+        const marker = detectLastDoneMarker(this._buffer, echoEnd);
+        const windowEnd = marker.done ? marker.pos : this._buffer.length;
+        if (this._streamPos === null) {
+            this._streamPos = echoEnd;
+        }
+        const raw = this._buffer.slice(this._streamPos, windowEnd);
+        this._streamPos = windowEnd;
+        return { data: stripMarkers(raw), done: marker.done };
+    }
+    /** 关闭终端，清理会话态（幂等） */
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        if (this._watchTimer)
+            clearInterval(this._watchTimer);
+        this._closeTransport();
+        this._connected = false;
+        this._remoteBusy = false;
+        this._history.dispose();
+    }
+    /** 增量读取连续原始字节流：返回自 pos 之后的新增字节 */
+    readRawStream(pos) {
+        if (pos < this._rawDiscarded)
+            return { data: this._rawLog, pos: this._rawTotal, reset: true };
+        const from = pos - this._rawDiscarded;
+        return { data: this._rawLog.slice(from), pos: this._rawTotal };
+    }
+    /** 命令执行/提交前准备：裁剪已消费缓冲 + 丢弃上一条命令的迟到残留标记 */
+    _beginCapture(command) {
+        // 用上一条命令完成标记（最后一个合法 <SSH_DONE:N>）定位命令起点；
+        // 备屏重放等场景下 buffer 可能含旧标记，裁剪到最后一个标记之后即可
+        const marker = detectLastDoneMarker(this._buffer, 0);
+        if (marker.done) {
+            this._buffer = this._buffer.slice(marker.pos);
+            this._cursor = 0;
+        }
+        // fallback：无标记时依赖 _cursor 裁剪
+        this._buffer = this._buffer.slice(this._cursor);
+        this._cursor = 0;
+        this._runningStartPos = 0;
+        this._runningCommand = command;
+        this._runningStartTs = Date.now();
+        this._remoteBusy = true;
+        this._lastActive = Date.now();
+    }
+    /** 追加输出字节：维护业务缓冲 + 连续原始流 ring */
+    _appendBuffer(text) {
+        this._buffer += text;
+        if (this._buffer.length > MAX_BUFFER_LEN) {
+            const trimmed = this._buffer.length - MAX_BUFFER_LEN;
+            this._buffer = this._buffer.slice(trimmed);
+            if (this._runningStartPos !== null)
+                this._runningStartPos = Math.max(0, this._runningStartPos - trimmed);
+            this._cursor = Math.max(0, this._cursor - trimmed);
+            if (this._streamPos !== null)
+                this._streamPos = Math.max(0, this._streamPos - trimmed);
+        }
+        this._rawLog += text;
+        this._rawTotal += text.length;
+        if (this._rawLog.length > RAW_LOG_MAX) {
+            const trimmed = this._rawLog.length - RAW_LOG_MAX;
+            this._rawLog = this._rawLog.slice(trimmed);
+            this._rawDiscarded += trimmed;
+        }
+    }
+    /** 探测 shell 类型：deadline 内循环发送探测命令并解析输出（shell 慢启动时也能等到就绪） */
+    async _probeShell(deadline) {
+        while (Date.now() < deadline) {
+            this._write("echo __SHELL_ID__$0\r");
+            const output = await this._waitProbeOutput(Math.min(PROBE_TIMEOUT_MS, deadline - Date.now()));
+            if (output !== null && /\b__SHELL_ID__\b/.test(output)) {
+                const adapter = resolveByProbe(output);
+                this._buffer = "";
+                return adapter;
+            }
+            this._buffer = "";
+        }
+        return null;
+    }
+    /** 等待探测输出稳定：buffer 有内容且 500ms 不再变化则返回，超时返回 null */
+    async _waitProbeOutput(maxMs) {
+        const start = Date.now();
+        let lastLen = this._buffer.length;
+        let lastChange = Date.now();
+        while (Date.now() - start < maxMs) {
+            if (this._buffer.length > 0 && Date.now() - lastChange >= 500)
+                return this._buffer;
+            if (this._buffer.length !== lastLen) {
+                lastLen = this._buffer.length;
+                lastChange = Date.now();
+            }
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        return this._buffer.length > 0 ? this._buffer : null;
+    }
+    /**
+   * deadline 内循环注入+等待确认，成功返回 true，超时返回 false
+   * 逐行发送避免因 shell 未就绪导致的整块丢失；每轮等待最大 3s
+   * 注入命令原样回显（不抑制），确认以 echo 唯一标识为准，避免与后续命令时序混淆
+   */
+    async _injectAndSettle(deadline) {
+        const TOKEN = "__SSH_INJECT_DONE__";
+        const line = this._adapter.buildInjectScript().trim();
+        if (!line)
+            return true;
+        while (Date.now() < deadline) {
+            this._write(line + "\r");
+            if (await this._waitForBufferToken(line, TOKEN, Math.min(SETTLE_TIMEOUT_MS, deadline - Date.now()))) {
+                await new Promise((r) => setTimeout(r, 100));
+                this._buffer = "";
+                this._cursor = 0;
+                return true;
+            }
+            log.info("注入标识未确认，重试");
+            this._buffer = "";
+            this._cursor = 0;
+        }
+        return false;
+    }
+    /** 等待缓冲中出现指定文本（最多 maxMs） */
+    async _waitForBufferToken(line, token, maxMs) {
+        const startTime = Date.now();
+        while (Date.now() - startTime < maxMs) {
+            const lineEnd = findLastEndOf(line, this._buffer);
+            if (lineEnd >= 0 && this._buffer.includes(token, lineEnd + 1))
+                return true;
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        return false;
+    }
+    _waitCompletion(startPos, startTs) {
+        return new Promise((resolve) => {
+            let lastLen = this._buffer.length;
+            let echoEnd = 0;
+            const timer = setInterval(() => {
+                if (INTERACTIVE_RE.test(this._buffer.slice(startPos))) {
+                    clearInterval(timer);
+                    resolve({ kind: "interactive" });
+                    return;
+                }
+                const now = Date.now();
+                const curLen = this._buffer.length;
+                if (curLen !== lastLen)
+                    lastLen = curLen;
+                if (echoEnd <= 0 && this._runningCommand) {
+                    const end = extractOutputStart(this._buffer.slice(startPos), this._runningCommand);
+                    if (end > 0)
+                        echoEnd = startPos + end;
+                }
+                // 完成标记（精确权威）：命令结束时 shell 重绘提示符前必输出 <SSH_DONE>，
+                // 下载/编译等静默期不会误判完成，中断（Ctrl-C 回到提示符）同样会输出标记。
+                // 必须等命令回显出现后才检测：回显前的标记只可能是上一条命令的迟到残留。
+                if (echoEnd > 0) {
+                    const marker = detectLastDoneMarker(this._buffer, echoEnd);
+                    if (marker.done) {
+                        clearInterval(timer);
+                        resolve({ kind: "done", markerPos: marker.pos });
+                        return;
+                    }
+                }
+                // 超过动画窗口仍未出现完成标记 → 交给后台 watch 继续监听（不设硬超时）
+                if (now - startTs >= ANIMATION_WINDOW_MS) {
+                    clearInterval(timer);
+                    resolve({ kind: "running" });
+                    return;
+                }
+            }, 50);
+        });
+    }
+    /** 后台监听：轮询 done 标记 → 收集输出进 history + busy=false */
+    _startBackgroundWatch(startPos, command) {
+        if (this._watchTimer)
+            clearInterval(this._watchTimer);
+        const born = Date.now();
+        let echoEnd = 0;
+        this._watchTimer = setInterval(() => {
+            if (!this._connected || Date.now() - born > MAX_WATCH_LEN) {
+                this._remoteBusy = false;
+                this._clearRunningContext();
+                if (this._watchTimer)
+                    clearInterval(this._watchTimer);
+                return;
+            }
+            if (echoEnd <= 0 && command) {
+                const end = extractOutputStart(this._buffer.slice(startPos), command);
+                if (end > 0)
+                    echoEnd = startPos + end;
+            }
+            if (echoEnd <= 0)
+                return;
+            const marker = detectLastDoneMarker(this._buffer, echoEnd);
+            if (marker.done) {
+                const raw = this._buffer.slice(startPos, marker.pos);
+                this._history.append(command, extractOutput(raw, command), this._runningStartTs);
+                this._cursor = Math.max(startPos, marker.pos);
+                this._remoteBusy = false;
+                this._clearRunningContext();
+                if (this._watchTimer)
+                    clearInterval(this._watchTimer);
+            }
+        }, 200);
+    }
+    _clearRunningContext() {
+        this._runningStartPos = null;
+        this._runningCommand = "";
+        this._streamPos = null;
+        this._runningStartTs = 0;
+    }
+    _truncate(s) {
+        if (s.length <= MAX_OUTPUT_LEN)
+            return s;
+        return `${s.slice(0, MAX_OUTPUT_LEN)}\n... [output truncated, ${s.length} chars total]`;
+    }
+}
+//# sourceMappingURL=base-session.js.map