@zhangfengshun/dsh-remote-ssh 2.1.7 → 2.2.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 本文件的版本号与 `package.json` 的 `version` 保持一致。每个版本对应一个 Cordis Package 快照（`pkg-N`）。
 
+## [2.2.0] — 远程命令连接复用（实测 ≈15× 提速）+ 协议/安全加固
+### 性能
+- **`remote_ssh_exec` 走持久会话池**：不再每次调用做完整 SSH 握手。真实 HPC（ssh.cn-zhongwei-1.paracloud.com，2222 端口）实测：一次性连接单命令平均 **1292ms**，连接复用后单命令平均 **84.3ms**，**约 15.3× 提速**；`stdin` 参数经 heredoc 走同一条复用通道。
+- **stderr/stdout 分离语义保留**：stderr 重定向到远端临时文件、退出码哨兵后 cat 回传并以第二个哨兵收尾（双哨兵协议）。
+- **读路径保持轻量**：`ls`/`cat`/`grep`/`glob` 继续走 `2>&1` 合并协议，热路径避开子 shell 与临时文件开销。
+- **大文件读取先 stat**：超过 4MB 只读前 4MB（`head -c` 截断并标记 truncated），不再让持久会话缓冲无限增长。
+### 安全 / 健壮性
+- **会话输出硬上限 8MB**：单条命令哨兵到达前缓冲超限即重置会话并给出明确报错，防止远端海量输出撑爆内存。
+- **密钥认证非交互连接加 `-o BatchMode=yes -o PreferredAuthentications=publickey`**：带口令的私钥/意外交互立即失败并返回可读提示（不再挂到超时），同时缩短建连时间；交互式终端（`ssh -tt`）不受影响。
+- **分离协议用双层子 shell**：用户命令中的 `exit`/`cd` 不再弄挂共享会话（内层子 shell 隔离，实测远端 `exit 7` 后会话存活且退出码正确传回）。
+- **写入上限 4MB**：超限直接拒绝并给出清晰报错；写入失败现在能拿回远端 stderr（此前错误信息丢失）。
+- 配合 2.1.7 纳入的修复（`--include` 转义、stderr 排空、删除配置级联清理、keyPath `~` 展开、会话池 key 含认证信息），完成一轮兼容性/安全性全面检查。
+
 ## [2.1.7] — 兼容 DSH Desktop ≥ 2.0.4：polyfill __DSH_MODULES__ + 可靠性/安全修复
 ### 修复
 - **__DSH_MODULES__ polyfill**：better-sidebar 0.15+ 的懒加载 chunk（编辑器等）依赖 `globalThis.__DSH_MODULES__`，而 DSH Desktop ≥ 2.0.4 的 shell 不再挂载该全局，导致侧边栏面板打不开（"chunk ... client module system unavailable"）。Client 半边启动时用内核 `modules` 服务补挂该全局（better-sidebar 已注入则保持原值），并带定期兜底重试。

package/lib/index.js

@@ -25,6 +25,8 @@ const Config = z.object({});
 
 const NS = "dsh-remote-ssh";
 const MAX_BYTES = 4 * 1024 * 1024;
+/** 持久会话单条命令的 stdout 缓冲硬上限（防止大文件/海量输出撑爆内存）。 */
+const SESSION_MAX_STDOUT = 8 * 1024 * 1024;
 const API_BASE = "/remote-ssh/api/";
 
 /** 连接配置 schema（存于 settings）。 */
