@xiaoqiong0v0/opencode-ssh-tool 0.5.1 → 0.6.1

package/dist/base-session.js

@@ -1,38 +1,100 @@
 // 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 { ANIMATION_WINDOW_MS, MAX_OUTPUT_LEN, RAW_LOG_MAX, DONE_TAG, } 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";
+import { toModelText, extractOutputStart } from "./utils.js";
+import { detectLastDoneMarker, stripMarkers, detectInterrupt, adapters } from "./shell-adapter.js";
+import { tr } from "./i18n.js";
 /** 交互触发词（sudo 密码 / 分页器 / 确认提示），含中英文 */
-const INTERACTIVE_RE = /(\[sudo\] password for|password for \S+:|Password:|密码:|--More--|\(END\)|\[y\/N\]|\[Y\/n\]|yes\/no|是\/否)/i;
+const INTERACTIVE_RE = /(\[sudo\] password for|password for \S+:|\*\*\*\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;
+/**
+ * 剥离命令尾部注释：仅当 `#` 在行首或前有空白、且不在单双引号内（支持反斜杠转义）时视为注释，
+ * 避免 `echo "a#b"` / `echo 'a#b'` 引号内的 # 被误剥，也避免 marker 被真注释吞掉。
+ * @param s 命令文本
+ * @returns 剥离尾注释（若有）后的文本
+ */
+function stripTrailingComment(s) {
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (c === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (c === "'" && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (c === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (c === "#" && !inSingle && !inDouble && (i === 0 || /\s/.test(s[i - 1]))) {
+            return s.slice(0, i).trimEnd();
+        }
+    }
+    return s.trimEnd();
+}
+/**
+ * 剥离命令尾部注释与尾部运算符，避免拼装 `;marker` 时：
+ * - 尾注释 `# xxx` 把 marker 整行吞掉 → 检测不到完成
+ * - 尾运算符 `&`、`;`、`&&`、`||` 与拼接的 `;` 形成 `&;`/`;;` 等语法错误
+ * @param command 原始命令
+ * @returns 可安全拼装 marker 的命令体
+ */
+function stripCommandTail(command) {
+    // 仅处理最后一行：多行命令（如 heredoc 正文）中间的 `#` 是内容，若在此截断会把命令切断
+    const nl = command.lastIndexOf("\n");
+    const head = nl >= 0 ? command.slice(0, nl + 1) : "";
+    const last = nl >= 0 ? command.slice(nl + 1) : command;
+    let s = stripTrailingComment(last);
+    s = s.replace(/(?:&&|\|\||[;&|])[\s]*$/, "");
+    return (head + s).trimEnd();
+}
 /** 会话命令执行与读取的公共实现 */
 export class BaseSession {
     sessionID;
     name;
+    _lang;
     _connected = false;
     _remoteBusy = false;
+    /**
+     * 是否保持 busy：排队命令顺序执行时，中间某条完成也不清 busy，
+     * 直到序列最后一条完成（否则 web/status 会在中间命令间隙闪 busy=false）。
+     */
+    _holdBusy = false;
     _buffer = "";
     _connectedAt = 0;
     _lastActive = 0;
     _runningStartPos = null;
     _runningCommand = "";
     _watchTimer = null;
+    /** 命令序号（完成标记 <SSH_DONE:seq:code> 标识本次命令，防残留误判） */
+    _cmdSeq = 0;
+    /** 当前命令序号（_beginCapture 递增，供检测/拼接用） */
+    _runningSeq = 0;
     /** 下次捕获窗口起点（相对当前 buffer）：前一条命令结束后，标记/残留从此处开始 */
     _cursor = 0;
     /** WS 实时流已发送位置（相对 buffer 偏移）；null = 尚未定位命令回显结束点 */
     _streamPos = null;
     /** Shell 适配器（探测后确定） */
     _adapter = null;
+    /** 多行命令写入 PTY 的行分隔符：Unix PTY 用 \n；Windows ConPTY（本地会话）用 \r（裸 \n 不提交行） */
+    _lineSep = "\n";
     _closed = false;
     /** 当前运行命令的输入时刻（history 记录展示命令发起时间用） */
     _runningStartTs = 0;
@@ -43,9 +105,19 @@ export class BaseSession {
     /** 累积原始字节总数（单调递增，前端增量游标） */
     _rawTotal = 0;
     _history;
-    constructor(sessionID, history, name = "default") {
+    /** 生命周期监听器（命令开始/完成事件，agent 转报 server） */
+    _lifecycle = null;
+    /**
+     * 本次命令期间是否真实发送过中断（Ctrl-C）。
+     * 中断判定不依赖"命令回显定位"：超宽命令被 readline 折行重绘时回显会多出字符，
+     * 精确匹配必然失败（echoEnd=0），若再以 echoEnd 为前置条件则 ^C 永远检测不到 → busy 卡死。
+     * 仅当确实发过 ^C 才去缓冲区找 ^C 回显，天然排除历史残留 ^C 的误判。
+     */
+    _interruptSent = false;
+    constructor(sessionID, history, name = "default", _lang = "en") {
         this.sessionID = sessionID;
         this.name = name;
+        this._lang = _lang;
         this._history = history;
     }
     /** 结果中的类型专属字段（SSH 附加 host，本地为空） */
@@ -57,11 +129,13 @@ export class BaseSession {
      */
     async submit(command) {
         if (!this._ready())
-            return { ok: false, output: "", error: "Not connected" };
+            return { ok: false, output: "", error: tr("err_not_connected", this._lang) };
         if (this._remoteBusy)
-            return { ok: false, output: "", error: `Previous command still running, poll with ${this._statusCmd} first` };
+            return { ok: false, output: "", error: tr("cmd_busy", this._lang) };
+        if (this._adapter?.hasOpenContinuation(command))
+            return { ok: false, output: "", error: tr("cmd_continuation", this._lang) };
         this._beginCapture(command);
-        this._write(command + "\r");
+        this._write(this._composeCommand(command));
         this._startBackgroundWatch(0, command);
         return { ok: true, output: "", submitted: true, command, duration: 0, ...this._extraResult };
     }
@@ -73,29 +147,39 @@ export class BaseSession {
     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` };
+            return { ok: false, output: "", error: tr("err_not_connected", this._lang) };
+        if (this._remoteBusy) {
+            log.info(`exec quick-fail busy: ${command} (busy=${this._remoteBusy})`);
+            return { ok: false, output: "", error: tr("cmd_busy", this._lang) };
+        }
+        if (this._adapter?.hasOpenContinuation(command)) {
+            log.info(`exec quick-fail open continuation: ${command}`);
+            return { ok: false, output: "", error: tr("cmd_continuation", this._lang) };
+        }
         this._beginCapture(command);
         const captureStart = this._buffer.length;
-        this._write(command + "\r");
+        this._write(this._composeCommand(command));
         const outcome = await this._waitCompletion(0, startTs);
+        log.info(`exec ${command} -> ${outcome.kind}${outcome.kind === "running" ? "" : " markerPos=" + outcome.markerPos} (busy=${this._remoteBusy})`);
         switch (outcome.kind) {
             case "done": {
-                this._remoteBusy = false;
+                this._remoteBusy = this._holdBusy; // 排队序列中间命令：保持 busy 到序列结束
                 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());
+                const out = this._extractOutput(raw, command);
+                this._history.append(command, out, this._runningStartTs, Date.now());
+                this._emitDone(outcome.exitCode ?? null, Date.now(), out);
                 this._clearRunningContext();
-                return { ok: true, output: this._truncate(toModelText(extractOutput(raw, command))), command, duration: Date.now() - startTs, ...this._extraResult };
+                return { ok: true, output: this._truncate(toModelText(out)), command, duration: Date.now() - startTs, ...this._extraResult };
             }
             case "interactive": {
-                this._remoteBusy = false;
+                // 交互程序（sudo 密码 / 确认提示）：命令仍在等待用户输入，
+                // 保留 running 上下文与 busy 状态，转后台 watch 持续监听完成标记；
+                // 用户 send 输入后命令完成时由 watch 完整收集输出并翻转 busy（防新命令被当 exec 塞进运行中 shell）
                 const raw = this._buffer.slice(captureStart);
-                this._cursor = 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))), interactive: true, command, duration: Date.now() - startTs, ...this._extraResult };
+                const out = this._extractOutput(raw, command);
+                this._startBackgroundWatch(captureStart, command);
+                return { ok: true, output: this._truncate(toModelText(out)), interactive: true, command, duration: Date.now() - startTs, ...this._extraResult };
             }
             case "running": {
                 this._runningStartPos = 0;
@@ -125,13 +209,10 @@ export class BaseSession {
      */
     async readBuffer() {
         if (!this._connected)
-            return { ok: false, output: "", error: "Not connected" };
+            return { ok: false, output: "", error: tr("err_not_connected", this._lang) };
         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 };
+            const marker = detectLastDoneMarker(this._buffer, this._runningStartPos, this._runningSeq);
             if (marker.done) {
                 const raw = this._buffer.slice(this._runningStartPos, marker.pos);
                 this._buffer = this._buffer.slice(marker.pos);
@@ -158,7 +239,7 @@ export class BaseSession {
      */
     send(text) {
         if (!this._connected)
-            return { ok: false, error: "Not connected" };
+            return { ok: false, error: tr("err_not_connected", this._lang) };
         const payload = text
             .replace(/\\x1b/gi, "\x1b")
             .replace(/\\x03/gi, "\x03")
@@ -166,6 +247,10 @@ export class BaseSession {
             .replace(/\\x1a/gi, "\x1a")
             .replace(/\\r/g, "\r")
             .replace(/\\n/g, "\r");
+        log.info(`send -> ${JSON.stringify(payload)} (connected=${this._connected}, busy=${this._remoteBusy})`);
+        // 真实中断输入：标记本次命令已发过 Ctrl-C，供完成判定识别 ^C 回显（不依赖命令回显定位）
+        if (payload.includes("\x03"))
+            this._interruptSent = true;
         this._write(payload);
         this._lastActive = Date.now();
         return { ok: true };
@@ -179,6 +264,37 @@ export class BaseSession {
     getRunningCommand() {
         return this._runningStartPos !== null && this._connected ? this._runningCommand : "";
     }
+    /**
+     * 设置命令生命周期监听器（命令开始/完成时回调）
+     * @param listener 回调（start 携带命令，done 携带退出码与结束时刻；null 表示清除）
+     */
+    setLifecycle(listener) {
+        this._lifecycle = listener;
+    }
+    /**
+     * 设置是否保持 busy（排队命令序列期间为 true）：
+     * true 时中间命令完成不清 busy；置 false 时立即清 busy。
+     * @param hold 是否保持
+     */
+    setHoldBusy(hold) {
+        this._holdBusy = hold;
+        if (!hold)
+            this._remoteBusy = false;
+    }
+    /** 触发命令开始事件 */
+    _emitStart(command, ts) {
+        try {
+            this._lifecycle?.({ type: "start", command, ts });
+        }
+        catch { /* 监听器异常不打断执行 */ }
+    }
+    /** 触发命令完成事件 */
+    _emitDone(exitCode, endTs, output) {
+        try {
+            this._lifecycle?.({ type: "done", exitCode, endTs, output });
+        }
+        catch { /* 同上 */ }
+    }
     hasRunningStream() {
         return this._runningStartPos !== null && this._connected && this._runningCommand !== "";
     }
@@ -192,18 +308,23 @@ export class BaseSession {
             this._streamPos = null;
             return { data: "", done: false };
         }
-        const end = extractOutputStart(this._buffer.slice(this._runningStartPos), this._runningCommand);
+        // 完成标记先定位（marker 唯一 seq，从命令起点搜索，免疫 echoEnd 被后序回显带偏）
+        const marker = detectLastDoneMarker(this._buffer, this._runningStartPos, this._runningSeq);
+        const markerEnd = marker.done ? marker.pos : this._buffer.length;
+        const end = extractOutputStart(this._buffer.slice(this._runningStartPos), this._composeEchoText(this._runningCommand), markerEnd - this._runningStartPos);
         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 };
+        let data = stripMarkers(raw);
+        if (this._adapter)
+            data = data.replace(this._markerCmd(this._runningSeq), "");
+        return { data, done: marker.done };
     }
     /** 关闭终端，清理会话态（幂等） */
     close() {
@@ -224,11 +345,86 @@ export class BaseSession {
         const from = pos - this._rawDiscarded;
         return { data: this._rawLog.slice(from), pos: this._rawTotal };
     }
+    /**
+     * 本会话当前命令的完成标记命令（adapter 负责各自的标记语法，无 adapter 时用 POSIX 默认）
+     * @param seq 命令序号
+     * @returns 标记命令文本
+     */
+    _markerCmd(seq) {
+        return this._adapter ? this._adapter.markerCmd(seq) : `printf '\\n${DONE_TAG}${seq}:%s>' $?`;
+    }
+    /**
+     * 组合实际写入 PTY 的命令：在规范形式（`_composeEchoText`）基础上把换行改写为会话行分隔符并补尾部回车。
+     * 行分隔符按会话类型：Unix PTY 用 `\n`（正常提交行），Windows ConPTY 用 `\r`（实测裸 `\n` 不提交行，
+     * pwsh 会停在续行 `>>`、行序错乱）。
+     * @param command 原始命令（history 存干净版本）
+     * @returns 实际写入 PTY 的文本（尾部带 \r，行分隔已按会话类型规范化）
+     */
+    _composeCommand(command) {
+        return this._composeEchoText(command).replace(/\n/g, this._lineSep) + "\r";
+    }
+    /**
+     * 组合命令文本（规范/匹配用形式，始终以 `\n` 分隔行、无尾部回车）：命令 + 完成标记。
+     * 该形式供 `extractOutputStart` 按 `\n` 切行并做段间宽松匹配（跳过 `>>` 续行提示），
+     * 故不可改写为 `_lineSep`——否则本地会话（`\r`）下整段回显变一行、段间匹配失效、回显剥离失败。
+     * 完成标记用当前 shell 的语句分隔符同行拼接（POSIX/pwsh 为 `;`，cmd 为 `&`），免疫 prompt 框架覆盖：
+     * `python; printf ...` 中 printf 由 shell 在 python 退出后执行，不会被 REPL 当 stdin 消费
+     * （实测 top/read/python 均正常出 marker）。
+     * 多行命令用 shell 组语法（groupWrap）包裹成**一条**命令：一次输入 = 一条命令 = 一段输出，
+     * 避免 shell 逐行执行导致回显与输出交错、中间输出被 extractOutputStart 丢掉
+     * （如 `cd /tmp` 之后的 `echo AAA`/`echo BBB` 输出丢失）；heredoc 分隔符行必须独占一行，
+     * 若标记直接拼上去（`EOF ;printf ...`）会让分隔符失效 → heredoc 永不结束 → 卡死，
+     * 故含 heredoc 的多行命令也必须包组。
+     * cmd 无法安全包组（组内 `%errorlevel%` 为解析期展开、退出码失真）或无 adapter 时回退原样拼接。
+     * 交互程序（top/vi/read/python 等）期间保留 running 上下文与 busy，marker 出现即判定完成。
+     * @param command 原始命令
+     * @returns 命令 + 标记文本（规范 `\n` 形式，无尾部回车）
+     */
+    _composeEchoText(command) {
+        const marker = this._markerCmd(this._runningSeq);
+        const body = stripCommandTail(command);
+        const sep = this._adapter?.stmtSep ?? ";";
+        // 多行命令：尝试包组（cmd 返回 null → 回退原样拼接），使整段作为一条命令执行
+        if (body.includes("\n")) {
+            const grouped = this._adapter?.groupWrap(body);
+            return grouped ? `${grouped} ${sep}${marker}` : `${body} ${sep}${marker}`;
+        }
+        return `${body} ${sep}${marker}`;
+    }
+    /**
+     * 提取命令纯输出：从命令回显后切到完成标记（无标记则切到中断回显 ^C 处），
+     * 顺带去掉追加的标记命令回显行。
+     * 回显定位使用组合命令文本（command + 标记段）而非裸命令：裸命令可能出现在程序错误输出中
+     * （如 `pw` 的错误行 `bash: pw: command not found`），而组合命令整行回显是唯一的，
+     * 可避免 last-match 误命中错误行导致输出被裁空。
+     * @param raw 本次执行窗口原始字节流
+     * @param command 原始命令（历史用）
+     * @returns 纯程序输出原始流
+     */
+    _extractOutput(raw, command) {
+        // 完成标记先定位：marker 自带唯一 seq，从窗口起点搜索即可（echoEnd 可能被连续输入的后序回显带偏）
+        const marker = detectLastDoneMarker(raw, 0, this._runningSeq);
+        const echoText = this._composeEchoText(command);
+        const end = marker.done ? extractOutputStart(raw, echoText, marker.pos) : extractOutputStart(raw, echoText);
+        if (end <= 0)
+            return stripMarkers(raw);
+        let out;
+        if (marker.done) {
+            out = raw.slice(end, marker.pos);
+        }
+        else {
+            const intr = detectInterrupt(raw, end);
+            out = intr.interrupted ? raw.slice(end, intr.pos) : raw.slice(end);
+        }
+        if (this._adapter)
+            out = out.replace(this._markerCmd(this._runningSeq), "");
+        return stripMarkers(out.replace(/^[\r\n]+/, ""));
+    }
     /** 命令执行/提交前准备：裁剪已消费缓冲 + 丢弃上一条命令的迟到残留标记 */
     _beginCapture(command) {
-        // 用上一条命令完成标记（最后一个合法 <SSH_DONE:N>）定位命令起点；
+        // 用上一条命令完成标记（<SSH_DONE:seq:N>，此刻 _runningSeq 仍是上一条的）定位命令起点；
         // 备屏重放等场景下 buffer 可能含旧标记，裁剪到最后一个标记之后即可
-        const marker = detectLastDoneMarker(this._buffer, 0);
+        const marker = detectLastDoneMarker(this._buffer, 0, this._runningSeq);
         if (marker.done) {
             this._buffer = this._buffer.slice(marker.pos);
             this._cursor = 0;
@@ -239,8 +435,12 @@ export class BaseSession {
         this._runningStartPos = 0;
         this._runningCommand = command;
         this._runningStartTs = Date.now();
+        this._interruptSent = false; // 新命令：清除上一条/空闲期发出的 Ctrl-C 标记
+        this._cmdSeq += 1;
+        this._runningSeq = this._cmdSeq;
         this._remoteBusy = true;
         this._lastActive = Date.now();
+        this._emitStart(command, this._runningStartTs);
     }
     /** 追加输出字节：维护业务缓冲 + 连续原始流 ring */
     _appendBuffer(text) {
@@ -262,17 +462,17 @@ export class BaseSession {
             this._rawDiscarded += trimmed;
         }
     }
-    /** 探测 shell 类型：deadline 内循环发送探测命令并解析输出（shell 慢启动时也能等到就绪） */
+    /** 探测 shell 类型：按各适配器 probeCommand 逐个探测（POSIX 系优先，pwsh/cmd 用各自独有命令），
+     *  login shell 的 $0 带 - 前缀（-bash/-zsh）由对应 parseProbe 容忍 */
     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);
+            for (const candidate of adapters) {
+                this._write(candidate.probeCommand + "\r");
+                const output = await this._waitProbeOutput(Math.min(PROBE_TIMEOUT_MS, deadline - Date.now()));
                 this._buffer = "";
-                return adapter;
+                if (output !== null && candidate.parseProbe(output))
+                    return candidate;
             }
-            this._buffer = "";
         }
         return null;
     }
@@ -292,45 +492,9 @@ export class BaseSession {
         }
         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);
@@ -341,23 +505,25 @@ export class BaseSession {
                 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;
+                // 完成判定（权威）：命令后追加的 printf 输出 <SSH_DONE>，或 Ctrl-C 中断时 TTY 回显 ^C。
+                // marker 自带唯一 seq，从命令起点直接搜索即可（不依赖命令回显定位）
+                const marker = detectLastDoneMarker(this._buffer, startPos, this._runningSeq);
+                if (marker.done) {
+                    clearInterval(timer);
+                    resolve({ kind: "done", markerPos: marker.pos, exitCode: marker.exitCode });
+                    return;
                 }
-                // 完成标记（精确权威）：命令结束时 shell 重绘提示符前必输出 <SSH_DONE>，
-                // 下载/编译等静默期不会误判完成，中断（Ctrl-C 回到提示符）同样会输出标记。
-                // 必须等命令回显出现后才检测：回显前的标记只可能是上一条命令的迟到残留。
-                if (echoEnd > 0) {
-                    const marker = detectLastDoneMarker(this._buffer, echoEnd);
-                    if (marker.done) {
+                // ^C 中断：仅当本次命令确实发送过 Ctrl-C 才检测（无需命令回显定位，
+                // 超宽命令折行重绘会让回显精确匹配失败；未发过 Ctrl-C 时缓冲区里的 ^C 只可能是残留）
+                if (this._interruptSent) {
+                    const intr = detectInterrupt(this._buffer, startPos);
+                    if (intr.interrupted) {
                         clearInterval(timer);
-                        resolve({ kind: "done", markerPos: marker.pos });
+                        resolve({ kind: "done", markerPos: intr.pos, exitCode: 130 });
                         return;
                     }
                 }
-                // 超过动画窗口仍未出现完成标记 → 交给后台 watch 继续监听（不设硬超时）
+                // 超过动画窗口仍未出现完成信号 → 交给后台 watch 继续监听（不设硬超时）
                 if (now - startTs >= ANIMATION_WINDOW_MS) {
                     clearInterval(timer);
                     resolve({ kind: "running" });
@@ -366,33 +532,35 @@ export class BaseSession {
             }, 50);
         });
     }
-    /** 后台监听：轮询 done 标记 → 收集输出进 history + busy=false */
+    /** 后台监听：轮询 done 标记 / ^C 中断 → 收集输出进 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) {
+                // 超时/断连：命令视为结束（可能从未完成），补发 done 防 server busy 卡死
+                if (this._runningCommand)
+                    this._emitDone(null, Date.now());
                 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;
+            // marker 唯一 seq，从命令起点搜索（不依赖命令回显定位）
+            const marker = detectLastDoneMarker(this._buffer, startPos, this._runningSeq);
+            // ^C 中断：仅当本次命令确实发送过 Ctrl-C 才检测（超宽命令折行重绘会让回显精确匹配失败）
+            const intr = this._interruptSent ? detectInterrupt(this._buffer, startPos) : { interrupted: false, pos: 0 };
+            const end = marker.done ? marker.pos : intr.pos;
+            if (marker.done || intr.interrupted) {
+                const raw = this._buffer.slice(startPos, end);
+                const code = marker.done ? marker.exitCode : 130;
+                const out = this._extractOutput(raw, command);
+                this._history.append(command, out, this._runningStartTs);
+                this._emitDone(code, Date.now(), out);
+                this._cursor = Math.max(startPos, end);
+                this._remoteBusy = this._holdBusy; // 排队序列中间命令：保持 busy 到序列结束
                 this._clearRunningContext();
                 if (this._watchTimer)
                     clearInterval(this._watchTimer);
@@ -404,6 +572,7 @@ export class BaseSession {
         this._runningCommand = "";
         this._streamPos = null;
         this._runningStartTs = 0;
+        this._interruptSent = false;
     }
     _truncate(s) {
         if (s.length <= MAX_OUTPUT_LEN)