@zhangfengshun/dsh-remote-ssh 1.8.2 → 1.9.0

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 本文件的版本号与 `package.json` 的 `version` 保持一致。每个版本对应一个 Cordis Package 快照（`pkg-N`）。
 
+## [1.9.0] — 远程文件/终端合并到内置页签
+### 重大变更
+- **移除 `remssh:files` 和 `remssh:term` 页签**：远程文件和远程终端不再使用独立侧边栏页签。
+- **远程文件 → 内置「文件」页签**：创建远程工作区时自动 `tar | ssh` 同步远程文件到本地镜像目录，内置「文件」页签直接显示真实远程文件。编辑后通过设置页「同步/推送」按钮或 `remote_ssh_push` 工具回传。
+- **远程终端 → 内置「终端」页签**：插件启动时自动生成跨平台 shell wrapper 脚本（`~/.dsh/remote-ssh/dsh-remote-shell[.cmd]`）。在 DSH 设置中将 better-sidebar 的 `shell` 指向该脚本后，内置「终端」页签在远程工作区中自动 SSH 到远程主机，在本地工作区中照常启动本地 shell。
+- **设置页新增「远程工作区」管理区**：列出所有远程工作区，支持同步/推送/删除操作。
+- **创建工作区时写入 `.remote-ssh.json`**：镜像目录中写入连接信息（host/port/user/keyPath/proxyJump/remotePath），供 shell wrapper 读取。
+- 保留隐藏的 `remssh:editor` 页签用于远程文件编辑器。
+- ⚠️ 终端透明接入仅支持**密钥认证**（密码无法安全传入 wrapper 脚本）。
+
+## [1.8.3] — 浏览按钮改回「打开」
+### 变更
+- 「浏览」按钮改回「打开」：按输入框路径加载该路径下的文件树，空路径时打开主目录。本地/远程行为一致，不再调用 `pickDirectory`（该原生对话框在仅有 `browse` capability 的环境下不可用）。回车导航保留。
+
 ## [1.8.2] — 修复浏览按钮：本地回退 + 远程打开主目录
 ### 修复
 - **本地浏览**：`pickDirectory()` 在仅有 `browse` capability（无 `native`）的 DSH 环境下会报错 `host.pickDirectory needs the native capability`。现改为：尝试原生选择框，失败时静默回退到加载用户主目录（`listDirectory` 默认列举 home）。用户取消也回到主目录。

package/README.md

@@ -11,13 +11,12 @@
 | 🔌 远程连接 | SSH 连接超算 / 服务器，密钥认证（推荐）或密码认证（需本机 `sshpass`），内置「测试连接」；支持 `ProxyJump` 跳板机 |
 | ⚡ 连接复用 | 持久 SSH 会话池，文件操作复用同一条已认证连接，不再每次握手（首次后近乎瞬时） |
 | 📥 配置导入 | 一键从 `~/.ssh/config`（递归 `Include`）发现主机并批量导入连接配置 |
-| 🗂️ 远程文件 | 在 better-sidebar「远程文件」页签浏览 / 打开 / 编辑 / 保存远程文件；选中工作区后可双向同步 |
-| 💻 远程终端 | 在 better-sidebar「远程终端」页签打开 `ssh -tt` 集成终端，支持多终端并发 |
-| 🔄 双向同步 | `remote_ssh_sync`（远端 → 本地镜像）/ `remote_ssh_push`（本地镜像 → 远端），tar 流式管道，同步后内置文件工具可见 |
-| 🌐 远程工作区 | 选择远程目录创建**原生工作区**（本地镜像目录 + 原生注册），一键打开进入远程环境 |
+| 🗂️ 远程文件 | 创建远程工作区时自动同步到本地镜像，内置「文件」页签直接显示远程文件；编辑后通过设置页同步/推送回传 |
+| 💻 远程终端 | 内置「终端」页签自动通过 shell wrapper 检测远程工作区，打开 SSH 交互式终端（仅密钥认证） |
+| 🔄 双向同步 | 设置页一键同步（远端 → 本地镜像）/ 推送（本地镜像 → 远端），或通过 `remote_ssh_sync` / `remote_ssh_push` 工具 |
+| 🌐 远程工作区 | 选择远程目录创建**原生工作区**（本地镜像目录 + 原生注册 + 自动同步），一键打开进入远程环境 |
 | 🤖 模型工具 | 12 个 `remote_ssh_*` 工具，模型可读写远程文件、执行远程命令、内容搜索、文件名查找、目录/删除/移动、双向同步；在远程工作区会话中免填连接参数 |
 | 🌍 国际化 | 界面文案 + 工具描述中英双语，通过 `ctx.locale` 跟随 DSH 语言设置自动切换 |
