@zhangfengshun/dsh-remote-ssh 1.4.0 → 1.6.0

package/CHANGELOG.md

@@ -2,6 +2,25 @@
 
 本文件的版本号与 `package.json` 的 `version` 保持一致。每个版本对应一个 Cordis Package 快照（`pkg-N`）。
 
+## [1.6.0] — 远程搜索与文件操作工具
+### 新增
+- **内容搜索 `remote_ssh_grep`**：在远端递归搜索文件内容（`grep -rnIE`，扩展正则），支持 `include` 文件名过滤（如 `*.py`）、`ignoreCase` 忽略大小写、`maxResults` 限流（默认 200）。借鉴 dsh-remote / dsh-remote-ssh 的远程搜索，但用通用 GNU grep（超算/Linux 通用，不依赖 ripgrep）。
+- **文件名查找 `remote_ssh_glob`**：按通配符查找远程文件（`find -name`，递归），自动剥离前导 `**/` 以适配 POSIX find。
+- **创建目录 `remote_ssh_mkdir`**：`mkdir -p`（含父目录）。
+- **删除 `remote_ssh_delete`**：删除远程文件或目录（`rm -rf`，递归不询问，⚠️ 不可恢复）。
+- **移动/重命名 `remote_ssh_move`**：`mv` 移动或重命名文件/目录。
+- 上述 5 个工具均会话感知：在远程工作区会话中免填 `profileId`，相对路径基于工作区远程目录解析。
+- 「远程文件」页签新增操作栏（选中工作区或连接时显示）：🔍 搜索 / 按名查找 / 新建目录 / 重命名移动 / 删除，均以弹窗形式执行并就地显示结果。
+- 远程工作区镜像目录的 `README.md` 补全新增工具说明。
+
+## [1.5.0] — 导入 OpenSSH 配置 + 双向同步
+### 新增
+- **从 `~/.ssh/config` 导入连接**：设置小节「从 ~/.ssh/config 导入…」按钮读取本机 OpenSSH 用户配置（递归解析 `Include`），多选主机后批量导入为连接配置（`HostName` / `User` / `Port` / `IdentityFile` / `ProxyJump` 一并带入）。借鉴 Yan-Zero `dsh-remote-ssh`，免去逐条手动录入。
+- **跳板机（ProxyJump）**：连接配置新增可选 `ProxyJump` 字段，`sshArgv` 追加 `-o ProxyJump=...`，OpenSSH 原生支持；导入的带跳板机主机开箱即用。
+- **tar-over-ssh 双向同步**：新增 `syncDown`（远端 → 本地镜像）/ `syncUp`（本地镜像 → 远端）HTTP API 与 `remote_ssh_sync` / `remote_ssh_push` 模型工具，用流式管道把一条 ssh 的 stdout 喂给本地 `tar` 的 stdin（反之亦然），不经过 4MB 缓冲上限。借鉴 flymysql `dsh-remote` 的 `rw_sync` / `rw_push`，但复用现有 `ssh.exe` + `tar`，不引入 `ssh2` 依赖。
+- 「远程文件」页签在选中工作区时显示「⬇ 同步 / ⬆ 推送」按钮，同步后镜像目录装下真实远程文件，内置 `read`/`grep`/`glob` 工具可直接读取镜像。
+- `remote_ssh_sync` / `remote_ssh_push` 工具会话感知：在远程工作区会话中无需 `workspaceId`，自动识别当前工作区。
+
 ## [1.4.0] — 远程文件单开一栏预览
 ### 新增
 - 点击「远程文件」文件树中的文件，改为在 better-sidebar 中**单开一栏（独立页签）预览/编辑**，与内置「文件」页签一致，不再在文件树下方内嵌预览。新增隐藏页签类型 `remssh:editor`，同一远程文件按 (profileId, path) 去重复用。

package/README.md

@@ -8,11 +8,13 @@
 
 | 能力 | 说明 |
 | --- | --- |
-| 🔌 远程连接 | SSH 连接超算 / 服务器，密钥认证（推荐）或密码认证（需本机 `sshpass`），内置「测试连接」 |
-| 🗂️ 远程文件 | 在 better-sidebar「远程文件」页签浏览 / 打开 / 编辑 / 保存远程文件 |
+| 🔌 远程连接 | SSH 连接超算 / 服务器，密钥认证（推荐）或密码认证（需本机 `sshpass`），内置「测试连接」；支持 `ProxyJump` 跳板机 |
+| 📥 配置导入 | 一键从 `~/.ssh/config`（递归 `Include`）发现主机并批量导入连接配置 |
+| 🗂️ 远程文件 | 在 better-sidebar「远程文件」页签浏览 / 打开 / 编辑 / 保存远程文件；选中工作区后可双向同步 |
 | 💻 远程终端 | 在 better-sidebar「远程终端」页签打开 `ssh -tt` 集成终端，支持多终端并发 |
+| 🔄 双向同步 | `remote_ssh_sync`（远端 → 本地镜像）/ `remote_ssh_push`（本地镜像 → 远端），tar 流式管道，同步后内置文件工具可见 |
 | 🌐 远程工作区 | 选择远程目录创建**原生工作区**（本地镜像目录 + 原生注册），一键打开进入远程环境 |
-| 🤖 模型工具 | 5 个 `remote_ssh_*` 工具，模型可读写远程文件、执行远程命令；在远程工作区会话中免填连接参数 |
+| 🤖 模型工具 | 12 个 `remote_ssh_*` 工具，模型可读写远程文件、执行远程命令、内容搜索、文件名查找、目录/删除/移动、双向同步；在远程工作区会话中免填连接参数 |
 | 🌍 国际化 | 界面文案 + 工具描述中英双语，通过 `ctx.locale` 跟随 DSH 语言设置自动切换 |
 | 🧠 会话记忆 | 切换会话后，「远程文件」「远程终端」页签记住已选连接、浏览目录、打开的文件与终端 |
 
@@ -27,7 +29,7 @@ dsh plugin --profile <name> add /absolute/path/to/dsh-remote-ssh
 ### 发布后安装
 
 ```bash
-dsh plugin --profile <name> add @zhangfengshun/dsh-remote-ssh@1.2.0
+dsh plugin --profile <name> add @zhangfengshun/dsh-remote-ssh@1.6.0
 ```
 
 > ⚠️ 安装后需**重启 DSH** 才生效；后续仅修改 Client 半边时刷新浏览器即可。
@@ -86,6 +88,13 @@ dsh plugin --profile <name> add @zhangfengshun/dsh-remote-ssh@1.2.0
 | `remote_ssh_ls` | 列举远程目录 |
 | `remote_ssh_cat` | 读取远程文本文件（base64 传输，二进制安全） |
 | `remote_ssh_write` | 写入远程文件（覆盖写入） |
+| `remote_ssh_sync` | 远端文件同步到本地镜像目录（tar 流式管道） |
+| `remote_ssh_push` | 本地镜像目录推送回远端（tar 流式管道） |
+| `remote_ssh_grep` | 递归搜索远程文件内容（grep -rnIE，支持 include/ignoreCase） |
+| `remote_ssh_glob` | 按通配符查找远程文件（find -name，递归） |
+| `remote_ssh_mkdir` | 创建远程目录（mkdir -p） |
+| `remote_ssh_delete` | 删除远程文件或目录（rm -rf，⚠️ 不可恢复） |
+| `remote_ssh_move` | 移动/重命名远程文件或目录（mv） |
 
 **会话感知**：当会话是从远程工作区创建时，模型调用这些工具可**不填** `profileId` / `host` / `user` 等连接参数，自动复用该工作区的连接，相对路径基于该工作区远程目录解析。
 
@@ -112,7 +121,7 @@ dsh-remote-ssh/
 │  · 远程文件 / 远程终端        │ ◀────── │  · SSH：listDir/readFile/…       │
 │ ctx.slots: settings.section   │  JSON   │  · settings：profiles/workspaces  │
 │  · DSH 设置页「远程连接」      │         │  · terminals：ssh -tt 管道        │