@@ -161,8 +163,10 @@ async function listSshConfigHosts() {
  * 避免每次操作都做完整 TCP 握手 + SSH 密钥交换 + 认证（超算/跳板机单次 2-10 秒）。
  *
  * 工作原理：向 bash 的 stdin 写入命令 + 哨兵标记 printf，从 stdout 读取直到哨兵出现，
- * 哨兵后的数字即退出码。每条命令用 2>&1 合并 stderr（成功时 stderr 为空，不影响解析；
- * 失败时错误信息在 stdout 中，退出码非 0）。带 stdin 的写操作用 heredoc。
+ * 哨兵后的数字即退出码。split（分离 stderr）模式下，stderr 重定向到远端临时文件，
+ * 退出码哨兵之后 cat 出来并用第二个哨兵收尾：保住 stdout/stderr 分离的同时，
+ * 让 remote_ssh_exec 这类调用也走连接复用（首调用建连后毫秒级返回）。
+ * 输出侧有硬上限 SESSION_MAX_STDOUT：哨兵出现前缓冲超限即重置会话，下次调用自动重建。
  */
 class CommandSession {
   constructor(subprocess, profile) {
@@ -226,34 +230,87 @@ class CommandSession {
 
   _check() {
     if (!this.current) return;
-    const idx = this.buf.indexOf(this.sentinel);
-    if (idx < 0) return;
-    const before = this.buf.slice(0, idx);
-    const after = this.buf.slice(idx + this.sentinel.length);
-    const nl = after.indexOf("\n");
-    const codeStr = nl >= 0 ? after.slice(0, nl) : after;
-    const rest = nl >= 0 ? after.slice(nl + 1) : "";
-    this.buf = rest;
-    const exitCode = parseInt(codeStr, 10);
-    const cur = this.current;
+    const item = this.current;
+    if (!item.exitParsed) {
+      // 找到主哨兵：解析退出码；split 模式还要等第二个哨兵（stderr 内容）
+      const idx = this.buf.indexOf(this.sentinel);
+      if (idx < 0) { this._enforceCap(); return; }
+      const before = this.buf.slice(0, idx);
+      const after = this.buf.slice(idx + this.sentinel.length);
+      const nl = after.indexOf("\n");
+      const codeStr = nl >= 0 ? after.slice(0, nl) : after;
+      this.buf = nl >= 0 ? after.slice(nl + 1) : "";
+      const exitCode = parseInt(codeStr, 10);
+      item.exitCode = isNaN(exitCode) ? -1 : exitCode;
+      item.stdout = before;
+      item.exitParsed = true;
+      if (!item.errSentinel) {
+        this.current = null;
+        item.resolve({ stdout: item.stdout, stderr: item.stderr, exitCode: item.exitCode });
+        this._next();
+        return;
+      }
+    }
+    if (item.errSentinel) {
+      // split 模式第二段：等 stderr 哨兵（可能已在缓冲里）
+      const idx = this.buf.indexOf(item.errSentinel);
+      if (idx < 0) { this._enforceCap(); return; }
+      const errText = this.buf.slice(0, idx);
+      const after = this.buf.slice(idx + item.errSentinel.length);
+      const nl = after.indexOf("\n");
+      this.buf = nl >= 0 ? after.slice(nl + 1) : "";
+      item.stderr = errText.replace(/\n$/, "");
+      this.current = null;
+      item.resolve({ stdout: item.stdout, stderr: item.stderr, exitCode: item.exitCode });
+      this._next();
+    }
+  }
+
+  /** 单条命令输出超过硬上限：立即重置会话（下次调用自动重建），拒绝挂起/撑爆内存。 */
+  _enforceCap() {
+    if (!this.current || this.buf.length < SESSION_MAX_STDOUT) return;
+    const item = this.current;
     this.current = null;
-    cur.resolve({ stdout: before, exitCode: isNaN(exitCode) ? -1 : exitCode });
-    this._next();
+    item.reject(new Error("单条命令输出超过 " + SESSION_MAX_STDOUT + " 字节上限，会话已重置（若确实需要更大输出请拆分命令）"));
+    this.alive = false;
+    if (this.handle) { try { this.handle.terminate(); } catch (e) {} this.handle = null; }
+    while (this.queue.length) this.queue.shift().reject(new Error("ssh 会话已重置"));
   }
 
   _next() {
     if (this.current || !this.alive || this.queue.length === 0) return;
     const item = this.queue.shift();
-    this.current = { resolve: item.resolve, reject: item.reject };
+    item.exitParsed = false;
+    item.stdout = "";
+    item.stderr = "";
+    item.exitCode = -1;
+    item.errSentinel = item.split
+      ? "DSHERR" + Math.random().toString(36).slice(2, 14) + Math.random().toString(36).slice(2, 8)
+      : null;
+    this.current = item;
     try {
+      const errFile = "${TMPDIR:-/tmp}/.dsh-err-" + Math.random().toString(36).slice(2, 10);
+      const exitMark = "printf '\\n" + this.sentinel + "%s\\n' $?";
+      const errTail = "cat " + errFile + " 2>/dev/null; rm -f " + errFile + "; printf '\\n" + item.errSentinel + "ok\\n'";
       let toWrite;
-      if (item.stdinData !== undefined && item.stdinData !== null) {
-        // 写操作：heredoc 传内容，不用 2>&1（cat > file 不产生 stdout）
+      if (item.split) {
+        // 分离 stderr 用双层子 shell：
+        //   外层 ( ... ) 保证 printf 链自身不会受用户命令返回值影响；
+        //   内层 ( { cmd ; } ) 隔离用户命令里的 exit/cd，绝不弄挂共享 bash 会话
+        //   （exit 只会退出内层子 shell，后面照常打印哨兵与退出码）。
+        if (item.stdinData !== undefined && item.stdinData !== null) {
+          const delim = "DSHW" + Math.random().toString(36).slice(2, 14);
+          toWrite = "( ( " + item.cmd + " <<'" + delim + "'\n" + String(item.stdinData) + "\n" + delim + "\n) 2>" + errFile + "; " + exitMark + "; " + errTail + " )\n";
+        } else {
+          toWrite = "( ( " + item.cmd + " ; ) 2>" + errFile + "; " + exitMark + "; " + errTail + " )\n";
+        }
+      } else if (item.stdinData !== undefined && item.stdinData !== null) {
+        // 快速路径写操作：heredoc 传内容，2>&1 合并（成功时 stderr 为空，不影响解析）
         const delim = "DSHW" + Math.random().toString(36).slice(2, 14);
-        toWrite = item.cmd + " <<'" + delim + "'\n" + String(item.stdinData) + "\n" + delim + "\nprintf '\\n" + this.sentinel + "%s\\n' $?\n";
+        toWrite = item.cmd + " <<'" + delim + "'\n" + String(item.stdinData) + "\n" + delim + "\n" + exitMark + "\n";
       } else {
-        // 读/列举/搜索：2>&1 合并 stderr（成功时 stderr 为空）
-        toWrite = "{ " + item.cmd + " ; } 2>&1\nprintf '\\n" + this.sentinel + "%s\\n' $?\n";
+        // 读/列举/搜索快速路径：2>&1 合并 stderr（成功时 stderr 为空）
+        toWrite = "{ " + item.cmd + " ; } 2>&1\n" + exitMark + "\n";
       }
       this.handle.stdin.write(toWrite);
     } catch (e) {
@@ -263,11 +320,11 @@ class CommandSession {
     }
   }
 
-  async exec(cmd, stdinData) {
+  async exec(cmd, stdinData, split) {
     await this.connect();
     this.lastUsed = Date.now();
     return new Promise((resolve, reject) => {
-      this.queue.push({ cmd, stdinData, resolve, reject });
+      this.queue.push({ cmd, stdinData, split: !!split, resolve, reject });
       this._next();
     });
   }
@@ -293,6 +350,13 @@ function sshArgv(p, remoteCmd, tty) {
   opts.push("-o", "ClearAllForwardings=yes");
   if (p.proxyJump) opts.push("-o", "ProxyJump=" + String(p.proxyJump));
   if (p.authMethod === "key" && p.keyPath) opts.push("-i", expandSshPath(p.keyPath));
+  // 密钥认证的非交互连接（会话池 / 工具 / 同步）要求一次性无提示完成：
+  // BatchMode 禁用 passphrase/确认交互（有口令的密钥立即报错而不是挂到超时），
+  // PreferredAuthentications=publickey 跳过无谓的认证方法协商，缩短建连时间。
+  if (!tty && p.authMethod === "key") {
+    opts.push("-o", "BatchMode=yes");
+    opts.push("-o", "PreferredAuthentications=publickey");
+  }
   const target = String(p.user || "") + "@" + String(p.host || "");
   const head = (p.authMethod === "password" && p.password) ? ["sshpass", "-p", String(p.password)] : [];
   const argv = head.concat(opts, [target]);
@@ -366,8 +430,23 @@ async function remoteListDir(runner, p, path) {
 
 async function remoteReadFile(runner, p, path) {
   if (!path) return { ok: false, error: "path 为必填项" };
-  const r = await runner(p, "base64 -w0 " + shellQuotePath(path), undefined, MAX_BYTES);
-  if (!r.ok) return r;
+  // 先 stat 拿大小：超过 MAX_BYTES 的大文件只读前 4MB（head -c 截断），
+  // 避免把持久会话的 stdout 缓冲撑爆（会话层另有 8MB 硬上限兜底）。
+  // 读路径走 2>&1 合并协议（热路径，省掉一次子 shell 与 stderr 重定向）。
+  const st = await runner(p, "stat -c%s " + shellQuotePath(path));
+  let size = null;
+  if (st.ok) {
+    const n = parseInt(String(st.stdout || "").trim(), 10);
+    if (!isNaN(n)) size = n;
+  }
+  let cmd = "base64 -w0 " + shellQuotePath(path);
+  let truncated = false;
+  if (size !== null && size > MAX_BYTES) {
+    cmd = "head -c " + MAX_BYTES + " " + shellQuotePath(path) + " | base64 -w0";
+    truncated = true;
+  }
+  const r = await runner(p, cmd, undefined, MAX_BYTES);
+  if (!r.ok) return { ok: false, error: String(r.error || r.stderr || "").trim() || "读取失败" };
   let text = "";
   let binary = false;
   try {
@@ -378,13 +457,16 @@ async function remoteReadFile(runner, p, path) {
   } catch (e) {
     return { ok: false, error: "解码失败: " + String(e) };
   }
-  return { ok: true, path: path, content: text, binary: binary, truncated: r.truncated };
+  return { ok: true, path: path, content: text, binary: binary, truncated: truncated || r.truncated };
 }
 
 async function remoteWriteFile(runner, p, path, content) {
   if (!path) return { ok: false, error: "path 为必填项" };
   const c = content !== undefined ? String(content) : "";
-  return await runner(p, "cat > " + shellQuotePath(path), c, MAX_BYTES);
+  if (c.length > MAX_BYTES) {
+    return { ok: false, exitCode: -1, stdout: "", stderr: "", error: "写入内容超过 " + MAX_BYTES + " 字节上限", truncated: false };
+  }
+  return await runner(p, "cat > " + shellQuotePath(path), c, MAX_BYTES, true);
 }
 
 /**
@@ -685,8 +767,9 @@ function apply(ctx, config) {
     return t.trim().slice(0, 500);
   }
 
-  /** 池化执行：复用持久会话；连接层失败（exit 255）或会话异常时清理会话并经一次性连接重试。 */
-  async function runPooled(p, cmd, stdinData, maxBytes) {
+  /** 池化执行：复用持久会话；连接层失败（exit 255）或会话异常时清理会话并经一次性连接重试。
+   *  split=true 时 stderr 与 stdout 分离返回（命令走双哨兵协议）。 */
+  async function runPooled(p, cmd, stdinData, maxBytes, split) {
     const dropSession = () => {
       const key = profileKey(p);
       const old = sessions.get(key);
@@ -694,11 +777,16 @@ function apply(ctx, config) {
     };
     try {
       const s = getSession(p);
-      const r = await s.exec(cmd, stdinData);
-      if (r.exitCode === 0) return { ok: true, exitCode: 0, stdout: r.stdout, stderr: "", error: "", truncated: false };
+      const r = await s.exec(cmd, stdinData, split);
+      const stderr = split ? String(r.stderr || "") : "";
+      if (r.exitCode === 0) return { ok: true, exitCode: 0, stdout: r.stdout, stderr: stderr, error: "", truncated: false };
       // exit 255 = ssh 连接层失败（非远程命令失败）：会话作废，下次调用重建。
       if (r.exitCode === 255) dropSession();
-      return { ok: false, exitCode: r.exitCode, stdout: r.stdout, stderr: "", error: sshErrorHint(r.exitCode === 255 ? r.stdout : String(r.stdout).trim().slice(0, 500)), truncated: false };
+      const errSource = String(stderr || r.stdout || "");
+      const error = r.exitCode === 255
+        ? sshErrorHint(errSource)
+        : (errSource.trim().slice(0, 500) || ("ssh 退出码 " + r.exitCode));
+      return { ok: false, exitCode: r.exitCode, stdout: r.stdout, stderr: stderr, error: error, truncated: false };
     } catch (e) {
       // 会话挂了 —— 清理并回退到一次性连接（相当于自动重连一次）
       dropSession();
@@ -934,7 +1022,8 @@ function apply(ctx, config) {
       const p = resolveProfile(args);
       if (!p) return { ok: false, error: "需要 profileId 或 host+user" };
       if (!args || !args.command) return { ok: false, error: "command 为必填项" };
-      return await runRemote(subprocess, p, args.command, args.stdin, undefined);
+      // 走持久会话池（stderr 分离）：首调用建立连接后，后续调用毫秒级返回。
+      return await runPooled(p, args.command, args.stdin, undefined, true);
     },
     listDir: async (args) => {
       const p = resolveProfile(args);
@@ -1130,7 +1219,10 @@ function apply(ctx, config) {
       if (!args.command) return normExec({ ok: false, error: "command 为必填项" });
       let cmd = String(args.command);
       if (tc.remotePath) cmd = "cd " + shellQuotePath(tc.remotePath) + " 2>/dev/null; " + cmd;
-      return normExec(await runRemote(subprocess, tc.profile, cmd, args.stdin, undefined));
+      // 走持久会话池（stderr 分离，双哨兵协议）：首次调用完成建连后，
+      // 后续调用不再重复 TCP 握手 + 认证，单次耗时从秒级降到毫秒级；
+      // 会话异常时 runPooled 自动重建并降级一次性连接。
+      return normExec(await runPooled(tc.profile, cmd, args.stdin, undefined, true));
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhangfengshun/dsh-remote-ssh",
-  "version": "2.1.7",
+  "version": "2.2.0",
   "description": "DSH web plugin: VSCode Remote-SSH-like remote development (SSH to supercomputers/servers, remote workspace, file explorer, integrated terminal), integrated with dsh-better-sidebar and DSH settings.",
   "keywords": [
     "dsh",