-| 🧠 会话记忆 | 切换会话后，「远程文件」「远程终端」页签记住已选连接、浏览目录、打开的文件与终端 |
 
 ## 安装
 
@@ -30,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.8.2
+dsh plugin --profile <name> add @zhangfengshun/dsh-remote-ssh@1.9.0
 ```
 
 > ⚠️ 安装后需**重启 DSH** 才生效；后续仅修改 Client 半边时刷新浏览器即可。
@@ -39,8 +38,9 @@ dsh plugin --profile <name> add @zhangfengshun/dsh-remote-ssh@1.8.2
 
 1. 安装插件并重启 DSH。
 2. 打开 **设置 → 🖥️ 远程连接**，添加一条连接（主机 / 端口 / 用户名 / 密钥或密码），点「测试连接」验证。
-3. 在侧边栏打开 **🗂️ 远程文件** 或 **💻 远程终端** 页签使用。
-4. 需要把远程目录当作工作区时：走 DSH 原生「添加工作区」流程，在弹窗中选择「**选择远程目录…**」。
+3. 需要把远程目录当作工作区时：走 DSH 原生「添加工作区」流程，在弹窗中选择「**选择远程目录…**」→ 选择连接 → 浏览并选择远程目录。
+4. 创建后远程文件自动同步到本地镜像，内置「文件」页签直接可见。
+5. **（可选）远程终端**：在 DSH 设置中把 better-sidebar 的 `shell` 配置指向 wrapper 脚本（见下方「远程终端配置」），内置「终端」页签即可在远程工作区中自动打开 SSH 终端。
 
 ## 使用指南
 
@@ -60,22 +60,34 @@ dsh plugin --profile <name> add @zhangfengshun/dsh-remote-ssh@1.8.2
 
 连接配置持久化在 DSH 设置命名空间 `dsh-remote-ssh` 中（密码字段 `role('secret')` 脱敏）。
 
-### 2. 远程文件（🗂️）
+### 2. 远程文件（内置「文件」页签）
 
-- 选择**远程工作区**或**连接配置**，浏览远程目录；
-- 点击文件即可打开并编辑，保存后写回远程；
-- 已选连接 / 目录 / 打开的文件在**切换会话后自动恢复**。
+- 创建远程工作区时，远程文件自动同步到本地镜像目录，内置「文件」页签直接显示；
+- 内置编辑器编辑的是本地镜像副本，编辑后需**推送回远端**；
+- 推送方式：设置 → 远程连接 → 远程工作区 → 点「⬆ 推送」按钮，或模型调用 `remote_ssh_push` 工具；
+- 远程有更新时点「⬇ 同步」重新拉取。
 
-### 3. 远程终端（💻）
+### 3. 远程终端（内置「终端」页签）
 
-- 选择连接配置，点「新建终端」打开 `ssh -tt` 交互式终端；
-- 支持同时打开多个终端，会话切换后终端列表自动恢复（终端本体在宿主进程存活，恢复后继续回显）。
+通过 shell wrapper 实现：终端启动时自动检测当前工作目录下的 `.remote-ssh.json`，若存在且含密钥路径 → 自动 `ssh -tt` 连接远程主机；否则启动本地 shell。
+
+**配置步骤**：
+
+1. 插件启动时自动在 `~/.dsh/remote-ssh/` 下生成 wrapper 脚本：
+   - Windows: `dsh-remote-shell.cmd`（调用 `dsh-remote-shell.js`）
+   - POSIX: `dsh-remote-shell`（调用 `dsh-remote-shell.js`）
+2. 在 DSH 设置中找到 better-sidebar 的 `shell` 配置项，填入 wrapper 脚本的完整路径：
+   - Windows: `C:\Users\<你>\.dsh\remote-ssh\dsh-remote-shell.cmd`
+   - POSIX: `/home/<你>/.dsh/remote-ssh/dsh-remote-shell`
+3. 重启 DSH 后，在远程工作区中打开终端 → 自动 SSH 到远程主机；在本地工作区中打开终端 → 照常启动本地 shell。
+
+> ⚠️ 终端透明接入仅支持**密钥认证**（密码无法安全传入 wrapper 脚本）。密码认证的连接仍可使用模型工具。
 
 ### 4. 远程工作区（🌐）
 
 1. 打开 DSH 原生「添加工作区」流程；
 2. 选择「**选择远程目录…**」→ 选择连接 → 浏览并选择远程目录；
-3. 插件在本地生成镜像目录 `~/.dsh/remote-workspaces/<id>` 并注册进原生工作区列表（标题 `🌐 <名称>`）；
+3. 插件在本地生成镜像目录 `~/.dsh/remote-workspaces/<id>`，写入 `.remote-ssh.json`（连接信息，供 shell wrapper 读取），自动同步远程文件，并注册进原生工作区列表（标题 `🌐 <名称>`）；
 4. 从工作区创建会话后，会话工作目录即该镜像目录，模型工具自动感知对应的远程连接与目录。
 
 ### 5. 模型工具（🤖）
@@ -118,13 +130,18 @@ dsh-remote-ssh/
 ```
 浏览器 (Client 半边)                     Node 进程 (Host 半边)
 ┌───────────────────────────────┐  fetch  ┌──────────────────────────────────┐