-└───────────────────────────────┘         │ ctx.tools：5 个 remote_ssh_*     │
+└───────────────────────────────┘         │ ctx.tools：12 个 remote_ssh_*    │
                                           └───────────────┬──────────────────┘
                                                           │ SSH
                                                      远程超算 / 服务器
@@ -132,15 +141,16 @@ dsh-remote-ssh/
 1. **终端非本地 PTY**：走 `ssh -tt` 管道通道（跨平台可用）；`vim` / `htop` 等全屏程序体验受限，后续可接入 `terminals.registerBackend` + `node-pty` 真 PTY。
 2. **文件操作依赖 GNU 工具**（`find -printf`、`base64 -w0`）：目标为 Linux 超算时通用。
 3. **密码认证需本机 `sshpass`**（Windows 默认没有）；密钥认证无此依赖。
-4. **无大文件上传 / 下载**：当前读 / 写为文本流，可后续加 `scp` / `sftp`。
-5. **镜像目录对内置文件工具不可见**：远程工作区的本地镜像目录是注册占位，模型对远程文件应使用 `remote_ssh_*` 工具（镜像目录内已放置说明文件）。
+4. **同步为全量 tar**：`remote_ssh_sync` / `remote_ssh_push` 用 `tar` 流式全量同步，单次同步大目录耗时与传输量较高，后续可换 `rsync -e ssh` 增量。
+5. **原生工具编辑的是本地镜像副本**，不会自动回传 —— 须点「推送」或调用 `remote_ssh_push` 同步回远端（与 `dsh-remote` 的 `rw_sync` / `rw_push` 模型一致）。
 
 ## 路线图
 
+- [x] 从 `~/.ssh/config` 自动导入连接
+- [x] ProxyJump / 跳板机、SSH config 复用
+- [x] `tar`-over-ssh 双向同步（`scp` / `sftp` 增量同步为后续优化）
+- [ ] `rsync -e ssh` 增量同步
 - [ ] 真 PTY 终端（`terminals.registerBackend` + `node-pty`）
-- [ ] `scp` / `sftp` 上传下载
-- [ ] 从 `~/.ssh/config` 自动导入连接
-- [ ] ProxyJump / 跳板机、SSH config 复用
 - [ ] 密码凭据走 `credentials` 服务（避免明文进 argv）
 
 ## 许可证

package/lib/client.js

@@ -73,6 +73,7 @@ window.__ModuleLoader__.load({
       "settings.keyPathPlaceholder": "~/.ssh/id_rsa",
       "settings.passwordField": "密码 password",
       "settings.remoteRoot": "远程根目录 remoteRoot",
+      "settings.proxyJump": "跳板机 ProxyJump",
       "settings.test": "测试连接",
       "settings.saved": "已保存",
       "settings.connOk": "连接成功",
@@ -115,7 +116,35 @@ window.__ModuleLoader__.load({
       "flow.remoteDir": "远程目录",
       "flow.chooseRemote": "选择远程目录…",
       "flow.backLocal": "← 选择本地目录",
-      "flow.errCreate": "创建远程工作区失败"
+      "flow.errCreate": "创建远程工作区失败",
+      "settings.importSshConfig": "从 ~/.ssh/config 导入…",
+      "settings.importTitle": "导入 ~/.ssh/config 主机",
+      "settings.noneFound": "未在 ~/.ssh/config 中发现可用主机",
+      "settings.imported": "已导入 {n} 个连接",
+      "sync.down": "⬇ 同步",
+      "sync.up": "⬆ 推送",
+      "sync.syncing": "同步中…",
+      "sync.pushing": "推送中…",
+      "sync.done": "同步完成",
+      "sync.fail": "同步失败",
+      "ops.search": "🔍 搜索",
+      "ops.find": "按名查找",
+      "ops.searchPh": "正则或关键词…",
+      "ops.globPh": "*.py",
+      "ops.newDir": "📁 新建目录",
+      "ops.newDirPh": "目录名",
+      "ops.rename": "✏ 重命名/移动",
+      "ops.renamePh": "目标路径",
+      "ops.delete": "🗑 删除",
+      "ops.confirmDel": "确认删除远程文件/目录？（不可恢复）",
+      "ops.grepTitle": "远程内容搜索 (grep)",
+      "ops.globTitle": "按文件名查找 (glob)",
+      "ops.mkdirTitle": "新建远程目录",
+      "ops.moveTitle": "移动/重命名",
+      "ops.deleteTitle": "删除远程文件/目录",
+      "ops.noMatch": "无匹配",
+      "ops.done": "操作完成",
+      "ops.fail": "操作失败"
     };
     var en = {
       "tabs.files": "Remote Files",
@@ -138,6 +167,7 @@ window.__ModuleLoader__.load({
       "settings.keyPathPlaceholder": "~/.ssh/id_rsa",
       "settings.passwordField": "Password",
       "settings.remoteRoot": "Remote root (remoteRoot)",
+      "settings.proxyJump": "ProxyJump (jump host)",
       "settings.test": "Test Connection",
       "settings.saved": "Saved",
       "settings.connOk": "Connected",
@@ -180,7 +210,35 @@ window.__ModuleLoader__.load({
       "flow.remoteDir": "Remote directory",
       "flow.chooseRemote": "Choose remote directory…",
       "flow.backLocal": "← Choose local directory",
-      "flow.errCreate": "Failed to create remote workspace"
+      "flow.errCreate": "Failed to create remote workspace",
+      "settings.importSshConfig": "Import from ~/.ssh/config…",
+      "settings.importTitle": "Import ~/.ssh/config hosts",
+      "settings.noneFound": "No usable hosts found in ~/.ssh/config",
+      "settings.imported": "Imported {n} connection(s)",
+      "sync.down": "⬇ Sync",
+      "sync.up": "⬆ Push",
+      "sync.syncing": "Syncing…",
+      "sync.pushing": "Pushing…",
+      "sync.done": "Sync complete",
+      "sync.fail": "Sync failed",
+      "ops.search": "🔍 Search",
+      "ops.find": "Find by name",
+      "ops.searchPh": "regex or keyword…",
+      "ops.globPh": "*.py",
+      "ops.newDir": "📁 New dir",
+      "ops.newDirPh": "dir name",
+      "ops.rename": "✏ Rename/Move",
+      "ops.renamePh": "target path",
+      "ops.delete": "🗑 Delete",
+      "ops.confirmDel": "Confirm delete remote file/dir? (irreversible)",
+      "ops.grepTitle": "Remote content search (grep)",
+      "ops.globTitle": "Find by name (glob)",
+      "ops.mkdirTitle": "Create remote directory",
+      "ops.moveTitle": "Move/Rename",
+      "ops.deleteTitle": "Delete remote file/dir",
+      "ops.noMatch": "No match",
+      "ops.done": "Done",
+      "ops.fail": "Operation failed"
     };
     var i18n = {
       t: function (key) { return key; },
@@ -251,6 +309,63 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // ======================================================================
+    // 远程操作弹窗（grep / glob / mkdir / move / delete）
+    // ======================================================================
+    function OpsModal(props) {
+      var d = props.opsDlg;
+      var t = props.t;
+      var patchOps = props.patchOps;
+      var runOps = props.runOps;
+      var title = ({
+        grep: t("ops.grepTitle"), glob: t("ops.globTitle"), mkdir: t("ops.mkdirTitle"),
+        move: t("ops.moveTitle"), delete: t("ops.deleteTitle")
+      })[d.type] || "";
+      var isGrep = d.type === "grep";
+      var isGlob = d.type === "glob";
+      var isMove = d.type === "move";
+      var isDel = d.type === "delete";
+      // 结果渲染
+      var resultEl = null;
+      if (d.result) {
+        var r = d.result;
+        if (isGrep) {
+          var ms = r.matches || [];
+          resultEl = h("div", { style: { maxHeight: 260, overflow: "auto", marginTop: 8, fontSize: 11, whiteSpace: "pre-wrap", fontFamily: "monospace" } },
+            !r.ok ? h("div", { className: "rssh-err" }, r.error || t("ops.fail")) :
+            ms.length === 0 ? h("div", { className: "rssh-muted" }, t("ops.noMatch")) :
+            ms.map(function (m, i) { return h("div", { key: i }, m.file + ":" + m.line + ": " + m.content); }),
+            r.truncated ? h("div", { className: "rssh-muted" }, "…") : null
+          );
+        } else if (isGlob) {
+          var fs2 = r.files || [];
+          resultEl = h("div", { style: { maxHeight: 260, overflow: "auto", marginTop: 8, fontSize: 11, whiteSpace: "pre-wrap", fontFamily: "monospace" } },
+            !r.ok ? h("div", { className: "rssh-err" }, r.error || t("ops.fail")) :
+            fs2.length === 0 ? h("div", { className: "rssh-muted" }, t("ops.noMatch")) :
+            fs2.map(function (f, i) { return h("div", { key: i }, f); })
+          );
+        } else {
+          // exec 结果（mkdir/move/delete）
+          resultEl = h("div", { style: { marginTop: 8 } },
+            r.ok ? h("div", { className: "rssh-ok" }, t("ops.done") + (r.stderr ? "  " + String(r.stderr).slice(0, 200) : "")) :
+            h("div", { className: "rssh-err" }, (r.error || r.stderr || t("ops.fail")))
+          );
+        }
+      }
+      return h(Modal, { open: true, onClose: props.close, title: title, closeLabel: t("common.close"), className: "rssh-flow-dialog" },
+        h("div", { style: { display: "flex", flexDirection: "column", gap: 6 } },
+          h("input", { className: "rssh-input", value: d.p1, onChange: function (e) { patchOps({ p1: e.target.value }); }, placeholder: isGrep ? t("ops.searchPh") : (isGlob ? t("ops.globPh") : t("ops.newDirPh")) }),
+          isGrep ? h("input", { className: "rssh-input", value: d.p2, onChange: function (e) { patchOps({ p2: e.target.value }); }, placeholder: "*.py (include)" }) : null,
+          isMove ? h("input", { className: "rssh-input", value: d.p2, onChange: function (e) { patchOps({ p2: e.target.value }); }, placeholder: t("ops.renamePh") }) : null,
+          h("div", { className: "rssh-actions" },
+            h("button", { className: "rssh-btn", onClick: runOps, disabled: d.busy }, d.busy ? t("common.processing") : (isDel ? t("ops.delete") : t("common.save"))),
+            h("button", { className: "rssh-btn", onClick: props.close, disabled: d.busy }, t("common.close"))
+          ),
+          resultEl
+        )
+      );
+    }
+
     // ======================================================================
     // 远程文件页签
     // ======================================================================
@@ -267,6 +382,8 @@ window.__ModuleLoader__.load({
       var [err, setErr] = React.useState(null);
       var [loading, setLoading] = React.useState(false);
       var [defaultDir, setDefaultDir] = useSessionMemory(sessionId, "defaultDir", "");
+      var [syncSt, setSyncSt] = React.useState(null); // { busy, msg, ok }
+      var [opsDlg, setOpsDlg] = React.useState(null); // { type, p1, p2, result, busy }
 
       React.useEffect(function () {
         api("listWorkspaces").then(function (r) { if (r && r.ok) setWorkspaces(r.workspaces || []); });
@@ -312,6 +429,81 @@ window.__ModuleLoader__.load({
         });
       }
 
+      function doSync(direction) {
+        if (!wsId) return;
+        var ws = workspaces.find(function (w) { return w.id === wsId; });
+        if (!ws) return;
+        setSyncSt({ busy: true, msg: direction === "down" ? t("sync.syncing") : t("sync.pushing"), ok: null });
+        var method = direction === "down" ? "syncDown" : "syncUp";
+        api(method, { workspaceId: wsId }).then(function (r) {
+          if (r && r.ok) setSyncSt({ busy: false, msg: direction === "down" ? t("sync.done") : t("sync.done"), ok: true });
+          else setSyncSt({ busy: false, msg: (r && r.error) || t("sync.fail"), ok: false });
+        });
+      }
+
+      function activeProfileId() {
+        if (wsId) {
+          var ws = workspaces.find(function (w) { return w.id === wsId; });
+          if (ws) return ws.profileId;
+        }
+        return profileId;
+      }
+      function opsBase() {
+        if (wsId) {
+          var ws = workspaces.find(function (w) { return w.id === wsId; });
+          if (ws) return ws.remotePath || path || "~";
+        }
+        return path || "~";
+      }
+      function openOps(type) {
+        var init = { type: type, p1: "", p2: "", result: null, busy: false };
+        if (type === "mkdir") init.p1 = path ? (path.replace(/\/+$/, "") + "/") : "";
+        if (type === "move") { init.p1 = path ? (path.replace(/\/+$/, "") + "/") : ""; init.p2 = path ? (path.replace(/\/+$/, "") + "/") : ""; }
+        if (type === "delete") init.p1 = path ? (path.replace(/\/+$/, "") + "/") : "";
+        setOpsDlg(init);
+      }
+      function patchOps(patch) {
+        setOpsDlg(function (d) { var n = {}; for (var k in d) n[k] = d[k]; for (var k2 in patch) n[k2] = patch[k2]; return n; });
+      }
+      function runOps() {
+        if (!opsDlg) return;
+        var pid = activeProfileId();
+        if (!pid) { patchOps({ result: { ok: false, msg: t("ops.fail") }, busy: false }); return; }
+        var base = opsBase();
+        var d = opsDlg;
+        patchOps({ busy: true, result: null });
+        function resolveP(p) {
+          if (!p) return p;
+          var c = String(p).charAt(0);
+          if (c === "/" || c === "~") return p;
+          return base.replace(/\/+$/, "") + "/" + p;
+        }
+        if (d.type === "grep") {
+          api("grep", { profileId: pid, pattern: d.p1, path: base, include: d.p2 || undefined }).then(function (r) {
+            patchOps({ busy: false, result: r });
+          });
+        } else if (d.type === "glob") {
+          api("glob", { profileId: pid, pattern: d.p1, path: base }).then(function (r) {
+            patchOps({ busy: false, result: r });
+          });
+        } else if (d.type === "mkdir") {
+          api("mkdir", { profileId: pid, path: resolveP(d.p1) }).then(function (r) {
+            patchOps({ busy: false, result: r });
+            if (r && r.ok) { setErr(null); load(pid, path); }
+          });
+        } else if (d.type === "move") {
+          api("move", { profileId: pid, src: resolveP(d.p1), dst: resolveP(d.p2) }).then(function (r) {
+            patchOps({ busy: false, result: r });
+            if (r && r.ok) { setErr(null); load(pid, path); }
+          });
+        } else if (d.type === "delete") {
+          api("deleteFile", { profileId: pid, path: resolveP(d.p1) }).then(function (r) {
+            patchOps({ busy: false, result: r });
+            if (r && r.ok) { setErr(null); load(pid, path); }
+          });
+        }
+      }
+
       function openEntry(e) {
         var base = path ? (path.replace(/\/+$/, "") + "/" + e.name) : e.name;
         if (e.type === "directory") {
@@ -368,8 +560,21 @@ window.__ModuleLoader__.load({
             h("button", { className: "rssh-btn", onClick: function () { load(profileId, path); } }, t("common.open")),
             h("button", { className: "rssh-btn", onClick: goUp }, t("common.up"))
           ),
+          wsId ? h("div", { className: "rssh-pathbar" },
+            h("button", { className: "rssh-btn", onClick: function () { doSync("down"); }, disabled: syncSt && syncSt.busy }, t("sync.down")),
+            h("button", { className: "rssh-btn", onClick: function () { doSync("up"); }, disabled: syncSt && syncSt.busy }, t("sync.up")),
+            syncSt ? h("span", { className: syncSt.ok === false ? "rssh-err" : (syncSt.ok ? "rssh-ok" : "rssh-muted"), style: { flex: 1, fontSize: 11 } }, syncSt.msg) : null
+          ) : null,
+          (wsId || profileId) ? h("div", { className: "rssh-pathbar", style: { flexWrap: "wrap" } },
+            h("button", { className: "rssh-btn", onClick: function () { openOps("grep"); } }, t("ops.search")),
+            h("button", { className: "rssh-btn", onClick: function () { openOps("glob"); } }, t("ops.find")),
+            h("button", { className: "rssh-btn", onClick: function () { openOps("mkdir"); } }, t("ops.newDir")),
+            h("button", { className: "rssh-btn", onClick: function () { openOps("move"); } }, t("ops.rename")),
+            h("button", { className: "rssh-btn", onClick: function () { openOps("delete"); } }, t("ops.delete"))
+          ) : null,
           loading ? h("div", { className: "rssh-muted" }, t("common.loading")) : null,
-          err ? h("div", { className: "rssh-err", style: { whiteSpace: "pre-wrap" } }, err) : null
+          err ? h("div", { className: "rssh-err", style: { whiteSpace: "pre-wrap" } }, err) : null,
+          opsDlg ? h(OpsModal, { opsDlg: opsDlg, patchOps: patchOps, runOps: runOps, close: function () { setOpsDlg(null); }, t: t }) : null
         ),
         h("div", { style: { flex: 1, minHeight: 0, overflowY: "auto", marginTop: 6 } },
           entries.map(function (e) {
@@ -666,9 +871,10 @@ window.__ModuleLoader__.load({
     function SettingsSection(props) {
       var t = useT();
       var [profiles, setProfiles] = React.useState([]);
-      var [form, setForm] = React.useState({ name: "", host: "", port: "22", user: "", authMethod: "key", keyPath: "", password: "", remoteRoot: "~" });
+      var [form, setForm] = React.useState({ name: "", host: "", port: "22", user: "", authMethod: "key", keyPath: "", password: "", remoteRoot: "~", proxyJump: "" });
       var [result, setResult] = React.useState(null);
       var [busy, setBusy] = React.useState(false);
+      var [importDlg, setImportDlg] = React.useState(null);
       var set = function (k, v) { setForm(function (f) { var n = {}; for (var key in f) n[key] = f[key]; n[k] = v; return n; }); };
 
       function reload() { api("listProfiles").then(function (r) { if (r && r.ok) setProfiles(r.profiles || []); }); }
@@ -680,7 +886,7 @@ window.__ModuleLoader__.load({
           setBusy(false);
           if (r && r.ok) {
             setProfiles(r.profiles || []);
-            setForm({ name: "", host: "", port: "22", user: "", authMethod: "key", keyPath: "", password: "", remoteRoot: "~" });
+            setForm({ name: "", host: "", port: "22", user: "", authMethod: "key", keyPath: "", password: "", remoteRoot: "~", proxyJump: "" });
             setResult({ ok: true, msg: t("settings.saved") });
           } else setResult({ ok: false, msg: (r && r.error) || t("settings.errSave") });
         });
@@ -697,6 +903,47 @@ window.__ModuleLoader__.load({
         api("deleteProfile", { id: p.id }).then(function (r) { if (r && r.ok) { setProfiles(r.profiles || []); } });
       }
 
+      function openImport() {
+        setImportDlg({ loading: true, hosts: [], selected: {} });
+        api("listSshConfigHosts").then(function (r) {
+          if (r && r.ok) {
+            var hosts = r.hosts || [];
+            var sel = {};
+            hosts.forEach(function (h) { sel[h.name + "|" + h.hostName] = true; });
+            setImportDlg({ loading: false, hosts: hosts, selected: sel });
+          } else {
+            setImportDlg({ loading: false, hosts: [], selected: {}, error: (r && r.error) || t("settings.noneFound") });
+          }
+        });
+      }
+      function toggleImport(key) {
+        setImportDlg(function (d) {
+          var sel = {}; for (var k in d.selected) sel[k] = d.selected[k];
+          sel[key] = !sel[key];
+          return Object.assign({}, d, { selected: sel });
+        });
+      }
+      function doImport() {
+        if (!importDlg) return;
+        var picked = importDlg.hosts.filter(function (h) { return importDlg.selected[h.name + "|" + h.hostName]; });
+        setBusy(true);
+        var i = 0;
+        function next() {
+          if (i >= picked.length) {
+            setBusy(false); setImportDlg(null);
+            setResult({ ok: true, msg: t("settings.imported").replace("{n}", String(picked.length)) });
+            reload();
+            return;
+          }
+          var h = picked[i++];
+          api("saveProfile", {
+            name: h.name, host: h.hostName, port: h.port || 22, user: h.user || "",
+            authMethod: "key", keyPath: h.identityFile || "", password: "", remoteRoot: "~", proxyJump: h.proxyJump || ""
+          }).then(next);
+        }
+        next();
+      }
+
       return h("div", null,
         h("p", { className: "rssh-muted" }, t("settings.desc")),
         profiles.map(function (p) {
@@ -726,9 +973,33 @@ window.__ModuleLoader__.load({
           form.authMethod === "key" ? Field({ label: t("settings.keyPath"), value: form.keyPath, onChange: function (v) { set("keyPath", v); }, placeholder: t("settings.keyPathPlaceholder") }) : null,
           form.authMethod === "password" ? Field({ label: t("settings.passwordField"), type: "password", value: form.password, onChange: function (v) { set("password", v); } }) : null,
           Field({ label: t("settings.remoteRoot"), value: form.remoteRoot, onChange: function (v) { set("remoteRoot", v); }, placeholder: "~/project" }),
-          h("button", { className: "rssh-btn", onClick: save, disabled: busy }, busy ? t("common.processing") : t("common.save"))
+          Field({ label: t("settings.proxyJump"), value: form.proxyJump, onChange: function (v) { set("proxyJump", v); }, placeholder: "bastion.example.com" }),
+          h("div", { className: "rssh-actions" },
+            h("button", { className: "rssh-btn", onClick: save, disabled: busy }, busy ? t("common.processing") : t("common.save")),
+            h("button", { className: "rssh-btn", onClick: openImport, disabled: busy }, t("settings.importSshConfig"))
+          )
         ),
-        result ? h("div", { className: result.ok ? "rssh-ok" : "rssh-err", style: { whiteSpace: "pre-wrap", marginTop: 6 } }, result.msg) : null
+        result ? h("div", { className: result.ok ? "rssh-ok" : "rssh-err", style: { whiteSpace: "pre-wrap", marginTop: 6 } }, result.msg) : null,
+        importDlg ? h(Modal, { open: true, onClose: function () { if (!busy) setImportDlg(null); }, title: t("settings.importTitle"), closeLabel: t("common.close") },
+          importDlg.loading ? h("div", { className: "rssh-muted" }, t("common.loading")) :
+          importDlg.error ? h("div", { className: "rssh-err" }, importDlg.error) :
+          (importDlg.hosts.length === 0 ? h("div", { className: "rssh-muted" }, t("settings.noneFound")) :
+            h("div", null,
+              importDlg.hosts.map(function (hh) {
+                var key = hh.name + "|" + hh.hostName;
+                return h("label", { key: key, className: "rssh-tree-item", style: { cursor: "pointer" } },
+                  h("input", { type: "checkbox", checked: !!importDlg.selected[key], onChange: function () { toggleImport(key); } }),
+                  h("span", { className: "rssh-tree-dir" }, hh.name),
+                  h("span", { className: "rssh-sub" }, (hh.user || "?") + "@" + hh.hostName + ":" + (hh.port || 22) + (hh.proxyJump ? "  → " + hh.proxyJump : ""))
+                );
+              }),
+              h("div", { className: "rssh-actions", style: { marginTop: 8 } },
+                h("button", { className: "rssh-btn", onClick: doImport, disabled: busy }, busy ? t("common.processing") : t("common.save")),
+                h("button", { className: "rssh-btn", onClick: function () { setImportDlg(null); }, disabled: busy }, t("common.close"))
+              )
+            )
+          )
+        ) : null
       );
     }
 

package/lib/index.js

@@ -11,7 +11,7 @@
 import z from "schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { settingsNamespace } from "@deepseek-ai/dsh-settings";
-import { mkdir, rm, writeFile } from "node:fs/promises";
+import { mkdir, rm, writeFile, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -36,7 +36,8 @@ const ProfileSchema = z.object({
   authMethod: z.string().default("key"),
   keyPath: z.string().default(""),
   password: z.string().default("").role("secret"),
-  remoteRoot: z.string().default("~")
+  remoteRoot: z.string().default("~"),
+  proxyJump: z.string().default("")
 });
 /** 远程工作区 schema（连接配置 + 远程根目录 + 本地镜像目录）。 */
 const WorkspaceSchema = z.object({
@@ -68,6 +69,92 @@ function shellQuotePath(s) {
   return shellQuote(str);
 }
 
+/**
+ * 解析 OpenSSH 用户配置（~/.ssh/config），递归处理 Include，发现其中的具体主机。
+ * 借鉴 Yan-Zero dsh-remote-ssh：自动读取 OpenSSH 配置发现主机，免去手动录入。
+ * 返回 [{ name, hostName, user, port, identityFile, proxyJump }]。
+ */
+function expandSshPath(raw) {
+  const s = String(raw || "").trim();
+  if (s === "~") return join(homedir());
+  if (s.startsWith("~/")) return join(homedir(), s.slice(2));
+  return s;
+}
+
+async function parseSshConfigFile(filePath, seen) {
+  const real = filePath;
+  if (seen.has(real)) return [];
+  seen.add(real);
+  let text;
+  try {
+    text = await readFile(filePath, "utf8");
+  } catch (e) {
+    return [];
+  }
+  const hosts = [];
+  let cur = null;
+  const lines = text.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const hash = raw.indexOf("#");
+    const line = (hash >= 0 ? raw.slice(0, hash) : raw).trim();
+    if (!line) continue;
+    const sp = line.search(/\s+/);
+    if (sp < 0) continue;
+    const key = line.slice(0, sp).toLowerCase();
+    const val = line.slice(sp).trim();
+    if (key === "host") {
+      // 多个名字空格分隔；含通配符 * / ? 的跳过
+      const names = val.split(/\s+/);
+      cur = null;
+      for (const n of names) {
+        if (n && !/[*?]/.test(n)) {
+          cur = { name: n, hostName: "", user: "", port: 22, identityFile: "", proxyJump: "" };
+          hosts.push(cur);
+          break;
+        }
+      }
+    } else if (cur) {
+      if (key === "hostname") cur.hostName = val;
+      else if (key === "user") cur.user = val;
+      else if (key === "port") { const pn = parseInt(val, 10); if (!isNaN(pn)) cur.port = pn; }
+      else if (key === "identityfile") cur.identityFile = expandSshPath(val);
+      else if (key === "proxyjump") cur.proxyJump = val;
+      else if (key === "include") {
+        // 递归 Include（相对 ~/.ssh/ 或绝对）
+        for (const inc of val.split(/\s+/)) {
+          if (!inc) continue;
+          const incPath = expandSshPath(inc);
+          const sub = await parseSshConfigFile(incPath, seen);
+          for (const h of sub) hosts.push(h);
+        }
+      }
+    }
+  }
+  return hosts;
+}
+
+async function listSshConfigHosts() {
+  const cfg = join(homedir(), ".ssh", "config");
+  const seen = new Set();
+  let hosts = [];
+  try {
+    hosts = await parseSshConfigFile(cfg, seen);
+  } catch (e) {
+    return { ok: false, error: "读取 ~/.ssh/config 失败: " + String(e && e.message ? e.message : e) };
+  }
+  // 过滤掉没有 hostName 的占位条目；保留 user 默认
+  const out = hosts.filter((h) => h.hostName).map((h) => ({
+    name: h.name,
+    hostName: h.hostName,
+    user: h.user || "",
+    port: h.port || 22,
+    identityFile: h.identityFile || "",
+    proxyJump: h.proxyJump || ""
+  }));
+  return { ok: true, hosts: out };
+}
+
 function sshArgv(p, remoteCmd, tty) {
   const opts = ["ssh"];
   if (tty) opts.push("-tt");
@@ -76,6 +163,7 @@ function sshArgv(p, remoteCmd, tty) {
   opts.push("-o", "ConnectTimeout=15");
   opts.push("-o", "ServerAliveInterval=30");
   opts.push("-o", "ServerAliveCountMax=3");
+  if (p.proxyJump) opts.push("-o", "ProxyJump=" + String(p.proxyJump));
   if (p.authMethod === "key" && p.keyPath) opts.push("-i", p.keyPath);
   const target = String(p.user || "") + "@" + String(p.host || "");
   const head = (p.authMethod === "password" && p.password) ? ["sshpass", "-p", String(p.password)] : [];
@@ -171,6 +259,153 @@ async function remoteWriteFile(subprocess, p, path, content) {
   return await runRemote(subprocess, p, "cat > " + shellQuotePath(path), c, MAX_BYTES);
 }
 
+/**
+ * 在远端递归搜索文件内容（grep -rnIE）。借鉴 dsh-remote / dsh-remote-ssh 的远程内容搜索，
+ * 但用通用的 GNU grep（超算/Linux 通用），不依赖 ripgrep。
+ * exit 1 = 无匹配（ok，空结果）；exit 0 = 有匹配；exit 2 = 出错。
+ */
+async function remoteGrep(subprocess, p, pattern, path, opts) {
+  opts = opts || {};
+  const target = path || p.remoteRoot || "~";
+  const parts = ["grep", "-rnIE"];
+  if (opts.ignoreCase) parts.push("-i");
+  if (opts.include) parts.push("--include=" + String(opts.include));
+  parts.push("--", shellQuote(pattern), shellQuotePath(target));
+  const cmd = parts.join(" ");
+  const r = await runRemote(subprocess, p, cmd, undefined, MAX_BYTES);
+  if (r.exitCode === 1 || (r.ok && !r.stdout)) {
+    return { ok: true, pattern: pattern, path: target, matches: [], truncated: false, error: "" };
+  }
+  if (r.exitCode > 1 && !r.ok) {
+    const err = (r.stderr || r.error || "").trim();
+    if (err && !r.stdout) return { ok: false, pattern: pattern, path: target, matches: [], truncated: false, error: err };
+  }
+  const all = [];
+  const lines = String(r.stdout || "").split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line) continue;
+    const c1 = line.indexOf(":");
+    if (c1 < 0) { all.push({ file: line, line: 0, content: "" }); continue; }
+    const file = line.slice(0, c1);
+    const rest = line.slice(c1 + 1);
+    const c2 = rest.indexOf(":");
+    if (c2 < 0) { all.push({ file: file, line: 0, content: rest }); continue; }
+    const ln = parseInt(rest.slice(0, c2), 10);
+    all.push({ file: file, line: isNaN(ln) ? 0 : ln, content: rest.slice(c2 + 1) });
+  }
+  const max = parseInt(String(opts.maxResults || 200), 10) || 200;
+  const truncated = all.length > max || !!r.truncated;
+  const matches = all.slice(0, max);
+  return { ok: true, pattern: pattern, path: target, matches: matches, truncated: truncated, error: "" };
+}
+
+/**
+ * 在远端按 glob 模式查找文件（find -name）。find 已递归；pattern 为 basename 通配
+ * （如 .py 后缀），自动剥离前导双星号-斜杠与星号-斜杠以适配 POSIX find -name。
+ */
+async function remoteGlob(subprocess, p, pattern, path, opts) {
+  opts = opts || {};
+  const target = path || p.remoteRoot || "~";
+  let pat = String(pattern || "").trim();
+  pat = pat.replace(/^(\*\*\/|\*\/)+/, "");
+  const max = parseInt(String(opts.maxResults || 500), 10) || 500;
+  const cmd = "find " + shellQuotePath(target) + " -name " + shellQuote(pat) + " -printf '%p\\n' 2>/dev/null | sort | head -n " + max;
+  const r = await runRemote(subprocess, p, cmd, undefined, MAX_BYTES);
+  const files = String(r.stdout || "").split("\n").filter(function (s) { return !!s; });
+  return { ok: true, pattern: pattern, path: target, files: files, truncated: !!r.truncated, error: "" };
+}
+
+/**
+ * tar-over-ssh 双向同步（借鉴 flymysql dsh-remote 的 SFTP 镜像同步，但复用现有 ssh.exe + tar，
+ * 不引入 ssh2 依赖）。用流式管道把一条 ssh 的 stdout 喂给本地 tar 的 stdin（反之亦然），
+ * 不经过 4MB Buffer 上限。
+ */
+function spawnOne(subprocess, argv, stdio, cwd) {
+  return subprocess.spawn({ argv: argv, cwd: cwd || process.cwd(), stdio: stdio, graceMs: 60000 });
+}
+
+function readCollected(handle, name) {
+  if (!handle || !handle.collected || !handle.collected[name]) return "";
+  const r = handle.collected[name].readFrom(0);
+  return r ? r.text : "";
+}
+
+/** 远端 → 本地镜像：先清空 mirror，再 tar 展开到 mirror。 */
+async function remoteSyncDown(subprocess, p, remotePath, mirrorPath) {
+  if (!remotePath) return { ok: false, error: "remotePath 为必填项" };
+  if (!mirrorPath) return { ok: false, error: "mirrorPath 为必填项" };
+  try { await rm(mirrorPath, { recursive: true, force: true }); } catch (e) {}
+  try { await mkdir(mirrorPath, { recursive: true }); } catch (e) {
+    return { ok: false, error: "创建镜像目录失败: " + String(e && e.message ? e.message : e) };
+  }
+  const COLLECT = { maxBytes: 1024 * 1024, spill: { maxBytes: 1024 * 1024 } };
+  let sshH, tarH;
+  try {
+    sshH = spawnOne(subprocess, sshArgv(p, "tar cf - -C " + shellQuotePath(remotePath) + " ."), {
+      stdin: "ignore", stdout: "pipe", stderr: COLLECT
+    });
+    tarH = spawnOne(subprocess, ["tar", "xf", "-", "-C", mirrorPath], {
+      stdin: "pipe", stdout: "ignore", stderr: COLLECT
+    });
+  } catch (e) {
+    return { ok: false, error: "spawn 失败: " + String(e && e.message ? e.message : e) };
+  }
+  let pipeErr = "";
+  try {
+    if (sshH.stdout && tarH.stdin) sshH.stdout.pipe(tarH.stdin);
+    else pipeErr = "stdout/stdin 管道不可用（subprocess 未暴露原始流）";
+  } catch (e) { pipeErr = String(e && e.message ? e.message : e); }
+  let sshOut, tarOut;
+  try { sshOut = await sshH.done; } catch (e) { sshOut = { exitCode: -1 }; }
+  try { tarOut = await tarH.done; } catch (e) { tarOut = { exitCode: -1 }; }
+  const sshErr = readCollected(sshH, "stderr");
+  const tarErr = readCollected(tarH, "stderr");
+  // ssh 正常退出且 tar 正常退出才算成功
+  if (sshOut.exitCode === 0 && tarOut.exitCode === 0) return { ok: true, mirrorPath: mirrorPath };
+  const parts = [];
+  if (pipeErr) parts.push("管道: " + pipeErr);
+  if (sshOut.exitCode !== 0) parts.push("ssh 退出码 " + sshOut.exitCode + (sshErr ? ": " + sshErr.slice(0, 500) : ""));
+  if (tarOut.exitCode !== 0) parts.push("tar 退出码 " + tarOut.exitCode + (tarErr ? ": " + tarErr.slice(0, 500) : ""));
+  if (!parts.length) parts.push("远端可能缺少 tar，或本机无 tar.exe");
+  return { ok: false, error: "同步失败: " + parts.join("；") };
+}
+
+/** 本地镜像 → 远端：本地 tar 打包喂给远端 tar 展开。 */
+async function remoteSyncUp(subprocess, p, remotePath, mirrorPath) {
+  if (!remotePath) return { ok: false, error: "remotePath 为必填项" };
+  if (!mirrorPath) return { ok: false, error: "mirrorPath 为必填项" };
+  const COLLECT = { maxBytes: 1024 * 1024, spill: { maxBytes: 1024 * 1024 } };
+  let tarH, sshH;
+  try {
+    tarH = spawnOne(subprocess, ["tar", "cf", "-", "-C", mirrorPath, "."], {
+      stdin: "ignore", stdout: "pipe", stderr: COLLECT
+    });
+    sshH = spawnOne(subprocess, sshArgv(p, "tar xf - -C " + shellQuotePath(remotePath)), {
+      stdin: "pipe", stdout: "ignore", stderr: COLLECT
+    });
+  } catch (e) {
+    return { ok: false, error: "spawn 失败: " + String(e && e.message ? e.message : e) };
+  }
+  let pipeErr = "";
+  try {
+    if (tarH.stdout && sshH.stdin) tarH.stdout.pipe(sshH.stdin);
+    else pipeErr = "stdout/stdin 管道不可用（subprocess 未暴露原始流）";
+  } catch (e) { pipeErr = String(e && e.message ? e.message : e); }
+  let tarOut, sshOut;
+  try { tarOut = await tarH.done; } catch (e) { tarOut = { exitCode: -1 }; }
+  try { sshOut = await sshH.done; } catch (e) { sshOut = { exitCode: -1 }; }
+  const tarErr = readCollected(tarH, "stderr");
+  const sshErr = readCollected(sshH, "stderr");
+  if (tarOut.exitCode === 0 && sshOut.exitCode === 0) return { ok: true, remotePath: remotePath };
+  const parts = [];
+  if (pipeErr) parts.push("管道: " + pipeErr);
+  if (tarOut.exitCode !== 0) parts.push("tar 退出码 " + tarOut.exitCode + (tarErr ? ": " + tarErr.slice(0, 500) : ""));
+  if (sshOut.exitCode !== 0) parts.push("ssh 退出码 " + sshOut.exitCode + (sshErr ? ": " + sshErr.slice(0, 500) : ""));
+  if (!parts.length) parts.push("远端可能缺少 tar，或本机无 tar.exe");
+  return { ok: false, error: "推送失败: " + parts.join("；") };
+}
+
 function normExec(r) {
   return {
     ok: !!r.ok,
@@ -265,6 +500,13 @@ function remoteWorkspaceReadme(profileName, remotePath) {
     "- `remote_ssh_cat`       — read a remote file / 读取远程文件",
     "- `remote_ssh_write`     — write a remote file / 写入远程文件",
     "- `remote_ssh_exec`      — run a command on the remote host (like a terminal) / 在远程执行命令",
+    "- `remote_ssh_grep`      — search file contents (recursive grep) / 递归搜索文件内容",
+    "- `remote_ssh_glob`      — find files by glob pattern / 按通配符查找文件",
+    "- `remote_ssh_mkdir`     — create a directory (mkdir -p) / 创建目录",
+    "- `remote_ssh_delete`    — delete a file or directory (rm -rf) / 删除文件或目录",
+    "- `remote_ssh_move`      — move/rename a file or directory (mv) / 移动或重命名",
+    "- `remote_ssh_sync`      — sync remote files to this local mirror / 同步远端文件到本地镜像",
+    "- `remote_ssh_push`      — push local mirror changes back to remote / 推送本地改动回远端",
     "- `remote_ssh_profiles`  — list profiles and the current remote-workspace context / 查看配置与当前上下文",
     "",
     "Workspace info / 工作区信息：",
@@ -346,6 +588,16 @@ function apply(ctx, config) {
     return { profile: null, remotePath: undefined };
   }
 
+  /** 解析同步工具的目标工作区：显式 workspaceId 优先，其次当前会话的远程工作区。 */
+  function resolveWorkspace(args, exec) {
+    const a = args || {};
+    const workspaces = settingsFace.read().workspaces;
+    if (a.workspaceId) {
+      return workspaces.find((w) => w.id === a.workspaceId) || null;
+    }
+    return remoteContextFor(exec);
+  }
+
   /** 相对路径拼到远程工作目录下，绝对路径（/、~、盘符）原样返回。 */
   function resolveRemotePath(path, base) {
     if (!base) return path || "";
@@ -357,6 +609,8 @@ function apply(ctx, config) {
 
   const api = {
     listProfiles: async () => ({ ok: true, profiles: settingsFace.read().profiles }),
+    /** 读取本机 ~/.ssh/config 发现的主机（借鉴 Yan-Zero dsh-remote-ssh）。 */
+    listSshConfigHosts: async () => listSshConfigHosts(),
     saveProfile: async (args) => {
       const p = args || {};
       if (!p.host || !p.user) return { ok: false, error: "host 和 user 为必填项" };
@@ -372,7 +626,8 @@ function apply(ctx, config) {
         authMethod: p.authMethod || "key",
         keyPath: p.keyPath || "",
         password: p.password || "",
-        remoteRoot: p.remoteRoot || "~"
+        remoteRoot: p.remoteRoot || "~",
+        proxyJump: p.proxyJump || ""
       };
       if (existing) {
         const i = profiles.indexOf(existing);
@@ -485,6 +740,52 @@ function apply(ctx, config) {
       if (!p) return { ok: false, error: "需要 profileId 或 host+user" };
       return await remoteWriteFile(subprocess, p, args && args.path, args && args.content);
     },
+    grep: async (args) => {
+      const p = resolveProfile(args);
+      if (!p) return { ok: false, error: "需要 profileId 或 host+user" };
+      return await remoteGrep(subprocess, p, args && args.pattern, args && args.path, args || {});
+    },
+    glob: async (args) => {
+      const p = resolveProfile(args);
+      if (!p) return { ok: false, error: "需要 profileId 或 host+user" };
+      return await remoteGlob(subprocess, p, args && args.pattern, args && args.path, args || {});
+    },
+    mkdir: async (args) => {
+      const p = resolveProfile(args);
+      if (!p) return { ok: false, error: "需要 profileId 或 host+user" };
+      if (!args || !args.path) return { ok: false, error: "path 为必填项" };
+      return await runRemote(subprocess, p, "mkdir -p " + shellQuotePath(args.path), undefined, undefined);
+    },
+    deleteFile: async (args) => {
+      const p = resolveProfile(args);
+      if (!p) return { ok: false, error: "需要 profileId 或 host+user" };
+      if (!args || !args.path) return { ok: false, error: "path 为必填项" };
+      return await runRemote(subprocess, p, "rm -rf " + shellQuotePath(args.path), undefined, undefined);
+    },
+    move: async (args) => {
+      const p = resolveProfile(args);
+      if (!p) return { ok: false, error: "需要 profileId 或 host+user" };
+      if (!args || !args.src || !args.dst) return { ok: false, error: "src 和 dst 为必填项" };
+      return await runRemote(subprocess, p, "mv " + shellQuotePath(args.src) + " " + shellQuotePath(args.dst), undefined, undefined);
+    },
+    /** 远端 → 本地镜像（按工作区）。 */
+    syncDown: async (args) => {
+      const a = args || {};
+      const ws = settingsFace.read().workspaces.find((w) => w.id === (a.workspaceId || a.id));
+      if (!ws) return { ok: false, error: "未找到远程工作区" };
+      const p = getProfile(ws.profileId);
+      if (!p) return { ok: false, error: "未找到连接配置" };
+      return await remoteSyncDown(subprocess, p, ws.remotePath, ws.mirrorPath);
+    },
+    /** 本地镜像 → 远端（按工作区）。 */
+    syncUp: async (args) => {
+      const a = args || {};
+      const ws = settingsFace.read().workspaces.find((w) => w.id === (a.workspaceId || a.id));
+      if (!ws) return { ok: false, error: "未找到远程工作区" };
+      const p = getProfile(ws.profileId);
+      if (!p) return { ok: false, error: "未找到连接配置" };
+      return await remoteSyncUp(subprocess, p, ws.remotePath, ws.mirrorPath);
+    },
     spawnTerminal: async (args) => {
       const p = resolveProfile(args);
       if (!p) return { ok: false, error: "需要 profileId 或 host+user" };
@@ -681,6 +982,172 @@ function apply(ctx, config) {
     }
   });
 
+  // 同步：把远程工作区的文件同步到本地镜像目录（syncDown），或把本地镜像改动推回远端（syncUp）。
+  // 借鉴 flymysql dsh-remote 的 rw_sync / rw_push，但用 tar-over-ssh 流式管道，不引入 ssh2。
+  const syncDesc = "按远程工作区双向同步：sync 把远端文件同步到本地镜像目录，push 把本地镜像改动推回远端。" +
+    "用 workspaceId 指定工作区，或留空在当前远程工作区会话中自动识别。" +
+    "Sync/push a remote workspace to its local mirror (or back). Pass workspaceId, or omit it inside a remote-workspace session.";
+  const syncParams = {
+    workspaceId: { type: "string", description: "远程工作区 id（留空则在当前远程工作区会话中自动识别）。" }
+  };
+  const syncOutput = {
+    schema: { type: "object", additionalProperties: false, properties: {
+      ok: { type: "boolean", required: true },
+      error: { type: "string", required: true }
+    } },
+    render: textRender(function (a, v) { return v.ok ? "同步完成" : (v.error || "同步失败"); })
+  };
+  register({
+    name: "remote_ssh_sync",
+    description: syncDesc,
+    parameters: syncParams,
+    output: syncOutput,
+    execute: async function (args, exec) {
+      const ws = resolveWorkspace(args, exec);
+      if (!ws) return { ok: false, error: "未找到远程工作区（workspaceId 必填，或当前会话非远程工作区）" };
+      const p = getProfile(ws.profileId);
+      if (!p) return { ok: false, error: "未找到连接配置" };
+      return await remoteSyncDown(subprocess, p, ws.remotePath, ws.mirrorPath);
+    }
+  });
+  register({
+    name: "remote_ssh_push",
+    description: syncDesc,
+    parameters: syncParams,
+    output: syncOutput,
+    execute: async function (args, exec) {
+      const ws = resolveWorkspace(args, exec);
+      if (!ws) return { ok: false, error: "未找到远程工作区（workspaceId 必填，或当前会话非远程工作区）" };
+      const p = getProfile(ws.profileId);
+      if (!p) return { ok: false, error: "未找到连接配置" };
+      return await remoteSyncUp(subprocess, p, ws.remotePath, ws.mirrorPath);
+    }
+  });
+
+  // ---- 搜索与文件操作（借鉴 dsh-remote 的 rw_grep/rw_glob/rw_mkdir/rw_delete/rw_move）----
+  // 内容搜索：grep -rnIE（GNU grep，超算/Linux 通用，不依赖 ripgrep）。
+  register({
+    name: "remote_ssh_grep",
+    description: "通过 SSH 在远程主机上递归搜索文件内容（grep -rnIE，扩展正则）。用 profileId 引用已保存配置，或直接给 host/user。在当前远程工作区会话中可不填连接参数，path 默认为工作区远程目录。可选 include 限定文件名通配（如 *.py）、ignoreCase 忽略大小写、maxResults 限制条数（默认 200）。Search file contents on a remote host over SSH (recursive grep).",
+    parameters: Object.assign({}, CONN_PARAMS, {
+      pattern: { type: "string", required: true, description: "搜索模式（grep 扩展正则）。" },
+      path: { type: "string", description: "搜索目录，默认使用工作区远程目录。" },
+      include: { type: "string", description: "文件名通配过滤，如 *.py（GNU grep --include）。" },
+      ignoreCase: { type: "boolean", description: "忽略大小写。" },
+      maxResults: { type: "number", description: "最多返回的匹配条数，默认 200。" }
+    }),
+    output: {
+      schema: {
+        type: "object", additionalProperties: false, properties: {
+          ok: { type: "boolean", required: true },
+          pattern: { type: "string", required: true },
+          path: { type: "string", required: true },
+          matches: { type: "array", required: true, items: { type: "object", additionalProperties: true } },
+          truncated: { type: "boolean", required: true },
+          error: { type: "string", required: true }
+        }
+      },
+      render: textRender(function (a, v) {
+        if (!v.ok) return v.error || "搜索失败";
+        const ms = v.matches || [];
+        if (!ms.length) return "无匹配";
+        const lines = ms.map(function (m) { return m.file + ":" + m.line + ": " + m.content; });
+        return lines.join("\n") + (v.truncated ? "\n…（已截断）" : "");
+      })
+    },
+    execute: async function (args, exec) {
+      const tc = toolContext(args, exec);
+      if (!tc.profile) return { ok: false, pattern: "", path: "", matches: [], truncated: false, error: "需要 profileId 或 host+user（当前会话非远程工作区时必填）" };
+      if (!args.pattern) return { ok: false, pattern: "", path: "", matches: [], truncated: false, error: "pattern 为必填项" };
+      const r = await remoteGrep(subprocess, tc.profile, args.pattern, resolveRemotePath(args.path, tc.remotePath), args);
+      return { ok: !!r.ok, pattern: r.pattern || args.pattern, path: r.path || "", matches: r.matches || [], truncated: !!r.truncated, error: r.error || "" };
+    }
+  });
+
+  // 文件名通配查找：find -name（已递归，自动剥离前导 **/）。
+  register({
+    name: "remote_ssh_glob",
+    description: "通过 SSH 在远程主机上按通配符查找文件（find -name，递归）。用 profileId 引用已保存配置，或直接给 host/user。在当前远程工作区会话中可不填连接参数，path 默认为工作区远程目录。pattern 为 basename 通配，如 *.py（自动剥离前导 **/ 以适配 POSIX find）。Find files by glob pattern on a remote host over SSH.",
+    parameters: Object.assign({}, CONN_PARAMS, {
+      pattern: { type: "string", required: true, description: "文件名通配，如 *.py 或 *.js。" },
+      path: { type: "string", description: "查找目录，默认使用工作区远程目录。" },
+      maxResults: { type: "number", description: "最多返回条数，默认 500。" }
+    }),
+    output: {
+      schema: {
+        type: "object", additionalProperties: false, properties: {
+          ok: { type: "boolean", required: true },
+          pattern: { type: "string", required: true },
+          path: { type: "string", required: true },
+          files: { type: "array", required: true, items: { type: "string" } },
+          truncated: { type: "boolean", required: true },
+          error: { type: "string", required: true }
+        }
+      },
+      render: textRender(function (a, v) {
+        if (!v.ok) return v.error || "查找失败";
+        const fs2 = v.files || [];
+        if (!fs2.length) return "无匹配文件";
+        return fs2.join("\n") + (v.truncated ? "\n…（已截断）" : "");
+      })
+    },
+    execute: async function (args, exec) {
+      const tc = toolContext(args, exec);
+      if (!tc.profile) return { ok: false, pattern: "", path: "", files: [], truncated: false, error: "需要 profileId 或 host+user（当前会话非远程工作区时必填）" };
+      if (!args.pattern) return { ok: false, pattern: "", path: "", files: [], truncated: false, error: "pattern 为必填项" };
+      const r = await remoteGlob(subprocess, tc.profile, args.pattern, resolveRemotePath(args.path, tc.remotePath), args);
+      return { ok: !!r.ok, pattern: r.pattern || args.pattern, path: r.path || "", files: r.files || [], truncated: !!r.truncated, error: r.error || "" };
+    }
+  });
+
+  // 创建目录：mkdir -p。
+  register({
+    name: "remote_ssh_mkdir",
+    description: "通过 SSH 在远程主机上创建目录（mkdir -p，含父目录）。用 profileId 引用已保存配置，或直接给 host/user。在当前远程工作区会话中可不填连接参数，相对路径基于工作区远程目录解析。Create a directory on a remote host over SSH (mkdir -p).",
+    parameters: Object.assign({}, CONN_PARAMS, { path: { type: "string", required: true, description: "远程目录路径。" } }),
+    output: { schema: execSchema(), render: textRender(function (a, v) { return v.ok ? "已创建" : (v.error || v.stderr || "创建失败"); }) },
+    execute: async function (args, exec) {
+      const tc = toolContext(args, exec);
+      if (!tc.profile) return normExec({ ok: false, error: "需要 profileId 或 host+user（当前会话非远程工作区时必填）" });
+      if (!args.path) return normExec({ ok: false, error: "path 为必填项" });
+      let cmd = "mkdir -p " + shellQuotePath(resolveRemotePath(args.path, tc.remotePath));
+      return normExec(await runRemote(subprocess, tc.profile, cmd, undefined, undefined));
+    }
+  });
+
+  // 删除文件或目录：rm -rf。谨慎使用。
+  register({
+    name: "remote_ssh_delete",
+    description: "通过 SSH 删除远程主机上的文件或目录（rm -rf，递归不询问）。用 profileId 引用已保存配置，或直接给 host/user。在当前远程工作区会话中可不填连接参数，相对路径基于工作区远程目录解析。⚠️ 不可恢复，请谨慎使用。Delete a file or directory on a remote host over SSH (rm -rf).",
+    parameters: Object.assign({}, CONN_PARAMS, { path: { type: "string", required: true, description: "远程文件或目录路径。" } }),
+    output: { schema: execSchema(), render: textRender(function (a, v) { return v.ok ? "已删除" : (v.error || v.stderr || "删除失败"); }) },
+    execute: async function (args, exec) {
+      const tc = toolContext(args, exec);
+      if (!tc.profile) return normExec({ ok: false, error: "需要 profileId 或 host+user（当前会话非远程工作区时必填）" });
+      if (!args.path) return normExec({ ok: false, error: "path 为必填项" });
+      let cmd = "rm -rf " + shellQuotePath(resolveRemotePath(args.path, tc.remotePath));
+      return normExec(await runRemote(subprocess, tc.profile, cmd, undefined, undefined));
+    }
+  });
+
+  // 移动/重命名：mv。
+  register({
+    name: "remote_ssh_move",
+    description: "通过 SSH 在远程主机上移动或重命名文件/目录（mv）。用 profileId 引用已保存配置，或直接给 host/user。在当前远程工作区会话中可不填连接参数，相对路径基于工作区远程目录解析。Move or rename a file/directory on a remote host over SSH (mv).",
+    parameters: Object.assign({}, CONN_PARAMS, {
+      src: { type: "string", required: true, description: "源路径。" },
+      dst: { type: "string", required: true, description: "目标路径。" }
+    }),
+    output: { schema: execSchema(), render: textRender(function (a, v) { return v.ok ? "已移动" : (v.error || v.stderr || "移动失败"); }) },
+    execute: async function (args, exec) {
+      const tc = toolContext(args, exec);
+      if (!tc.profile) return normExec({ ok: false, error: "需要 profileId 或 host+user（当前会话非远程工作区时必填）" });
+      if (!args.src || !args.dst) return normExec({ ok: false, error: "src 和 dst 为必填项" });
+      let cmd = "mv " + shellQuotePath(resolveRemotePath(args.src, tc.remotePath)) + " " + shellQuotePath(resolveRemotePath(args.dst, tc.remotePath));
+      return normExec(await runRemote(subprocess, tc.profile, cmd, undefined, undefined));
+    }
+  });
+
   // ---- 清理 ----
   ctx.effect(() => () => {
     terminals.forEach(function (s) { try { s.handle.terminate(); } catch (e) {} });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhangfengshun/dsh-remote-ssh",
-  "version": "1.4.0",
+  "version": "1.6.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",