-│ ctx.betterSidebar.registerTab │ ──────▶ │ ctx.webServer /remote-ssh/api/*  │
-│  · 远程文件 / 远程终端        │ ◀────── │  · SSH：listDir/readFile/…       │
-│ ctx.slots: settings.section   │  JSON   │  · settings：profiles/workspaces  │
-│  · DSH 设置页「远程连接」      │         │  · terminals：ssh -tt 管道        │
-└───────────────────────────────┘         │ ctx.tools：12 个 remote_ssh_*    │
-                                          └───────────────┬──────────────────┘
-                                                          │ SSH
+│ ctx.betterSidebar.registerTab  │ ──────▶ │ ctx.webServer /remote-ssh/api/*  │
+│  · remssh:editor (隐藏)        │ ◀────── │  · SSH：listDir/readFile/…       │
+│ ctx.slots: settings.section    │  JSON   │  · settings：profiles/workspaces  │
+│  · 连接配置 + 工作区管理       │         │  · 自动同步 + shell wrapper 生成  │
+│ ctx.slots: directoryFlow       │         │ ctx.tools：12 个 remote_ssh_*    │
+│  · 本地 / 远程目录两选弹窗     │         └───────────────┬──────────────────┘
+└───────────────────────────────┘                          │ SSH
+                                              ┌─────────────┴──────────┐
+                                              │ ~/.dsh/remote-ssh/    │
+                                              │  dsh-remote-shell.js   │
+                                              │  dsh-remote-shell[.cmd]│ ← better-sidebar shell 指向此文件
+                                              └────────────────────────┘
                                                      远程超算 / 服务器
 ```
 
@@ -134,24 +151,27 @@ dsh-remote-ssh/
 - **二进制安全读文件**：远程 `base64 -w0` 输出，Host 用 `Buffer` 解码为 UTF-8。
 - **写文件走 stdin**：远程 `cat > <file>`，内容经子进程 stdin 传入。
 - **文件列举**：`find -printf '%Y\t%f\t%s\n'`（`%Y` 跟随软链接取目标类型，适配超算家目录软链接）。
-- **终端**：`ssh -tt` 分配远程 PTY，本地管道转发，客户端 HTTP 轮询回显（无 `node-pty` 依赖，Windows 可用）。
+- **自动同步**：创建远程工作区时立即 `tar | ssh` 拉取远程文件到本地镜像，使内置「文件」页签可见真实远程文件。
+- **Shell wrapper**：插件启动时生成跨平台 wrapper 脚本（Node.js + 薄壳），检测工作区 `.remote-ssh.json` 自动 SSH，使内置「终端」页签透明接入远程。
 - **国际化**：Client 接入 `ctx.locale`，注册 `zh` / `en` 词典，界面与工具描述跟随 DSH 语言自动切换。
 
 ## 已知限制
 
-1. **终端非本地 PTY**：走 `ssh -tt` 管道通道（跨平台可用）；`vim` / `htop` 等全屏程序体验受限，后续可接入 `terminals.registerBackend` + `node-pty` 真 PTY。
-2. **文件操作依赖 GNU 工具**（`find -printf`、`base64 -w0`）：目标为 Linux 超算时通用。
-3. **密码认证需本机 `sshpass`**（Windows 默认没有）；密钥认证无此依赖。
-4. **同步为全量 tar**：`remote_ssh_sync` / `remote_ssh_push` 用 `tar` 流式全量同步，单次同步大目录耗时与传输量较高，后续可换 `rsync -e ssh` 增量。
-5. **原生工具编辑的是本地镜像副本**，不会自动回传 —— 须点「推送」或调用 `remote_ssh_push` 同步回远端（与 `dsh-remote` 的 `rw_sync` / `rw_push` 模型一致）。
+1. **终端透明接入仅限密钥认证**：shell wrapper 通过 `.remote-ssh.json` 读取密钥路径，密码认证无法安全传入。密码认证的连接仍可使用模型工具和远程文件操作。
+2. **终端需手动配置 shell**：需在 DSH 设置中把 better-sidebar 的 `shell` 指向 wrapper 脚本路径，终端透明接入才生效。
+3. **文件操作依赖 GNU 工具**（`find -printf`、`base64 -w0`）：目标为 Linux 超算时通用。
+4. **密码认证需本机 `sshpass`**（Windows 默认没有）；密钥认证无此依赖。
+5. **同步为全量 tar**：`remote_ssh_sync` / `remote_ssh_push` 用 `tar` 流式全量同步，单次同步大目录耗时与传输量较高，后续可换 `rsync -e ssh` 增量。
+6. **内置编辑器编辑的是本地镜像副本**，不会自动回传 —— 须在设置页点「推送」或调用 `remote_ssh_push` 同步回远端。
 
 ## 路线图
 
 - [x] 从 `~/.ssh/config` 自动导入连接
 - [x] ProxyJump / 跳板机、SSH config 复用
 - [x] `tar`-over-ssh 双向同步（`scp` / `sftp` 增量同步为后续优化）
+- [x] 远程文件合并到内置「文件」页签（自动同步 + 镜像）
+- [x] 远程终端合并到内置「终端」页签（shell wrapper 透明 SSH）
 - [ ] `rsync -e ssh` 增量同步
-- [ ] 真 PTY 终端（`terminals.registerBackend` + `node-pty`）
 - [ ] 密码凭据走 `credentials` 服务（避免明文进 argv）
 
 ## 许可证

package/lib/client.js

@@ -1,12 +1,14 @@
 /**
  * @zhangfengshun/dsh-remote-ssh — Client 半边（静态 DSH Web 插件，浏览器 bundle）
  *
- * 通过 dsh-better-sidebar 的 `ctx.betterSidebar.registerTab` 注册两个侧边栏页签：
- *   - remssh:files  远程文件（文件浏览器 + 工作区选择）
- *   - remssh:term   远程终端（ssh -tt 管道终端）
- * 并在 DSH 设置页注册「远程连接」小节（settings.section）管理连接配置；
- * 同时接管原生「添加工作区」流程（directoryFlow 槽位，优先级 -1 覆盖内置选择器），
- * 提供「本地目录 / 远程目录」两选：远程分支创建本地镜像目录并注册为原生工作区。
+ * 远程文件与远程终端已合并到内置「文件」和「终端」页签：
+ *   - 远程文件：创建远程工作区时自动同步到本地镜像目录，内置「文件」页签直接显示远程文件。
+ *     编辑后通过设置页的「同步/推送」按钮回传远程（或使用 remote_ssh_push 工具）。
+ *   - 远程终端：shell wrapper 自动检测工作区 .remote-ssh.json，在远程工作区中打开 SSH 终端。
+ *     需在 better-sidebar 设置中将 shell 指向 wrapper 脚本（见 README）。
+ * 仍保留隐藏的 remssh:editor 页签用于远程文件编辑器。
+ * 在 DSH 设置页注册「远程连接」小节管理连接配置和远程工作区；
+ * 同时接管原生「添加工作区」流程提供「本地目录 / 远程目录」两选。
  */
 window.__ModuleLoader__.load({
   id: "@zhangfengshun/dsh-remote-ssh",
@@ -66,6 +68,7 @@ window.__ModuleLoader__.load({
       "settings.desc": "管理 Remote-SSH 的远程连接配置（SSH 密钥或密码认证）。",
       "settings.empty": "还没有连接配置。请在下方添加。",
       "settings.add": "添加连接",
+      "settings.workspaces": "远程工作区",
       "settings.name": "名称",
       "settings.namePlaceholder": "如：我的超算",
       "settings.host": "主机 host",
@@ -165,6 +168,7 @@ window.__ModuleLoader__.load({
       "settings.desc": "Manage Remote-SSH connection profiles (SSH key or password authentication).",
       "settings.empty": "No connection profiles yet. Add one below.",
       "settings.add": "Add Profile",
+      "settings.workspaces": "Remote Workspaces",
       "settings.name": "Name",
       "settings.namePlaceholder": "e.g. My HPC",
       "settings.host": "Host",
@@ -790,8 +794,6 @@ window.__ModuleLoader__.load({
 
       var listFnRef = React.useRef(props.listFn);
       listFnRef.current = props.listFn;
-      var pickRef = React.useRef(props.pickNative);
-      pickRef.current = props.pickNative;
 
       function load(p) {
         setLoading(true); setErr(null);
@@ -809,35 +811,19 @@ window.__ModuleLoader__.load({
         if (up !== null) load(up);
       }
 
-      // 浏览按钮：
-      //   本地模式：尝试弹原生系统目录选择框（pickDirectory），若 native capability 不可用
-      //             则回退到加载用户主目录（load(undefined) 列举 home）。
-      //   远程模式：打开远程用户主目录（load(undefined) → remoteRoot/~）。
-      function browse() {
-        if (pickRef.current) {
-          setLoading(true); setErr(null);
-          pickRef.current().then(function (picked) {
-            setLoading(false);
-            if (picked) load(picked);
-            else load(undefined); // 用户取消 → 回到主目录
-          }).catch(function (e) {
-            setLoading(false);
-            // native capability 不可用（"browse" only）→ 回退到加载主目录
-            load(undefined);
-          });
-        } else {
-          load(undefined); // 远程：打开用户主目录（~）
-        }
+      // 打开按钮：按输入框路径加载该路径下的文件树。空路径时打开主目录。
+      function open() {
+        load(path || undefined);
       }
 
-      // 路径栏：输入框（回车导航）+ 浏览按钮（紧挨在右侧）+ 上级
+      // 路径栏：输入框（回车导航）+ 打开按钮（紧挨在右侧）+ 上级
       return h("div", null,
         h("div", { className: "rssh-pathbar" },
           h("input", { className: "rssh-input", value: path,
             onChange: function (e) { setPath(e.target.value); },
-            onKeyDown: function (e) { if (e.key === "Enter") { e.preventDefault(); load(path); } },
+            onKeyDown: function (e) { if (e.key === "Enter") { e.preventDefault(); open(); } },
             placeholder: props.placeholder || t("picker.dir") }),
-          h("button", { className: "rssh-btn", onClick: browse, disabled: loading }, t("flow.browse")),
+          h("button", { className: "rssh-btn", onClick: open, disabled: loading }, t("common.open")),
           h("button", { className: "rssh-btn", onClick: goUp }, t("common.up"))
         ),
         loading ? h("div", { className: "rssh-muted" }, t("common.loading")) : null,
@@ -906,7 +892,7 @@ window.__ModuleLoader__.load({
           isRemote
             ? (profileId ? h(DirPicker, { resetKey: profileId, placeholder: t("flow.remoteDir"), listFn: function (p) { return remoteListFn(profileId, p); }, onChoose: chooseRemote, disabled: creating })
                : h("div", { className: "rssh-pick-empty" }, t("common.selectProfile")))
-            : h(DirPicker, { resetKey: "local", placeholder: t("flow.localDir"), listFn: function (p) { return localListFn(props.workspaces, p); }, pickNative: function () { return props.workspaces.pickDirectory(); }, onChoose: chooseLocal })
+            : h(DirPicker, { resetKey: "local", placeholder: t("flow.localDir"), listFn: function (p) { return localListFn(props.workspaces, p); }, onChoose: chooseLocal })
         )
       );
     }
@@ -917,15 +903,34 @@ window.__ModuleLoader__.load({
     function SettingsSection(props) {
       var t = useT();
       var [profiles, setProfiles] = React.useState([]);
+      var [workspaces, setWorkspaces] = React.useState([]);
       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 [wsSync, setWsSync] = React.useState({});
       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 || []); }); }
+      function reload() {
+        api("listProfiles").then(function (r) { if (r && r.ok) setProfiles(r.profiles || []); });
+        api("listWorkspaces").then(function (r) { if (r && r.ok) setWorkspaces(r.workspaces || []); });
+      }
       React.useEffect(reload, []);
 
+      function profileName(id) {
+        var p = profiles.find(function (x) { return x.id === id; });
+        return p ? p.name : id;
+      }
+      function doWsSync(wsId, dir) {
+        setWsSync(function (s) { var n = {}; for (var k in s) n[k] = s[k]; n[wsId] = { busy: true, msg: dir === "down" ? t("sync.syncing") : t("sync.pushing"), ok: null }; return n; });
+        api(dir === "down" ? "syncDown" : "syncUp", { workspaceId: wsId }).then(function (r) {
+          setWsSync(function (s) { var n = {}; for (var k in s) n[k] = s[k]; n[wsId] = { busy: false, msg: r && r.ok ? t("sync.done") : ((r && r.error) || t("sync.fail")), ok: !!(r && r.ok) }; return n; });
+        });
+      }
+      function delWs(wsId) {
+        api("deleteWorkspace", { id: wsId }).then(function (r) { if (r && r.ok) setWorkspaces(r.workspaces || []); });
+      }
+
       function save() {
         setBusy(true); setResult(null);
         api("saveProfile", Object.assign({}, form, { port: parseInt(form.port, 10) || 22 })).then(function (r) {
@@ -1003,6 +1008,22 @@ window.__ModuleLoader__.load({
           );
         }),
         profiles.length === 0 ? h("div", { className: "rssh-empty" }, t("settings.empty")) : null,
+        workspaces.length > 0 ? h("div", { className: "rssh-card" },
+          h("div", { className: "rssh-title" }, t("settings.workspaces")),
+          workspaces.map(function (ws) {
+            var st = wsSync[ws.id];
+            return h("div", { key: ws.id, className: "rssh-card", style: { marginBottom: 6 } },
+              h("div", { className: "rssh-title" }, ws.title || ws.id),
+              h("div", { className: "rssh-sub" }, profileName(ws.profileId) + " → " + (ws.remotePath || "")),
+              h("div", { className: "rssh-actions" },
+                h("button", { className: "rssh-btn", onClick: function () { doWsSync(ws.id, "down"); }, disabled: st && st.busy }, t("sync.down")),
+                h("button", { className: "rssh-btn", onClick: function () { doWsSync(ws.id, "up"); }, disabled: st && st.busy }, t("sync.up")),
+                h("button", { className: "rssh-btn", onClick: function () { delWs(ws.id); } }, t("common.delete"))
+              ),
+              st ? h("span", { className: st.ok === false ? "rssh-err" : (st.ok ? "rssh-ok" : "rssh-muted"), style: { fontSize: 11 } }, st.msg) : null
+            );
+          })
+        ) : null,
         h("div", { className: "rssh-card" },
           h("div", { className: "rssh-title" }, t("settings.add")),
           Field({ label: t("settings.name"), value: form.name, onChange: function (v) { set("name", v); }, placeholder: t("settings.namePlaceholder") }),
@@ -1073,20 +1094,9 @@ window.__ModuleLoader__.load({
       });
 
       if (betterSidebar) {
-        ctx.effect(function () {
-          return betterSidebar.registerTab({
-            id: "remssh:files",
-            title: function () { return i18n.t("tabs.files"); },
-            order: 90,
-            single: true,
-            icon: function () { return h("span", null, "🗂️"); },
-            component: function (props) {
-              var sid = props && props.scope ? props.scope.sessionId : null;
-              return h(FilesTab, { key: "files:" + (sid || "global"), sessionId: sid, betterSidebar: props && props.ctx ? props.ctx.betterSidebar : null });
-            }
-          });
-        });
-        // 远程文件编辑器页签（隐藏页签，仅由文件树点击打开，每个远程文件单开一栏）。
+        // 远程文件编辑器页签（隐藏页签，仅由代码打开，每个远程文件单开一栏）。
+        // remssh:files 和 remssh:term 已移除：远程文件由内置「文件」页签显示（自动同步到镜像目录），
+        // 远程终端由内置「终端」页签提供（shell wrapper 自动 SSH）。
         ctx.effect(function () {
           return betterSidebar.registerTab({
             id: "remssh:editor",
@@ -1099,19 +1109,6 @@ window.__ModuleLoader__.load({
             }
           });
         });
-        ctx.effect(function () {
-          return betterSidebar.registerTab({
-            id: "remssh:term",
-            title: function () { return i18n.t("tabs.term"); },
-            order: 91,
-            single: true,
-            icon: function () { return h("span", null, "💻"); },
-            component: function (props) {
-              var sid = props && props.scope ? props.scope.sessionId : null;
-              return h(TerminalTab, { key: "term:" + (sid || "global"), sessionId: sid });
-            }
-          });
-        });
       }
 
       if (slots) {

package/lib/index.js

@@ -819,6 +819,18 @@ function apply(ctx, config) {
       try {
         await writeFile(join(mirrorDir, "README.md"), remoteWorkspaceReadme(p.name, a.remotePath), "utf8");
       } catch (e) {}
+      // 写 .remote-ssh.json：供 shell wrapper 读取连接信息（仅密钥认证，不含密码）。
+      try {
+        const connInfo = {
+          profileId: p.id, host: p.host, port: p.port || 22, user: p.user,
+          keyPath: p.keyPath || "", proxyJump: p.proxyJump || "", remotePath: a.remotePath
+        };
+        await writeFile(join(mirrorDir, ".remote-ssh.json"), JSON.stringify(connInfo, null, 2), "utf8");
+      } catch (e) {}
+      // 自动同步：把远程文件拉到本地镜像，使内置「文件」页签可见真实远程文件。
+      try {
+        await remoteSyncDown(subprocess, p, a.remotePath, mirrorDir);
+      } catch (e) {}
       let workspaceId = null;
       if (workspaceRegistry) {
         try {
@@ -1297,6 +1309,66 @@ function apply(ctx, config) {
     }
   });
 
+  // ---- 创建 shell wrapper（供 better-sidebar 的 shell 配置指向它，实现远程终端透明接入）----
+  // wrapper 逻辑：读取当前工作目录下的 .remote-ssh.json，若存在且含 keyPath → exec ssh -tt；
+  // 否则降级到平台默认 shell（bash -l / powershell）。
+  // 实现方式：跨平台 Node.js 脚本 + 平台特定的薄壳调用它。
+  const wrapperDir = join(homedir(), ".dsh", "remote-ssh");
+  const isWin = process.platform === "win32";
+  const wrapperJsPath = join(wrapperDir, "dsh-remote-shell.js");
+  const wrapperPath = isWin ? join(wrapperDir, "dsh-remote-shell.cmd") : join(wrapperDir, "dsh-remote-shell");
+  const wrapperJs = [
+    "// DSH remote-ssh shell wrapper — auto-detects remote workspace via .remote-ssh.json",
+    "const fs = require('fs');",
+    "const path = require('path');",
+    "const { spawn } = require('child_process');",
+    "const info = path.join(process.cwd(), '.remote-ssh.json');",
+    "try {",
+    "  if (fs.existsSync(info)) {",
+    "    const j = JSON.parse(fs.readFileSync(info, 'utf8'));",
+    "    if (j.keyPath && j.keyPath !== '' && j.host && j.user) {",
+    "      const port = j.port || 22;",
+    "      const args = ['-tt', '-o', 'StrictHostKeyChecking=no', '-p', String(port), '-i', j.keyPath, j.user + '@' + j.host];",
+    "      if (j.proxyJump) { args.splice(2, 0, '-J', j.proxyJump); }",
+    "      const ssh = spawn('ssh', args, { stdio: 'inherit' });",
+    "      ssh.on('exit', function(c) { process.exit(c == null ? 0 : c); });",
+    "      return;",
+    "    }",
+    "  }",
+    "} catch (e) {}",
+    "// 默认本地 shell",
+    "var sh = process.env.SHELL || (process.platform === 'win32' ? 'powershell.exe' : '/bin/bash');",
+    "var shArgs = process.platform === 'win32' ? [] : ['-l'];",
+    "var p = spawn(sh, shArgs, { stdio: 'inherit' });",
+    "p.on('exit', function(c) { process.exit(c == null ? 0 : c); });",
+    ""
+  ].join("\n");
+  const winCmd = [
+    "@echo off",
+    'node "%~dp0dsh-remote-shell.js"',
+    ""
+  ].join("\r\n");
+  const posixSh = [
+    "#!/usr/bin/env bash",
+    "# DSH remote-ssh shell wrapper (POSIX) — delegates to Node.js script",
+    'exec node "$(dirname "$0")/dsh-remote-shell.js"',
+    ""
+  ].join("\n");
+  (async function () {
+    try {
+      await mkdir(wrapperDir, { recursive: true });
+      await writeFile(wrapperJsPath, wrapperJs, "utf8");
+      if (isWin) {
+        await writeFile(wrapperPath, winCmd, "utf8");
+      } else {
+        await writeFile(wrapperPath, posixSh, "utf8");
+        try { await (await import("node:fs/promises")).chmod(wrapperPath, 0o755); } catch (e) {}
+      }
+    } catch (e) {
+      ctx.logger?.warn("[dsh-remote-ssh] 创建 shell wrapper 失败: " + String(e && e.message ? e.message : e));
+    }
+  })();
+
   // ---- 清理 ----
   ctx.effect(() => () => {
     clearInterval(idleTimer);

package/package.json

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