dsh-remote 0.8.39 → 0.8.40

package/README.en.md

@@ -57,9 +57,9 @@ The image above is the overview. What follows is only what the image does not ma
 The rest:
 
 - **25 model tools** (listed so they can be copied or searched): `rw_info`, `rw_connect`, `rw_machines`, `rw_pick_workspace`, `rw_list_dir`, `rw_stat`, `rw_read_file`, `rw_write_file`, `rw_edit`, `rw_append`, `rw_mkdir`, `rw_remove`, `rw_move`, `rw_exec`, `rw_search`, `rw_download`, `rw_upload`, `rw_sync`, `rw_push`, `rw_backup`, `rw_backup_list`, `rw_restore`, `rw_forward`, `rw_disconnect`, `rw_deploy_probe`.
-- **Compressed workspace backup / restore** (`rw_backup` / `rw_backup_list` / `rw_restore`) — archive a remote workspace to `.tar.gz` (everything is included by default; pass excludes for `node_modules`, `/build/`, `*.log` and friends). The archive can stay on the remote under `$HOME/.dsh-remote/backups`, be pulled to this machine, or **both**. Before restoring, the archive is verified; **a corrupt archive is refused and the target is left untouched**. `mode=replace` (default) swaps the whole tree, `mode=merge` only overwrites without deleting. The settings page has a **Backup** card too (create / download / restore / delete).
+- **Workspace backup / restore (two buttons, nothing to configure)** — the settings page offers just **Back up** and **Restore**: backing up archives **every remote workspace in the sidebar into ONE** `.tar.gz`, and restoring brings them all back from the point in time you pick. Dependency/build directories (`node_modules`, `.git`, `dist`, `build`, `target`, `__pycache__`, `.venv` … both top-level and nested) are excluded automatically. The model can do the same through `rw_backup` / `rw_backup_list` / `rw_restore`. **The archive is verified before anything is written — a corrupt or truncated archive is refused and nothing is touched**; each workspace's previous contents are moved aside first and restored automatically if the swap fails.
 - **Open a remote machine's DSH Web UI locally** (`0.8.36+`) — nothing has to be exposed on the remote: the plugin SSHes out, starts a `dsh web` there that binds **`127.0.0.1` only**, and tunnels its port back to a loopback port on this machine. The URL carries a one-time login token, consumed once by a redirect.
-- **One-click health check & deploy** (`0.8.36+`) — **a failed connection is usually the remote dsh version or environment, not the plugin.** The read-only check reports platform / node / npm / dsh version / **whether the native module can load** / proxy and npm registry, with a suggested fix; "Deploy & verify" installs into a remote **private directory** (no system directory, no PATH change, no replacing the version you use — deleting it is a complete rollback) and verifies step by step. If that still fails, the built-in `dsh-remote-deploy` skill takes over.
+- **One-click health check & deploy** (`0.8.36+`) — **a failed connection is usually the remote dsh version or environment, not the plugin.** The read-only check reports platform / node / npm / dsh version / **whether the native module can load** / proxy and npm registry, with a suggested fix; "Deploy & verify" installs into a remote **private directory** (no system directory, no PATH change, no replacing the version you use — deleting it is a complete rollback) and verifies step by step. The button **no longer requires running the check first** (`0.8.40+`) — the deploy re-checks internally. If that still fails, the built-in `dsh-remote-deploy` skill takes over.
 - **Cross-platform remotes** — all file access is SFTP-protocol-level (no POSIX shell), so Linux/macOS/Windows remotes all work.
 - **Windows remotes** — the platform is auto-detected and commands go through `bash -s` over stdin, so quoting and backslash escaping are never an issue (`config.shell` can pin a path or `native` disables wrapping); `C:\Users\dev` and `/c/Users/dev` are both accepted.
 - **Async long tasks** — `rw_sync`/`rw_push` with `async: true` return a `taskId` with progress/result/cancel.
@@ -265,7 +265,7 @@ Deploying to a product profile is a separate, explicit action (`./sync.sh`) for
 | `webInstallVersion` | string | `0.1.5-rc.2` | dsh version an automatic deployment installs; the default is the first that can start the web surface on Linux |
 | `webInstallRegistry` | string | `''` | npm registry for the install; **empty keeps the remote's own config**, so an internal mirror is never overridden |
 | `backupDir` | string | `''` | Where backup archives are written **on the remote**; empty means `$HOME/.dsh-remote/backups` (resolved on the remote, never guessed from this machine's home) |
-| `backupExcludes` | string[] | `[]` | Paths excluded from backups by default (gitignore-style). **Empty by default**: silently omitting directories is how a restore becomes silent data loss |
+| `backupExcludes` | string[] | `[]` | Extra paths excluded **on top of the built-in set** (gitignore-style). No longer surfaced in the UI; the built-in set covers `node_modules`/`.git`/`dist`/`build`/`target`/`__pycache__`/`.venv` and friends, top-level and nested |
 | `maxBackupTransferBytes` | int | `2147483648` | Cap (bytes) on moving an archive between this machine and the remote; **the remote archive is never truncated** — this only bounds the optional cross-machine copy. 0 = unlimited |
 
 > The authoritative list is the `Config` schema in `lib/index.js`; this table mirrors it.

package/README.md

@@ -46,9 +46,9 @@ DSH 的 Web 界面刻意只监听 `127.0.0.1`（CLI 为安全拒绝 `--host 0.0.
 其余要点：
 
 - **25 个模型工具**（便于复制/检索）：`rw_info`、`rw_connect`、`rw_machines`、`rw_pick_workspace`、`rw_list_dir`、`rw_stat`、`rw_read_file`、`rw_write_file`、`rw_edit`、`rw_append`、`rw_mkdir`、`rw_remove`、`rw_move`、`rw_exec`、`rw_search`、`rw_download`、`rw_upload`、`rw_sync`、`rw_push`、`rw_backup`、`rw_backup_list`、`rw_restore`、`rw_forward`、`rw_disconnect`、`rw_deploy_probe`。
-- **工作区压缩备份 / 恢复**（`rw_backup` / `rw_backup_list` / `rw_restore`）—— 把远程工作区打成 `.tar.gz`（默认全部收录，另可按参数排除 `node_modules`、`/build/`、`*.log` 等）；归档可留在远端 `$HOME/.dsh-remote/backups`，也可拉到本机或**两边都留**。恢复前先校验归档可读，**归档损坏则拒绝执行、目标目录原封不动**；`mode=replace`（默认）整树替换、`mode=merge` 只覆盖不删除。设置页里也有「备份」卡片（新建 / 下载 / 恢复 / 删除）。
+- **工作区备份 / 恢复（一个按钮就够）** —— 设置页里只有「备份」和「恢复」两个按钮：**备份**把侧边栏里的所有远程工作区打包成**一个** `.tar.gz`，**恢复**用选中的那个时间点把全部工作区还原。依赖/构建目录（`node_modules`、`.git`、`dist`、`build`、`target`、`__pycache__`、`.venv`… 顶层与嵌套）自动排除，不需要你配置。模型侧仍可用 `rw_backup` / `rw_backup_list` / `rw_restore` 做同样的事。**恢复前先校验归档可读，归档损坏或截断就拒绝执行、目标一个字节都不动**；每个工作区的旧目录会先移到一旁，换入失败会自动还原。
 - **把远端机器的 DSH 界面挂到本机**（`0.8.36+`）—— 不用在远端开任何端口：插件主动 SSH 连过去，在远端**只监听 `127.0.0.1`** 地起一个 `dsh web`，再把端口经隧道搬回本机的一个 loopback 端口。地址带一次性登录令牌，只在本机这次跳转里用一次。
-- **连不上时一键体检与部署**（`0.8.36+`）—— **连不上大多不是插件的问题，而是远端 dsh 的版本或环境不对**。体检（只读）会报出平台/node/npm/dsh 版本、**原生模块能否启动**、代理与 npm 源，并给出修复建议；「部署并验证」把它装到远端**私有目录**（不写系统目录、不改 PATH、不覆盖你在用的版本，删目录即回滚）并逐步校验。失败还能交给内置的 `dsh-remote-deploy` 技能排查。
+- **连不上时一键体检与部署**（`0.8.36+`）—— **连不上大多不是插件的问题，而是远端 dsh 的版本或环境不对**。体检（只读）会报出平台/node/npm/dsh 版本、**原生模块能否启动**、代理与 npm 源，并给出修复建议；「部署并验证」把它装到远端**私有目录**（不写系统目录、不改 PATH、不覆盖你在用的版本，删目录即回滚）并逐步校验。按钮**不再需要先体检**——直接点即可（`0.8.40+`），部署过程自己会重新体检。失败还能交给内置的 `dsh-remote-deploy` 技能排查。
 - **远端跨平台** —— 文件访问走 SFTP 协议层（不依赖 POSIX shell），Linux/macOS/Windows 远端都能列/读/写/搜索/同步。
 - **Windows 主机** —— 自动探测平台并定位 Git Bash，命令经 `bash -s` 走 stdin 执行，不受引号/反斜杠转义困扰（`config.shell` 可指定或设 `native` 关闭）；`C:\Users\dev` 与 `/c/Users/dev` 两种写法都接受。
 - **长任务异步化** —— `rw_sync`/`rw_push` 传 `async: true` 返回 `taskId`，可查询进度/结果/取消。
@@ -247,7 +247,7 @@ scripts/dev-run.sh --status    # 是否在运行
 | `webInstallVersion` | string | `0.1.5-rc.2` | 自动部署安装的 dsh 版本；默认值是第一个在 Linux 上能启动 web 的版本 |
 | `webInstallRegistry` | string | `''` | 安装用的 npm 源；**留空沿用远端自己的配置**，不会覆盖内网镜像 |
 | `backupDir` | string | `''` | 备份归档在**远端**的存放目录；留空用 `$HOME/.dsh-remote/backups`（在远端解析，不用本机 home 猜） |
-| `backupExcludes` | string[] | `[]` | 备份默认排除的路径（gitignore 风格）。**默认为空**：静默少打包目录正是「恢复即静默丢数据」的成因 |
+| `backupExcludes` | string[] | `[]` | 在**内置排除集之外**额外排除的路径（gitignore 风格）。设置页不再暴露此项；内置集已覆盖 `node_modules`/`.git`/`dist`/`build`/`target`/`__pycache__`/`.venv` 等（顶层与嵌套） |
 | `maxBackupTransferBytes` | int | `2147483648` | 归档在本机与远端之间搬运的大小上限（字节）；**远端的归档从不截断**，只约束可选的对拷。0 = 不限 |
 
 > 权威清单是 `lib/index.js` 里的 `Config` schema，本表与之一致。

package/lib/archive.js

@@ -244,6 +244,273 @@ export function excludeFlags(patterns = []) {
   return patterns.map((p) => shq(`--exclude=${p}`)).join(' ')
 }
 
+/** Marker value for the manifest directory inside a "all workspaces" archive. */
+export const ALL_MANIFEST_DIR = 'dsh-remote-backup.json'
+export const ALL_MANIFEST_FILE = 'manifest.json'
+
+/**
+ * Build the archive-creation script for SEVERAL workspaces at once.
+ *
+ * One archive, one restore button — the whole point is that the user does not
+ * have to think per-workspace. Members are stored by their ABSOLUTE path with
+ * the leading `/` stripped (`-C /`), next to a manifest listing each workspace's
+ * real absolute path. Restoring reads the manifest, so an archive made on one
+ * machine can be restored on another, where the same absolute path may not exist
+ * (the caller supplies the fallback location).
+ *
+ * Excludes are passed for the WHOLE set: `node_modules` must be skipped at any
+ * depth, so the caller passes both the bare form and the `*​/…` form (GNU tar
+ * matches a bare pattern at any depth already, but a pattern that contains a `/`
+ * is anchored, so the `*​/` variant is what keeps a NESTED `a/node_modules` out
+ * — measured, see the header note).
+ *
+ * @param {object} spec
+ * @param {Array<{path: string, member: string}>} spec.workspaces - absolute
+ *   directory paths plus the archive member each one is stored as.
+ * @param {string} spec.archive - absolute destination for the .tar.gz.
+ * @param {string} spec.manifestJson - sidecar manifest text stored in the archive.
+ * @param {string} [spec.pathsTsv] - `member<TAB>path` lines the restore loop reads
+ *   (the remote has no JSON parser we can rely on).
+ * @param {string[]} [spec.excludes] - NORMALIZED tar patterns (see parseExcludes).
+ * @returns {string} a POSIX shell script.
+ */
+export function buildCreateAllCommand({ workspaces = [], archive, manifestJson = '', pathsTsv = '', excludes = [] }) {
+  const seen = new Set()
+  const members = []
+  for (const w of workspaces) {
+    const p = String((w && w.path) || '')
+    const member = String((w && w.member) || '')
+    if (!p || p === '/' || seen.has(p)) continue
+    seen.add(p)
+    // Guard the member expression: a workspace the archive cannot address would
+    // silently land somewhere unexpected on restore.
+    if (!p.startsWith('/')) throw new Error(`dsh-remote: refusing to archive a non-absolute workspace path ${JSON.stringify(p)}`)
+    if (p.split('/').includes('..')) throw new Error(`dsh-remote: refusing to archive a workspace path containing '..': ${JSON.stringify(p)}`)
+    if (!member || member.startsWith('/') || member.split('/').includes('..')) {
+      throw new Error(`dsh-remote: refusing a bad archive member ${JSON.stringify(member)} for ${p}`)
+    }
+    members.push({ path: p, member })
+  }
+  if (!members.length) throw new Error('dsh-remote: no workspaces to archive')
+  for (const p of excludes) {
+    if (isUnsafeExclude(p) || p.startsWith('./') || p.startsWith('/')) {
+      throw new Error(`dsh-remote: refusing to run tar with unsafe/ineffective exclude pattern ${JSON.stringify(p)}`)
+    }
+  }
+  const flags = excludeFlags(excludes)
+  const manifestB64 = Buffer.from(String(manifestJson), 'utf8').toString('base64')
+  const pathsTsvB64 = Buffer.from(String(pathsTsv || ''), 'utf8').toString('base64')
+  return [
+    'set -u',
+    `ARCH_DST=${shq(archive)}`,
+    'ARCH_DIR=$(dirname "$ARCH_DST")',
+    'mkdir -p "$ARCH_DIR"',
+    'if [ ! -d "$ARCH_DIR" ]',
+    'then',
+    `  echo "${MARK.ok}=0"`,
+    `  echo "${MARK.error}=cannot create archive directory: $ARCH_DIR"`,
+    '  exit 1',
+    'fi',
+    // Refuse BEFORE writing anything when a listed workspace is gone: a silent
+    // partial archive is exactly how "I backed it up" becomes false.
+    // The check uses the REAL absolute path, not the archive member — the two
+    // differ (`/allws/w1` vs `allws/w1`), and checking the member is what the
+    // first version did, failing every run with "these workspaces do not exist".
+    'ARCH_MISSING=""',
+    ...members.map((m) => `if [ ! -d ${shq(m.path)} ]\nthen\n  ARCH_MISSING="$ARCH_MISSING ${shq(m.path)}"\nfi`),
+    'if [ -n "$ARCH_MISSING" ]',
+    'then',
+    `  echo "${MARK.ok}=0"`,
+    `  echo "${MARK.error}=these workspaces do not exist:$ARCH_MISSING"`,
+    '  exit 1',
+    'fi',
+    // The manifest is materialised into a staging dir and added with its OWN -C
+    // group, so one invocation writes the archive plus its manifest.
+    'ARCH_TMP="$ARCH_DST.stage.$$"',
+    'rm -rf "$ARCH_TMP"',
+    // The manifest lives in its OWN subdirectory inside the staging dir, because
+    // tar adds `"$ARCH_TMP"/dsh-remote-backup.json` as a member of that name.
+    // Writing the files flat into ARCH_TMP made tar fail with "Cannot stat" —
+    // caught by the real-shell run, not by a string assertion.
+    `mkdir -p "$ARCH_TMP/${ALL_MANIFEST_DIR}"`,
+    // Both manifest files are written HERE, before tar runs.
+    // Base64 avoids every quoting hazard in the text (quotes, tabs, newlines).
+    `printf '%s' ${shq(manifestB64)} | base64 -d > "$ARCH_TMP/${ALL_MANIFEST_DIR}/${ALL_MANIFEST_FILE}"`,
+    `printf '%s' ${shq(pathsTsvB64)} | base64 -d > "$ARCH_TMP/${ALL_MANIFEST_DIR}/paths.tsv"`,
+    'ARCH_STAGE="$ARCH_DST.stage.$$.tgz"',
+    'rm -f "$ARCH_STAGE"',
+    // `-C /` keeps member names absolute-relative (no leading slash), and `-C`
+    // again for the manifest dir; `-P` is never passed.
+    `tar -czf "$ARCH_STAGE" -C / ${flags ? flags + ' ' : ''}${members.map((m) => shq(m.member)).join(' ')} -C "$ARCH_TMP" ${shq(ALL_MANIFEST_DIR)} 2>&1`,
+    'ARCH_RC=$?',
+    'if [ "$ARCH_RC" -ne 0 ]',
+    'then',
+    `  echo "${MARK.ok}=0"`,
+    `  echo "${MARK.error}=tar failed with exit $ARCH_RC"`,
+    '  rm -f "$ARCH_STAGE"',
+    '  rm -rf "$ARCH_TMP"',
+    '  exit 1',
+    'fi',
+    'if [ ! -s "$ARCH_STAGE" ]',
+    'then',
+    `  echo "${MARK.ok}=0"`,
+    `  echo "${MARK.error}=tar produced an empty archive"`,
+    '  rm -f "$ARCH_STAGE"',
+    '  rm -rf "$ARCH_TMP"',
+    '  exit 1',
+    'fi',
+    'if tar -tzf "$ARCH_STAGE" >/dev/null 2>&1',
+    'then',
+    `  echo "${MARK.verify}=ok"`,
+    'else',
+    `  echo "${MARK.verify}=bad"`,
+    'fi',
+    'mv -f "$ARCH_STAGE" "$ARCH_DST"',
+    'rm -rf "$ARCH_TMP"',
+    'ARCH_BYTES=$(wc -c < "$ARCH_DST" | tr -d " ")',
+    'ARCH_MEMBERS=$(tar -tzf "$ARCH_DST" 2>/dev/null | wc -l | tr -d " ")',
+    'ARCH_SUM=""',
+    'if command -v sha256sum >/dev/null 2>&1',
+    'then',
+    '  ARCH_SUM=$(sha256sum "$ARCH_DST" | awk \'{print $1}\')',
+    'elif command -v shasum >/dev/null 2>&1',
+    'then',
+    '  ARCH_SUM=$(shasum -a 256 "$ARCH_DST" | awk \'{print $1}\')',
+    'elif command -v openssl >/dev/null 2>&1',
+    'then',
+    '  ARCH_SUM=$(openssl dgst -sha256 "$ARCH_DST" | awk \'{print $NF}\')',
+    'fi',
+    `echo "${MARK.file}=$ARCH_DST"`,
+    `echo "${MARK.bytes}=$ARCH_BYTES"`,
+    `echo "${MARK.members}=$ARCH_MEMBERS"`,
+    `echo "${MARK.sha}=$ARCH_SUM"`,
+    `echo "${MARK.ok}=1"`,
+  ].join('\n')
+}
+
+/**
+ * Build the restore-all script.
+ *
+ * Order matters and is the safety property: verify the stream, extract to a
+ * staging dir, then relocate each workspace into place. Relocation is
+ * per-workspace `mv` of the EXTRACTED copy over the destination, moving the
+ * previous contents aside first and deleting them only after the new tree is in
+ * place — the same stage/swap discipline as the single-workspace restore.
+ *
+ * A workspace in the manifest whose absolute path cannot be created falls back
+ * to `<fallbackRoot>/<basename>`, so an archive restored on a different machine
+ * still lands somewhere sensible instead of failing outright.
+ */
+export function buildRestoreAllCommand({ archive, fallbackRoot = '/tmp' }) {
+  return [
+    'set -u',
+    `ARCH_F=${shq(archive)}`,
+    `ARCH_FALLBACK=${shq(fallbackRoot)}`,
+    'if [ ! -f "$ARCH_F" ]',
+    'then',
+    `  echo "${MARK.ok}=0"`,
+    `  echo "${MARK.error}=archive not found: $ARCH_F"`,
+    '  exit 1',
+    'fi',
+    'if tar -tzf "$ARCH_F" >/dev/null 2>&1',
+    'then',
+    `  echo "${MARK.verify}=ok"`,
+    'else',
+    `  echo "${MARK.verify}=bad"`,
+    `  echo "${MARK.ok}=0"`,
+    `  echo "${MARK.error}=archive is corrupt or truncated; nothing was written"`,
+    '  exit 1',
+    'fi',
+    'ARCH_STAGE="$ARCH_F.extract.$$"',
+    'rm -rf "$ARCH_STAGE"',
+    'mkdir -p "$ARCH_STAGE"',
+    'if tar -xzf "$ARCH_F" -C "$ARCH_STAGE" 2>&1',
+    'then',
+    '  :',
+    'else',
+    '  rm -rf "$ARCH_STAGE"',
+    `  echo "${MARK.ok}=0"`,
+    `  echo "${MARK.error}=extraction failed; nothing was written"`,
+    '  exit 1',
+    'fi',
+    `if [ ! -f "$ARCH_STAGE/${ALL_MANIFEST_DIR}/${ALL_MANIFEST_FILE}" ]`,
+    'then',
+    '  rm -rf "$ARCH_STAGE"',
+    `  echo "${MARK.ok}=0"`,
+    `  echo "${MARK.error}=archive has no manifest (${ALL_MANIFEST_DIR}/${ALL_MANIFEST_FILE})"`,
+    '  exit 1',
+    'fi',
+    // Parse the manifest without jq: each workspace is one line of the form
+    // `MEMBER<TAB>PATH`, which the host emits into the manifest as an extra
+    // field for exactly this reason (no JSON parser on the remote).
+    `ARCH_LIST="$ARCH_STAGE/${ALL_MANIFEST_DIR}/paths.tsv"`,
+    'if [ ! -f "$ARCH_LIST" ]',
+    'then',
+    '  rm -rf "$ARCH_STAGE"',
+    `  echo "${MARK.ok}=0"`,
+    `  echo "${MARK.error}=archive manifest has no paths.tsv"`,
+    '  exit 1',
+    'fi',
+    'ARCH_RESTORED=0',
+    'ARCH_FAILED=""',
+    'while IFS="\t" read -r ARCH_MEMBER ARCH_TARGET',
+    'do',
+    '  if [ -z "$ARCH_MEMBER" ] || [ -z "$ARCH_TARGET" ]',
+    '  then',
+    '    continue',
+    '  fi',
+    '  ARCH_SRC="$ARCH_STAGE/$ARCH_MEMBER"',
+    '  if [ ! -e "$ARCH_SRC" ]',
+    '  then',
+    '    continue',
+    '  fi',
+    // An unwritable original location falls back to <fallback>/<basename> rather
+    // than failing the whole restore half-way.
+    '  ARCH_P=$(dirname "$ARCH_TARGET")',
+    '  if ! mkdir -p "$ARCH_P" 2>/dev/null',
+    '  then',
+    '    ARCH_TARGET="$ARCH_FALLBACK/$(basename "$ARCH_TARGET")"',
+    '    ARCH_P=$(dirname "$ARCH_TARGET")',
+    '    mkdir -p "$ARCH_P" 2>/dev/null || { ARCH_FAILED="$ARCH_FAILED $ARCH_SRC"; continue; }',
+    '  fi',
+    '  ARCH_SWAP="$ARCH_TARGET.dsh-remote-bak.$$"',
+    '  ARCH_HAD=0',
+    '  if [ -e "$ARCH_TARGET" ]',
+    '  then',
+    '    ARCH_HAD=1',
+    '    rm -rf "$ARCH_SWAP"',
+    '    if ! mv "$ARCH_TARGET" "$ARCH_SWAP"',
+    '    then',
+    '      ARCH_FAILED="$ARCH_FAILED $ARCH_TARGET"',
+    '      continue',
+    '    fi',
+    '  fi',
+    '  if mv "$ARCH_SRC" "$ARCH_TARGET"',
+    '  then',
+    '    if [ "$ARCH_HAD" = "1" ]',
+    '    then',
+    '      rm -rf "$ARCH_SWAP"',
+    '    fi',
+    '    ARCH_RESTORED=$((ARCH_RESTORED+1))',
+    `    echo "${MARK.entry}=$ARCH_TARGET"`,
+    '  else',
+    '    if [ "$ARCH_HAD" = "1" ]',
+    '    then',
+    '      mv "$ARCH_SWAP" "$ARCH_TARGET"',
+    '    fi',
+    '    ARCH_FAILED="$ARCH_FAILED $ARCH_TARGET"',
+    '  fi',
+    `done < "$ARCH_LIST"`,
+    'rm -rf "$ARCH_STAGE"',
+    `echo "${MARK.members}=$ARCH_RESTORED"`,
+    'if [ -n "$ARCH_FAILED" ]',
+    'then',
+    `  echo "${MARK.error}=could not restore:$ARCH_FAILED"`,
+    'fi',
+    `echo "${MARK.ok}=1"`,
+  ].join('\n')
+}
+
 /**
  * Build the archive-creation script.
  *
@@ -642,6 +909,64 @@ export function parseStatus(stdout) {
   }
 }
 
+/** Every `ARCH_ENTRY=` value from a restore-all run (one per relocated workspace). */
+export function parseRestoredEntries(stdout) {
+  const out = []
+  const re = new RegExp(`^${MARK.entry}=(.*)$`, 'gm')
+  let m
+  while ((m = re.exec(String(stdout ?? ''))) !== null) {
+    const v = m[1].trim()
+    if (v) out.push(v)
+  }
+  return out
+}
+
+/**
+ * The default exclude set for an "all workspaces" archive.
+ *
+ * Deliberately narrow and predictable: dependency/build trees that are huge,
+ * reproducible from the manifest, and the main reason a naive full backup is
+ * unusably large. Anything NOT listed here is archived — silently dropping more
+ * than this is how a restore turns into data loss.
+ *
+ * Both the bare and the star-prefixed form of each directory pattern are emitted
+ * because GNU tar anchors a pattern that contains a slash: the bare form covers
+ * the top level and the star-slash form covers every nested occurrence
+ * (measured, see the header).
+ */
+/** Directory names whose dependency/build content is excluded from an "all
+ *  workspaces" archive. Kept as bare names so the star-prefixed variants can be
+ *  DERIVED instead of typed — a hand-typed `*​/` once carried a zero-width space
+ *  that made the pattern unusable, and a derivation cannot do that. */
+export const ALL_BACKUP_EXCLUDE_DIRS = [
+  'node_modules', '.git', 'dist', 'build', 'target',
+  '__pycache__', '.venv', 'venv', '.tox', '.mypy_cache', '.pytest_cache',
+]
+
+/** Expand bare directory names into the tar patterns actually passed.
+ *
+ *  Both forms are needed: GNU tar anchors a pattern containing a slash, so the
+ *  bare name covers the top level while the star-prefixed one covers every nested
+ *  occurrence (measured on GNU tar 1.35 — see the module header). */
+export function expandExcludeDirs(dirs = ALL_BACKUP_EXCLUDE_DIRS) {
+  const out = []
+  for (const d of dirs) {
+    const name = String(d || '').trim()
+    if (!name) continue
+    out.push(name)
+    out.push(`*/${name}`)
+  }
+  return out
+}
+
+/** The default exclude set for an "all workspaces" archive.
+ *
+ *  Deliberately narrow and predictable: dependency/build trees that are huge,
+ *  reproducible from the manifest, and the main reason a naive full backup is
+ *  unusably large. Anything NOT listed here is archived — silently dropping more
+ *  than this is how a restore turns into data loss. */
+export const ALL_BACKUP_EXCLUDES = expandExcludeDirs()
+
 /**
  * Reject an exclude that would escape the workspace. Kept separate so the tool
  * can return a precise, actionable message instead of a generic failure, and so

package/lib/backup.js

@@ -34,6 +34,9 @@ import {
   buildDeleteCommand, buildRestoreCommand, parseCreateResult, parseListResult,
   parseStatus, resolveBackupDir, archiveName, archiveStem, metaNameFor,
   isSafeArchiveName, excludeRejection, backupDirUnderRoot, formatBytes,
+  buildCreateAllCommand, buildRestoreAllCommand, parseRestoredEntries,
+  ALL_MANIFEST_DIR, ALL_MANIFEST_FILE, ALL_BACKUP_EXCLUDES, expandExcludeDirs,
+  isUnsafeExclude,
 } from './archive.js'
 
 /** Parse one `ARCH_*` marker without importing the whole marker map. */
@@ -517,3 +520,192 @@ export function describeCreate(result, { dest = 'remote' } = {}) {
 
 /** Marker used by tests to assert the sidecar name derivation. */
 export { META_SUFFIX, ARCHIVE_SUFFIX, META_BEGIN_MARK }
+
+// ── "all workspaces" backup: ONE archive, ONE restore ───────────────────────
+//
+// The panel offers exactly two buttons, so this is the whole feature. Everything
+// the single-workspace flow learned still applies (stage-then-publish, verify
+// before writing, manifest for self-description); what changes is that the
+// archive holds MANY unrelated absolute directories and describes itself, so a
+// restore does not need the caller to remember which workspace it was for.
+
+/** Filename stem for an all-workspaces archive: the machine identity plus a
+ *  hash, so archives from different machines never share a stem. */
+export function allArchiveStem(machine = {}) {
+  const who = `${machine.username || 'user'}-${machine.host || 'host'}`
+  const slug = who.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'machine'
+  return `workspaces-${slug}-${shortHashLocal(`${machine.username || ''}@${machine.host || ''}:${machine.port || 22}`)}`
+}
+
+/** Local 32-bit base36 hash (kept here so this module has no extra import). */
+function shortHashLocal(s) {
+  let h = 0
+  for (let i = 0; i < String(s).length; i++) h = ((h << 5) - h + String(s).charCodeAt(i)) | 0
+  return (h >>> 0).toString(36)
+}
+
+/**
+ * The archive member for an absolute path: the path with its leading slash
+ * stripped, because members are added with `-C /`.
+ *
+ * It MUST be the full path, not a shortened display form. `-C /` resolves the
+ * member against the filesystem root, so a shortened member (`allws/w1`) makes
+ * tar look in `/allws/w1` while the real directory is `/tmp/allws/w1` — every
+ * run fails with "Cannot stat". (Measured on a real host; the shortening looked
+ * tidier and was simply wrong.)
+ */
+export function memberForPath(absPath) {
+  const p = String(absPath || '')
+  if (!p.startsWith('/') || p === '/') {
+    throw new Error(`dsh-remote: cannot archive a non-absolute path ${JSON.stringify(absPath)}`)
+  }
+  return p.replace(/^\/+/, '')
+}
+
+/** Attach the archive member to each distinct path. Members are unique whenever
+ *  the paths are, which is why no suffixing is needed (and why two different
+ *  `/a/x/proj` and `/b/x/proj` stay distinct: their full paths differ). */
+export function assignMembers(paths = []) {
+  const used = new Set()
+  const out = []
+  for (const p of paths) {
+    const path = String(p || '')
+    if (!path || path === '/' || used.has(path)) continue
+    used.add(path)
+    out.push({ path, member: memberForPath(path) })
+  }
+  return out
+}
+
+/**
+ * Create ONE archive containing every given workspace.
+ *
+ * @param {object} pool
+ * @param {object} spec
+ * @param {string[]} spec.workspaces - absolute remote directories.
+ * @param {string} spec.backupDir - absolute remote directory for the archive.
+ * @param {object} [spec.machine] - {host, username, port} recorded in the manifest.
+ * @param {string[]} [spec.extraExcludes] - added to the default exclude set.
+ * @param {string} [spec.label]
+ * @param {Date}   [spec.date]
+ * @returns {Promise<object>} the create result plus `workspaces` (the manifest).
+ */
+export async function createAllBackup(pool, spec = {}) {
+  const dirs = [...new Set((spec.workspaces || []).map((p) => String(p || '')).filter((p) => p && p !== '/'))]
+  if (!dirs.length) {
+    return { ok: false, error: 'no workspaces to back up — pick a remote workspace first', archive: '', name: '', bytes: 0, members: 0, sha256: '', verified: false, workspaces: [] }
+  }
+  const backupDir = String(spec.backupDir || '')
+  if (!backupDir) {
+    return { ok: false, error: 'cannot determine the remote backup directory — set backupDir', archive: '', name: '', bytes: 0, members: 0, sha256: '', verified: false, workspaces: [] }
+  }
+  const assigned = assignMembers(dirs)
+  const excludes = [...new Set([...ALL_BACKUP_EXCLUDES, ...expandExcludeDirs([]), ...(spec.extraExcludes || [])])]
+  // Never archive a previous backup of the same machine.
+  for (const d of dirs) {
+    const nested = backupDirUnderRoot(backupDir, d)
+    if (nested) excludes.push(nested)
+  }
+  for (const p of excludes) {
+    const bad = isUnsafeExclude(p) || p.startsWith('./') || p.startsWith('/')
+    if (bad) return { ok: false, error: `invalid exclude pattern: ${JSON.stringify(p)}`, archive: '', name: '', bytes: 0, members: 0, sha256: '', verified: false, workspaces: [] }
+  }
+
+  const baseName = `${allArchiveStem(spec.machine || {})}-${archiveName(spec.date ? new Date(spec.date) : new Date(), { label: spec.label || 'all' })}`
+  const archive = await uniqueArchivePath(pool, backupDir, baseName)
+  const name = archive.slice(archive.lastIndexOf('/') + 1)
+  const metaPath = `${backupDir}/${metaNameFor(name)}`
+
+  const manifest = {
+    kind: 'dsh-remote/workspaces',
+    version: 1,
+    createdAt: new Date().toISOString(),
+    machine: {
+      host: String((spec.machine && spec.machine.host) || ''),
+      username: String((spec.machine && spec.machine.username) || ''),
+      port: Number((spec.machine && spec.machine.port) || 22),
+    },
+    excludes,
+    workspaces: assigned.map((a) => ({ path: a.path, member: a.member })),
+  }
+  // The remote has no JSON parser we can rely on, so the manifest ships BOTH the
+  // human/JSON form and a TAB-separated member↔path list the restore loop reads.
+  // Both are passed to the builder, which writes them BEFORE tar runs.
+  const pathsTsv = assigned.map((a) => `${a.member}\t${a.path}`).join('\n') + '\n'
+  const withTsv = buildCreateAllCommand({
+    workspaces: assigned,
+    archive,
+    manifestJson: JSON.stringify(manifest, null, 2),
+    pathsTsv,
+    excludes,
+  })
+
+  let out
+  try {
+    out = await pool.exec(withTsv, spec.timeoutMs ? { timeoutMs: spec.timeoutMs } : {})
+  } catch (err) {
+    return { ok: false, error: String((err && err.message) || err), archive, name, bytes: 0, members: 0, sha256: '', verified: false, workspaces: assigned }
+  }
+  const parsed = parseCreateResult(out && out.stdout)
+  const stderr = String((out && out.stderr) || '').trim()
+  if (!parsed.ok) {
+    const detail = [parsed.error, stderr].filter(Boolean).join(' — ')
+    return { ok: false, error: detail || 'backup failed', archive, name, bytes: 0, members: 0, sha256: '', verified: false, workspaces: assigned }
+  }
+  const meta = { name, kind: 'workspaces', ...manifest, bytes: parsed.bytes, members: parsed.members, sha256: parsed.sha256, verified: parsed.verified, tool: 'dsh-remote' }
+  const metaWritten = await writeRemoteMeta(pool, metaPath, meta)
+  return {
+    ok: true,
+    error: '',
+    archive,
+    name,
+    metaPath,
+    bytes: parsed.bytes,
+    members: parsed.members,
+    sha256: parsed.sha256,
+    verified: parsed.verified,
+    metaWritten,
+    meta,
+    workspaces: assigned,
+  }
+}
+
+/** POSIX single-quote (local copy; keeps this module's imports minimal). */
+function shqLocal(s) {
+  return `'${String(s).replace(/'/g, `'\\''`)}'`
+}
+
+/**
+ * Restore every workspace from an all-workspaces archive.
+ * @param {object} pool
+ * @param {object} spec
+ * @param {string} spec.archive - absolute archive path on the remote.
+ * @param {string} [spec.fallbackRoot] - where a workspace lands when its original
+ *   absolute path cannot be created (e.g. restoring another machine's archive).
+ */
+export async function restoreAllBackup(pool, spec = {}) {
+  const archive = String(spec.archive || '')
+  if (!archive) return { ok: false, error: 'an archive is required', verified: false, entries: [], members: 0 }
+  const script = buildRestoreAllCommand({ archive, fallbackRoot: String(spec.fallbackRoot || '/tmp') })
+  let out
+  try {
+    out = await pool.exec(script, { timeoutMs: Number(spec.timeoutMs) || 0 })
+  } catch (err) {
+    return { ok: false, error: String((err && err.message) || err), verified: false, entries: [], members: 0 }
+  }
+  const status = parseStatus(out && out.stdout)
+  const entries = parseRestoredEntries(out && out.stdout)
+  const stderr = String((out && out.stderr) || '').trim()
+  if (!status.ok && !status.error) {
+    return { ok: false, error: stderr || 'restore failed before it could report a reason', verified: status.verified, entries, members: 0 }
+  }
+  return {
+    ok: status.ok,
+    // A partial restore still reports success for what moved, so the error text
+    // must survive alongside `ok` for the caller to show honestly.
+    error: status.error || (status.ok ? '' : stderr),
+    verified: status.verified,
+    entries,
+    members: status.members || entries.length,
+  }
+}

package/lib/client.js

@@ -188,42 +188,30 @@ window.__ModuleLoader__.load({
         'settings.modeOff': '关闭',
         'settings.modeManual': '手动',
         // ── 工作区备份（rw_backup / rw_restore）────────────────────────────
-        'settings.backup': '工作区备份（.tar.gz）',
-        'settings.backupHint': '把远程工作区打包成 .tar.gz。默认**全部收录**；需要更小的归档时再填排除项。归档可留在远端、拉到本机、或两边都留。',
-        'settings.backupCreate': '立即备份',
+        'settings.backup': '工作区备份',
+        'settings.backupHint': '一键把侧边栏里的所有远程工作区打包成一个 .tar.gz；恢复时用同一个归档把全部工作区还原。依赖/构建目录（node_modules、.git、dist、build…）会自动排除。',
+        'settings.backupCreate': '备份',
         'settings.backupCreating': '备份中…',
-        'settings.backupExcludes': '排除项（每行一个）',
-        'settings.backupExcludesPlaceholder': 'node_modules\n/build/\n*.log',
-        'settings.backupDest': '存放位置',
-        'settings.backupDestRemote': '仅远端',
-        'settings.backupDestLocal': '仅本机',
-        'settings.backupDestBoth': '两边都留',
+        'settings.backupRestore': '恢复',
+        'settings.backupRestoring': '恢复中…',
+        'settings.backupPickOne': '— 选择要恢复的备份时间点 —',
+        'settings.backupCovers': '本次将备份 {n} 个工作区：',
         'settings.backupDirLabel': '远端备份目录：{dir}',
-        'settings.backupDirUnknown': '（无法确定远端备份目录）',
-        'settings.backupNone': '还没有备份。点「立即备份」创建第一个。',
+        'settings.backupNone': '还没有备份。点「备份」创建第一个。',
         'settings.backupCount': '{n} 个备份',
-        'settings.backupWhereRemote': '远端',
-        'settings.backupWhereLocal': '本机',
-        'settings.backupRestore': '恢复',
-        'settings.backupDownload': '下载',
-        'settings.backupUpload': '传回远端',
+        'settings.backupEntries': '{n} 个条目',
+        'settings.backupDownload': '下载到本机',
         'settings.backupDelete': '删除',
         'settings.backupVerify': '校验',
-        'settings.backupRestoreConfirm': '要用 {file} 覆盖恢复远程工作区吗？归档里没有的文件会被删除（合并模式不删）。',
+        'settings.backupRestoreConfirm': '要用 {file} 恢复全部工作区吗？归档里没有的文件会被删除（原目录会先移到一旁，换入失败会自动还原）。',
         'settings.backupDeleteConfirm': '删除备份 {file}？此操作不可撤销。',
-        'settings.backupModeReplace': '整树替换',
-        'settings.backupModeMerge': '合并（不删除）',
         'settings.backupVerified': '校验通过：sha256 {sha}',
         'settings.backupVerifyMismatch': '校验失败：哈希与记录不一致（归档可能已损坏）',
-        'settings.backupNoSidecar': '无 sidecar（早期归档，元数据未知）',
-        'settings.backupRestored': '已恢复 {file} → {target}',
-        'settings.backupCreated': '已创建 {file}',
+        'settings.backupRestored': '已从 {file} 恢复：{target}',
+        'settings.backupCreatedN': '已备份 {n} 个工作区 → {file}',
         'settings.backupDownloaded': '已下载到本机：{path}',
-        'settings.backupUploaded': '已传回远端：{path}',
         'settings.backupDeleted': '已删除 {file}',
-        'settings.backupRefresh': '刷新列表',
         'settings.backupFailed': '备份操作失败：{msg}',
-        'settings.backupOverCap': '归档超过搬运上限，未传输（可用 maxBackupTransferBytes 放宽）',
         'settings.backupMachine': '机器',
         'settings.backupPickMachine': '— 选择机器 —',
         'picker.title': '选择工作目录',
@@ -485,42 +473,30 @@ window.__ModuleLoader__.load({
         'settings.modeOff': 'Off',
         'settings.modeManual': 'Manual',
         // ── workspace backup (rw_backup / rw_restore) ──────────────────────
-        'settings.backup': 'Workspace backup (.tar.gz)',
-        'settings.backupHint': 'Archive the remote workspace to a .tar.gz. **Everything is included by default**; add excludes only when you want a smaller archive. The archive can stay on the remote, be pulled here, or both.',
-        'settings.backupCreate': 'Back up now',
+        'settings.backup': 'Workspace backup',
+        'settings.backupHint': 'One click archives every remote workspace in the sidebar into a single .tar.gz; restore brings them all back from that archive. Dependency/build directories (node_modules, .git, dist, build…) are excluded automatically.',
+        'settings.backupCreate': 'Back up',
         'settings.backupCreating': 'Backing up…',
-        'settings.backupExcludes': 'Excludes (one per line)',
-        'settings.backupExcludesPlaceholder': 'node_modules\n/build/\n*.log',
-        'settings.backupDest': 'Store in',
-        'settings.backupDestRemote': 'Remote only',
-        'settings.backupDestLocal': 'Local only',
-        'settings.backupDestBoth': 'Both',
+        'settings.backupRestore': 'Restore',
+        'settings.backupRestoring': 'Restoring…',
+        'settings.backupPickOne': '— choose a backup point in time —',
+        'settings.backupCovers': 'This will back up {n} workspace(s):',
         'settings.backupDirLabel': 'Remote backup directory: {dir}',
-        'settings.backupDirUnknown': '(cannot determine the remote backup directory)',
-        'settings.backupNone': 'No backups yet. Click "Back up now" to create the first one.',
+        'settings.backupNone': 'No backups yet. Click "Back up" to create the first one.',
         'settings.backupCount': '{n} backup(s)',
-        'settings.backupWhereRemote': 'Remote',
-        'settings.backupWhereLocal': 'Local',
-        'settings.backupRestore': 'Restore',
+        'settings.backupEntries': '{n} entries',
         'settings.backupDownload': 'Download',
-        'settings.backupUpload': 'Upload',
         'settings.backupDelete': 'Delete',
         'settings.backupVerify': 'Verify',
-        'settings.backupRestoreConfirm': 'Overwrite the remote workspace with {file}? Files not present in the archive will be removed (merge mode deletes nothing).',
+        'settings.backupRestoreConfirm': 'Restore ALL workspaces from {file}? Files not present in the archive will be removed (each target is moved aside first, and restored automatically if the swap fails).',
         'settings.backupDeleteConfirm': 'Delete the backup {file}? This cannot be undone.',
-        'settings.backupModeReplace': 'Replace tree',
-        'settings.backupModeMerge': 'Merge (keep extra)',
         'settings.backupVerified': 'Verified: sha256 {sha}',
         'settings.backupVerifyMismatch': 'Verification FAILED: the digest does not match the recorded one (the archive may be corrupt)',
-        'settings.backupNoSidecar': 'No sidecar (older archive; metadata unknown)',
-        'settings.backupRestored': 'Restored {file} → {target}',
-        'settings.backupCreated': 'Created {file}',
+        'settings.backupRestored': 'Restored from {file}: {target}',
+        'settings.backupCreatedN': 'Backed up {n} workspace(s) → {file}',
         'settings.backupDownloaded': 'Downloaded locally: {path}',
-        'settings.backupUploaded': 'Uploaded to the remote: {path}',
         'settings.backupDeleted': 'Deleted {file}',
-        'settings.backupRefresh': 'Refresh list',
         'settings.backupFailed': 'Backup action failed: {msg}',
-        'settings.backupOverCap': 'The archive is over the transfer cap, so it was not transferred (raise maxBackupTransferBytes to allow it)',
         'settings.backupMachine': 'Machine',
         'settings.backupPickMachine': '— choose a machine —',
         'picker.title': 'Select working directory',
@@ -946,12 +922,10 @@ window.__ModuleLoader__.load({
       const [backupBusy, setBackupBusy] = React.useState('')
       const [backupMsg, setBackupMsg] = React.useState('')
       const [backupErr, setBackupErr] = React.useState('')
-      const [backupExcludes, setBackupExcludes] = React.useState('')
-      const [backupDest, setBackupDest] = React.useState('remote')
-      // Restore mode is a panel-level choice rather than a per-row prompt: the
-      // two modes differ in whether files absent from the archive are DELETED,
-      // so it is worth showing which one is armed before clicking Restore.
-      const [backupRestoreMode, setBackupRestoreMode] = React.useState('replace')
+      // `backupPick` is the archive the Restore/Verify/Delete buttons act on. A
+      // timestamp picker replaced the old per-row buttons: restoring is the rare
+      // action, and one selector is all it needs.
+      const [backupPick, setBackupPick] = React.useState('')
       const [backupMachine, setBackupMachine] = React.useState('')
       React.useEffect(() => { ensureChromeCss() }, [])
 
@@ -1057,17 +1031,23 @@ window.__ModuleLoader__.load({
         setBackupBusy(action); setBackupMsg(''); setBackupErr('')
         return api('POST', '/dsh-remote/backup', Object.assign({ action }, backupMachine ? { machineId: backupMachine } : {}, body || {}))
           .then((r) => {
-            if (r) setBackupData(r)
+            if (r) {
+              setBackupData(r)
+              // Keep the picker pointing at something real after a list refresh
+              // (a delete/restore changes the set): prefer the current choice,
+              // else the newest archive.
+              const names = (r.entries || []).map((e) => e.name)
+              setBackupPick((cur) => (cur && names.includes(cur) ? cur : (names[0] || '')))
+            }
             if (action === 'create' && r && r.created) {
-              setBackupMsg(tr('settings.backupCreated', { file: r.created.name }) + (r.pullError ? ' — ' + tr('settings.backupOverCap') + ' (' + r.pullError + ')' : ''))
+              setBackupMsg(tr('settings.backupCreatedN', { n: (r.created.workspaces || []).length, file: r.created.name }))
             } else if (action === 'restore' && r && r.restored) {
-              setBackupMsg(tr('settings.backupRestored', { file: r.restored.file, target: r.restored.target }))
+              setBackupMsg(tr('settings.backupRestored', { file: r.restored.file, target: (r.restored.targets || []).join('、') })
+                + (r.warning ? ' — ' + r.warning : ''))
             } else if (action === 'delete') {
               setBackupMsg(tr('settings.backupDeleted', { file: body.file }))
-            } else if (action === 'download' && r && r.localPath) {
-              setBackupMsg(tr('settings.backupDownloaded', { path: r.localPath }))
-            } else if (action === 'upload' && r && r.remotePath) {
-              setBackupMsg(tr('settings.backupUploaded', { path: r.remotePath }))
+            } else if (action === 'download' && r && (r.localPath || (r.restored && r.restored.file))) {
+              setBackupMsg(tr('settings.backupDownloaded', { path: r.localPath || body.file }))
             } else if (action === 'verify' && r) {
               setBackupMsg(r.matches === false || r.verified === false
                 ? tr('settings.backupVerifyMismatch')
@@ -1437,14 +1417,18 @@ window.__ModuleLoader__.load({
                 ? React.createElement('div', { style: { color: T.ok, marginTop: 4 } }, tr('settings.deployInvestigateStarted') + ' (' + deploy.sessionId + ')')
                 : null,
             ) : null,
-            // The install button only appears when a probe says it is both needed
-            // and possible; clicking it is the explicit consent (confirm: true).
-            deploy && deploy.verdict && deploy.verdict.canAutoInstall && !deploy.verdict.ok
-              ? React.createElement('button', { type: 'button', className: 'dsh-rw-btn dsh-rw-primary', style: { ...primaryBtnS, marginTop: 6 },
-                  disabled: !!deployBusy,
-                  onClick: () => { if (window.confirm(tr('settings.deployConfirm'))) deployAction('install', webAttachMachine, { confirm: true }) } },
-                  deployBusy === 'install' ? tr('settings.deployInstalling') : tr('settings.deployInstall'))
-              : null,
+            // Deploy is ALWAYS available — not hidden behind a prior probe.
+            //
+            // It used to render only when a probe had already run AND reported
+            // something wrong (`deploy.verdict.canAutoInstall && !deploy.verdict.ok`),
+            // which meant a user who only ever saw 体检 could never deploy: the
+            // button that does the work was waiting behind a check they had no
+            // reason to run. The host action re-probes internally anyway, so it is
+            // safe to offer directly; clicking it is the explicit consent.
+            React.createElement('button', { type: 'button', className: 'dsh-rw-btn dsh-rw-primary', style: { ...primaryBtnS, marginTop: 6 },
+              disabled: !!deployBusy || !webAttachMachine,
+              onClick: () => { if (window.confirm(tr('settings.deployConfirm'))) deployAction('install', webAttachMachine, { confirm: true }) } },
+              deployBusy === 'install' ? tr('settings.deployInstalling') : tr('settings.deployInstall')),
             // The AI escape hatch: offered after a failure, and ONLY on click —
             // it costs a model call, so it is never automatic.
             (deployErr || (deploy && deploy.ok === false))
@@ -1461,94 +1445,78 @@ window.__ModuleLoader__.load({
           ) : React.createElement('div', { style: { fontSize: 11, opacity: 0.55 } }, deploy && deploy.verdict ? (deploy.verdict.ok ? tr('settings.deployOk') : tr('settings.deployBlocked')) : ''),
         ),
         // 工作区备份（rw_backup / rw_backup_list / rw_restore）
+        //
+        // TWO buttons and a timestamp picker on purpose. The first version exposed
+        // excludes / destination / per-archive verify-download-upload-delete, which
+        // turned "keep a copy of my workspaces" into a configuration exercise.
+        // Everything that needed deciding now lives in code (the exclude set) or
+        // is derived (which workspaces = whatever the sidebar shows).
         React.createElement('div', { style: boxS },
           sectionToggle(backupOpen, setBackupOpen, tr('settings.backup'),
             backupData ? React.createElement('span', { style: { marginLeft: 'auto', fontSize: 11, opacity: 0.6 } },
-              tr('settings.backupCount', { n: (backupData.entries || []).length + ((backupData.local && backupData.local.entries) || []).length })) : null),
+              tr('settings.backupCount', { n: (backupData.entries || []).length })) : null),
           backupOpen ? React.createElement(React.Fragment, null,
             React.createElement('div', { style: { opacity: 0.65, fontSize: 11, lineHeight: 1.5, marginBottom: 6 } }, tr('settings.backupHint')),
-            React.createElement('div', { style: { fontSize: 11, opacity: 0.7, marginBottom: 6, wordBreak: 'break-all' } },
-              backupData && backupData.backupDir ? tr('settings.backupDirLabel', { dir: backupData.backupDir }) : tr('settings.backupDirUnknown')),
-            // Machine selector: empty means "this session's machine", which the
-            // host resolves from the session binding (the panel is reachable from
-            // a local session too, hence an explicit choice is always available).
-            React.createElement('div', { style: { display: 'flex', gap: 6, alignItems: 'center', marginBottom: 6, flexWrap: 'wrap' } },
+            // Say exactly what will be included, before the click.
+            backupData && (backupData.covers || []).length
+              ? React.createElement('div', { style: { fontSize: 11, opacity: 0.8, marginBottom: 6, wordBreak: 'break-all' } },
+                  tr('settings.backupCovers', { n: (backupData.covers || []).length }) + ' ' + (backupData.covers || []).join('、'))
+              : null,
+            backupData && backupData.backupDir
+              ? React.createElement('div', { style: { fontSize: 11, opacity: 0.6, marginBottom: 8, wordBreak: 'break-all' } },
+                  tr('settings.backupDirLabel', { dir: backupData.backupDir }))
+              : null,
+            // Machine selector: empty means "this session's machine". Kept because
+            // the panel is reachable from a local session, where there is no
+            // session binding to resolve.
+            React.createElement('div', { style: { display: 'flex', gap: 6, alignItems: 'center', marginBottom: 8, flexWrap: 'wrap' } },
               React.createElement('span', { style: { fontSize: 12, opacity: 0.8 } }, tr('settings.backupMachine') + ':'),
-              React.createElement('select', { className: 'dsh-rw-input', value: backupMachine, onChange: (e) => setBackupMachine(e.target.value), style: { ...inputS, maxWidth: 200 } },
+              React.createElement('select', { className: 'dsh-rw-input', value: backupMachine, onChange: (e) => setBackupMachine(e.target.value), style: { ...inputS, maxWidth: 220 } },
                 React.createElement('option', { value: '' }, tr('settings.backupPickMachine')),
-                machines.map((m) => React.createElement('option', { key: m.id, value: m.id }, `${m.name || m.host} (${m.username}@${m.host})`))),
-              React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 10px' },
-                disabled: !!backupBusy, onClick: () => refreshBackups() }, tr('settings.backupRefresh')),
-              // Which restore mode the Restore button will use.
-              React.createElement('span', { style: { fontSize: 12, opacity: 0.8, marginLeft: 4 } }, tr('settings.backupRestore') + ':'),
+                machines.map((m) => React.createElement('option', { key: m.id, value: m.id }, `${m.name || m.host} (${m.username}@${m.host})`)))),
+            // ── the two buttons ───────────────────────────────────────────────
+            React.createElement('div', { style: { display: 'flex', gap: 8, alignItems: 'center', flexWrap: 'wrap' } },
+              React.createElement('button', {
+                type: 'button', className: 'dsh-rw-btn dsh-rw-primary', style: { ...primaryBtnS },
+                disabled: !!backupBusy,
+                onClick: () => backupAction('create'),
+              }, backupBusy === 'create' ? tr('settings.backupCreating') : tr('settings.backupCreate')),
               React.createElement('select', {
-                className: 'dsh-rw-input', value: backupRestoreMode,
-                onChange: (e) => setBackupRestoreMode(e.target.value),
-                style: { ...inputS, maxWidth: 170 },
+                className: 'dsh-rw-input',
+                value: backupPick,
+                onChange: (e) => setBackupPick(e.target.value),
+                style: { ...inputS, flex: '1 1 260px', minWidth: 200, maxWidth: 380 },
               },
-                React.createElement('option', { value: 'replace' }, tr('settings.backupModeReplace')),
-                React.createElement('option', { value: 'merge' }, tr('settings.backupModeMerge')))),
-            // Excludes + destination, then the create button.
-            React.createElement('div', { style: { display: 'flex', gap: 8, alignItems: 'flex-start', flexWrap: 'wrap', marginBottom: 6 } },
-              React.createElement('div', { style: { flex: '1 1 260px', minWidth: 220 } },
-                React.createElement('div', { style: { fontSize: 11, opacity: 0.75, marginBottom: 2 } }, tr('settings.backupExcludes')),
-                React.createElement('textarea', {
-                  className: 'dsh-rw-input', value: backupExcludes,
-                  onChange: (e) => setBackupExcludes(e.target.value),
-                  placeholder: tr('settings.backupExcludesPlaceholder'),
-                  rows: 3, style: { ...inputS, width: '100%', fontFamily: 'monospace', resize: 'vertical' },
-                })),
-              React.createElement('div', null,
-                React.createElement('div', { style: { fontSize: 11, opacity: 0.75, marginBottom: 2 } }, tr('settings.backupDest')),
-                React.createElement('select', { className: 'dsh-rw-input', value: backupDest, onChange: (e) => setBackupDest(e.target.value), style: { ...inputS, maxWidth: 160 } },
-                  React.createElement('option', { value: 'remote' }, tr('settings.backupDestRemote')),
-                  React.createElement('option', { value: 'local' }, tr('settings.backupDestLocal')),
-                  React.createElement('option', { value: 'both' }, tr('settings.backupDestBoth'))),
-                React.createElement('button', {
-                  type: 'button', className: 'dsh-rw-btn dsh-rw-primary',
-                  style: { ...primaryBtnS, marginTop: 6, display: 'block' },
-                  disabled: !!backupBusy,
-                  onClick: () => backupAction('create', { excludes: backupExcludes, dest: backupDest }),
-                }, backupBusy === 'create' ? tr('settings.backupCreating') : tr('settings.backupCreate')))),
-            // The list: remote archives then local copies. A sidecar-less archive
-            // is labelled instead of showing invented metadata.
-            (backupData && (backupData.entries || []).length) || (backupData && backupData.local && (backupData.local.entries || []).length)
-              ? React.createElement('div', { style: { maxHeight: 280, overflowY: 'auto' } },
-                  (backupData.entries || []).map((e) => React.createElement('div', { key: 'r-' + e.name, className: 'dsh-rw-row', style: { display: 'flex', gap: 6, alignItems: 'center', padding: '5px 0', borderBottom: '1px solid ' + T.border, fontSize: 12, flexWrap: 'wrap' } },
-                    React.createElement('span', { style: { fontFamily: 'monospace', flex: '1 1 220px', wordBreak: 'break-all' } }, e.name),
-                    React.createElement('span', { style: { opacity: 0.7, minWidth: 60 } }, humanSize(e.bytes)),
-                    React.createElement('span', { style: { opacity: 0.7 } }, e.createdAt || e.mtime || ''),
-                    React.createElement('span', { style: { opacity: 0.55, fontSize: 11 } }, tr('settings.backupWhereRemote')),
-                    e.hasMeta ? null : React.createElement('span', { style: { color: T.warn, fontSize: 11 } }, tr('settings.backupNoSidecar')),
-                    React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 8px' }, disabled: !!backupBusy,
-                      onClick: () => backupAction('verify', { file: e.name }) }, tr('settings.backupVerify')),
-                    React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 8px' }, disabled: !!backupBusy,
-                      onClick: () => backupAction('download', { file: e.name }) }, tr('settings.backupDownload')),
-                    // Restore is destructive, so it asks first and sends the
-                    // explicit confirmation the host requires.
-                    React.createElement('button', { type: 'button', className: 'dsh-rw-btn dsh-rw-primary', style: { ...primaryBtnS, padding: '2px 8px' }, disabled: !!backupBusy,
-                      onClick: () => {
-                        if (!window.confirm(tr('settings.backupRestoreConfirm', { file: e.name }))) return
-                        backupAction('restore', { file: e.name, confirm: true, mode: backupRestoreMode })
-                      } }, tr('settings.backupRestore')),
-                    React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 8px', color: T.dangerText }, disabled: !!backupBusy,
-                      onClick: () => { if (window.confirm(tr('settings.backupDeleteConfirm', { file: e.name }))) backupAction('delete', { file: e.name }) } }, tr('settings.backupDelete')))),
-                  ((backupData.local && backupData.local.entries) || []).map((e) => React.createElement('div', { key: 'l-' + e.name, className: 'dsh-rw-row', style: { display: 'flex', gap: 6, alignItems: 'center', padding: '5px 0', borderBottom: '1px solid ' + T.border, fontSize: 12, opacity: 0.92, flexWrap: 'wrap' } },
-                    React.createElement('span', { style: { fontFamily: 'monospace', flex: '1 1 220px', wordBreak: 'break-all' } }, e.name),
-                    React.createElement('span', { style: { opacity: 0.7, minWidth: 60 } }, humanSize(e.bytes)),
-                    React.createElement('span', { style: { opacity: 0.7 } }, e.createdAt || e.mtime || ''),
-                    React.createElement('span', { style: { opacity: 0.55, fontSize: 11 } }, tr('settings.backupWhereLocal')),
-                    React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 8px' }, disabled: !!backupBusy,
-                      onClick: () => backupAction('verify', { file: e.name, where: 'local' }) }, tr('settings.backupVerify')),
-                    React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 8px' }, disabled: !!backupBusy,
-                      onClick: () => backupAction('upload', { file: e.name }) }, tr('settings.backupUpload')),
-                    React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 8px', color: T.dangerText }, disabled: !!backupBusy,
-                      onClick: () => { if (window.confirm(tr('settings.backupDeleteConfirm', { file: e.name }))) backupAction('delete', { file: e.name, where: 'local' }) } }, tr('settings.backupDelete')))))
-              : React.createElement('div', { style: { opacity: 0.6, fontSize: 12 } }, tr('settings.backupNone')),
-            backupMsg ? React.createElement('div', { style: { marginTop: 6, fontSize: 12, color: T.ok, wordBreak: 'break-all' } }, backupMsg) : null,
-            backupErr ? React.createElement('div', { style: { marginTop: 6, fontSize: 12, color: T.danger, wordBreak: 'break-all' } }, backupErr) : null,
+                React.createElement('option', { value: '' }, tr('settings.backupPickOne')),
+                (backupData && backupData.entries ? backupData.entries : []).map((e, i) => React.createElement('option', { key: e.name, value: e.name },
+                  `${e.createdAt ? e.createdAt.replace('T', ' ').slice(0, 19) : e.mtime || ''}  ·  ${humanSize(e.bytes)}  ·  ${tr('settings.backupEntries', { n: e.members == null ? '?' : e.members })}  ·  ${e.name}`))),
+              React.createElement('button', {
+                type: 'button', className: 'dsh-rw-btn',
+                style: { ...buttonS },
+                disabled: !!backupBusy || !backupPick,
+                onClick: () => {
+                  if (!window.confirm(tr('settings.backupRestoreConfirm', { file: backupPick }))) return
+                  backupAction('restore', { file: backupPick, confirm: true })
+                },
+              }, backupBusy === 'restore' ? tr('settings.backupRestoring') : tr('settings.backupRestore'))),
+            // Housekeeping stays available but out of the way: verify and delete
+            // whatever the picker has selected.
+            backupPick
+              ? React.createElement('div', { style: { marginTop: 6, display: 'flex', gap: 8, alignItems: 'center', flexWrap: 'wrap' } },
+                  React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 10px' }, disabled: !!backupBusy,
+                    onClick: () => backupAction('verify', { file: backupPick }) }, tr('settings.backupVerify')),
+                  React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 10px' }, disabled: !!backupBusy,
+                    onClick: () => backupAction('download', { file: backupPick }) }, tr('settings.backupDownload')),
+                  React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, padding: '2px 10px', color: T.dangerText }, disabled: !!backupBusy,
+                    onClick: () => { if (window.confirm(tr('settings.backupDeleteConfirm', { file: backupPick }))) backupAction('delete', { file: backupPick }) } }, tr('settings.backupDelete')))
+              : null,
+            backupMsg ? React.createElement('div', { style: { marginTop: 8, fontSize: 12, color: T.ok, wordBreak: 'break-all' } }, backupMsg) : null,
+            backupErr ? React.createElement('div', { style: { marginTop: 8, fontSize: 12, color: T.danger, wordBreak: 'break-all' } }, backupErr) : null,
+            !backupData || !(backupData.entries || []).length
+              ? React.createElement('div', { style: { marginTop: 8, opacity: 0.6, fontSize: 12 } }, tr('settings.backupNone'))
+              : null,
           ) : backupData ? React.createElement('div', { style: { fontSize: 11, opacity: 0.55 } },
-              tr('settings.backupCount', { n: (backupData.entries || []).length + ((backupData.local && backupData.local.entries) || []).length })) : null,
+              tr('settings.backupCount', { n: (backupData.entries || []).length })) : null,
         ),
         // 端口转发面板
         React.createElement('div', { style: boxS },

package/lib/index.js

@@ -1311,6 +1311,60 @@ export async function apply(ctx, config) {
   /** Local directory holding archives pulled from one machine. */
   const localBackupRootFor = (b) => localBackupDirFor(mirrorRootFor(b.host, b.username, b.port))
 
+  /**
+   * Every REMOTE workspace the sidebar knows about for one machine.
+   *
+   * "Back up all my workspaces" has to mean what the user sees in the sidebar, so
+   * this walks the mirror registry rather than the machine's recent-workspaces
+   * list: each mirror dir carries `.dsh-remote-meta.json` with the remote origin,
+   * which is authoritative and survives the sidebar's own storage being reset.
+   * The machine's remembered workspaces are unioned in as a fallback for
+   * workspaces that have never been mirrored on this machine.
+   *
+   * @param {{host: string, username: string, port: number}} machine
+   * @returns {string[]} absolute REMOTE directory paths, de-duplicated.
+   */
+  const remoteWorkspacesFor = (machine) => {
+    const out = new Set()
+    const host = String((machine && machine.host) || '')
+    const username = String((machine && machine.username) || '')
+    const port = Number((machine && machine.port) || 22)
+    if (!host) return []
+    // 1) Mirror dirs for THIS machine (the sidebar's remote entries).
+    try {
+      const hostDir = mirrorRootFor(host, username, port)
+      if (existsSync(hostDir)) {
+        for (const entry of readdirSync(hostDir)) {
+          const metaPath = path.join(hostDir, entry, '.dsh-remote-meta.json')
+          if (!existsSync(metaPath)) continue
+          try {
+            const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+            if (!meta || !meta.remotePath) continue
+            // Only mirrors that unambiguously belong to this machine.
+            if (String(meta.host || '') !== host) continue
+            if (Number(meta.port || 22) !== port) continue
+            if (username && String(meta.username || '') !== username) continue
+            out.add(normalizeRemotePath(meta.remotePath))
+          } catch { /* unreadable meta → not a usable workspace */ }
+        }
+      }
+    } catch { /* registry unreadable */ }
+    // 2) Workspaces the registry remembers for this machine, even if unmirrored.
+    const rec = machines.find((m) => m.host === host
+      && Number(m.port || 22) === port
+      && (!username || m.username === username))
+    const remembered = [rec && rec.workspace, ...((rec && rec.recentWorkspaces) || [])]
+    for (const p of remembered) {
+      const norm = p ? normalizeRemotePath(String(p)) : ''
+      if (norm && norm !== '/') out.add(norm)
+    }
+    // 3) The mirror the calling session is bound to, if any (a session can be
+    //    bound to a workspace the registry has not recorded yet).
+    const bound = wsPath()
+    if (bound) out.add(normalizeRemotePath(bound))
+    return [...out]
+  }
+
   // ── tools ─────────────────────────────────────────────────────────────────
 
   const textOut = {
@@ -2820,6 +2874,9 @@ export async function apply(ctx, config) {
         }
       },
       localRootFor: localBackupRootFor,
+      // "Back up all my workspaces" means what the SIDEBAR shows, so the route
+      // asks the same collection the panel displays.
+      workspacesFor: (b) => remoteWorkspacesFor({ host: b.host, username: b.username, port: b.port }),
     }),
 
     {

package/lib/routes-backup.js

@@ -1,21 +1,20 @@
-// Settings-panel routes for workspace compressed backup / restore.
+// Settings-panel routes for workspace backup / restore.
 //
 // Kept in its own module (like lib/routes-fs.js) so the route surface stays
 // readable and the whole thing is unit-testable with an injected binding — the
 // production wiring in lib/index.js supplies the real SSH pool, audit log and
 // configuration.
 //
-// Scope: this is the machine/session-scoped JSON API behind Settings → 备份.
-// The model-facing equivalents are the rw_backup / rw_backup_list / rw_restore
-// tools, which resolve their own session binding and share the same lib/backup.js
-// implementation — one behaviour, two entrances.
+// Scope: the machine/session-scoped JSON API behind Settings → 工作区备份. The
+// panel deliberately exposes only two actions (create / restore) plus
+// list-verify-delete housekeeping; the model-facing equivalents are the
+// rw_backup / rw_backup_list / rw_restore tools, which share lib/backup.js.
 import {
-  createBackup, listBackups, verifyBackup, deleteBackup, restoreBackup,
-  pullBackup, pushBackup, listLocalBackups, deleteLocalBackup, verifyLocalBackup,
-  resolveRemoteHome,
+  listBackups, verifyBackup, deleteBackup, pullBackup, listLocalBackups,
+  deleteLocalBackup, verifyLocalBackup, resolveRemoteHome, describeCreate,
+  createAllBackup, restoreAllBackup,
 } from './backup.js'
-import { parseExcludes, resolveBackupDir, isSafeArchiveName, formatBytes, DEFAULT_MAX_TRANSFER_BYTES } from './archive.js'
-import { describeCreate } from './backup.js'
+import { resolveBackupDir, isSafeArchiveName, DEFAULT_MAX_TRANSFER_BYTES } from './archive.js'
 
 /** Default cap on a cross-machine archive copy; the archive itself is uncapped. */
 export { DEFAULT_MAX_TRANSFER_BYTES }
@@ -29,10 +28,12 @@ export { DEFAULT_MAX_TRANSFER_BYTES }
  * @param {Function} deps.resolveRequestBinding - (req, body) => binding (see routes-fs)
  * @param {Function} deps.resolveMachineBinding - (machineId) => binding for an explicit machine
  * @param {Function} deps.localRootFor - (binding) => local directory for pulled archives
+ * @param {Function} deps.workspacesFor - (binding) => string[] of REMOTE workspace paths
  * @returns {Array<object>} route definitions
  */
 export function createBackupRoutes({
   sendJson, readBody, config, audit, resolveRequestBinding, resolveMachineBinding, localRootFor,
+  workspacesFor,
 }) {
   const maxTransfer = Number(config.maxBackupTransferBytes) > 0
     ? Number(config.maxBackupTransferBytes)
@@ -76,8 +77,15 @@ export function createBackupRoutes({
     }
     const localDir = localRootFor(b)
     const local = listLocalBackups(localDir)
+    // Which remote workspaces this backup WOULD include — shown before the user
+    // clicks, so "back up all my workspaces" is never a surprise.
+    let covers = []
+    try {
+      covers = typeof workspacesFor === 'function' ? (workspacesFor(b) || []) : (b.ws ? [b.ws] : [])
+    } catch { covers = b.ws ? [b.ws] : [] }
     return {
       workspace: b.ws || '',
+      covers,
       host: b.host,
       username: b.username,
       port: b.port,
@@ -135,47 +143,30 @@ export function createBackupRoutes({
 
         try {
           if (action === 'create') {
-            const parsed = parseExcludes(body.excludes)
-            // The UI may target a subdirectory of the workspace; it must stay
-            // inside it, otherwise "backup" could archive the whole home dir.
-            let dir = b.ws || ''
-            const requested = String(body.path || '').trim()
-            if (requested && b.ws && requested !== b.ws
-              && !requested.startsWith(b.ws.replace(/\/+$/, '') + '/')) {
-              return sendJson(res, 400, { ok: false, error: '只允许备份当前工作区目录（或其子目录）' })
-            }
-            if (requested) dir = requested
-            if (!dir) return sendJson(res, 400, { ok: false, error: '没有远程工作区可备份——先选择一个远程工作区' })
-            const dest = ['remote', 'local', 'both'].includes(String(body.dest)) ? String(body.dest) : 'remote'
+            // ONE button: archive every remote workspace the sidebar knows about
+            // for this machine. There is no per-workspace choice, no exclude box
+            // and no destination picker on purpose — the default exclude set
+            // (dependency/build trees) is the only thing worth deciding, and it
+            // lives in code where it is reviewable.
             const backupDir = await backupDirFor(b)
             if (!backupDir) return sendJson(res, 400, { ok: false, error: '无法确定远端 $HOME，请配置 backupDir' })
-            const result = await createBackup(b.pool, {
-              dir,
+            let covers = []
+            try { covers = (typeof workspacesFor === 'function' ? workspacesFor(b) : []) || [] } catch { covers = [] }
+            if (!covers.length && b.ws) covers = [b.ws]
+            if (!covers.length) {
+              return sendJson(res, 400, { ok: false, error: '没有可备份的远程工作区——先在侧边栏里选一个远程工作区' })
+            }
+            const result = await createAllBackup(b.pool, {
+              workspaces: covers,
               backupDir,
-              label: String(body.label || 'manual'),
-              excludes: parsed.patterns,
-              meta: { username: b.username, host: b.host, port: b.port },
+              machine: { host: b.host, username: b.username, port: b.port },
+              label: 'all',
             })
             if (!result.ok) {
-              audit('backup', `backup ${dir} failed: ${result.error}`, 1, b)
-              return sendJson(res, 500, { ok: false, error: result.error, droppedExcludes: parsed.dropped })
-            }
-            audit('backup', `backup ${dir} → ${result.archive}`, 0, b)
-            let pulled = null
-            let pullError = ''
-            if (dest === 'local' || dest === 'both') {
-              pulled = await pullBackup(b.pool, { archive: result.archive, localDir: localRootFor(b), maxTransferBytes: maxTransfer })
-              if (!pulled.ok) pullError = pulled.error
-              else audit('backup', `pull ${result.name} → ${pulled.localPath}`, 0, b)
-            }
-            // Local-only means the remote copy is a staging step: drop it so the
-            // "dest: local" promise is honoured (and say so if removal failed).
-            let remoteRemoved = null
-            if (dest === 'local' && result.ok) {
-              const del = await deleteBackup(b.pool, { archive: result.archive })
-              remoteRemoved = !!del.ok
-              if (del.ok) audit('backup', `removed remote staging copy ${result.name}`, 0, b)
+              audit('backup', `backup ${covers.length} workspace(s) failed: ${result.error}`, 1, b)
+              return sendJson(res, 500, { ok: false, error: result.error })
             }
+            audit('backup', `backup ${covers.length} workspace(s) → ${result.archive}`, 0, b)
             return sendJson(res, 200, {
               ok: true,
               created: {
@@ -185,13 +176,9 @@ export function createBackupRoutes({
                 members: result.members,
                 sha256: result.sha256,
                 verified: result.verified,
-                dest,
+                workspaces: covers,
               },
-              summary: describeCreate(result, { dest }),
-              localPath: pulled && pulled.ok ? pulled.localPath : '',
-              pullError,
-              remoteRemoved,
-              droppedExcludes: parsed.dropped,
+              summary: describeCreate(result, { dest: 'remote' }),
               ...(await collect(b)),
             })
           }
@@ -202,35 +189,18 @@ export function createBackupRoutes({
             if (body.confirm !== true) return sendJson(res, 400, { ok: false, error: '恢复需要显式确认（confirm: true）' })
             const file = String(body.file || '')
             if (!isSafeArchiveName(file)) return sendJson(res, 400, { ok: false, error: '无效的备份文件名' })
-            const mode = body.mode === 'merge' ? 'merge' : 'replace'
-            const target = String(body.target || '').trim() || b.ws || ''
-            if (!target || target === '/') return sendJson(res, 400, { ok: false, error: '没有恢复目标目录' })
-            const where = body.where === 'local' ? 'local' : 'remote'
-            let archive = ''
-            let uploaded = null
-            if (where === 'local') {
-              // A pulled copy is restored by pushing it back first: the extract
-              // itself must happen where the workspace lives.
-              const localDir = localRootFor(b)
-              const up = await pushBackup(b.pool, {
-                localPath: `${localDir.replace(/\/+$/, '')}/${file}`,
-                remoteDir: await backupDirFor(b),
-                maxTransferBytes: maxTransfer,
-              })
-              if (!up.ok) return sendJson(res, 500, { ok: false, error: up.error })
-              uploaded = up.remotePath
-              archive = up.remotePath
-            } else {
-              archive = `${(await backupDirFor(b)).replace(/\/+$/, '')}/${file}`
-            }
-            const r = await restoreBackup(b.pool, { archive, target, mode })
-            audit('restore', `${mode} restore ${file} → ${target}`, r.ok ? 0 : 1, b)
-            if (!r.ok) return sendJson(res, 500, { ok: false, error: r.error, mode, target, uploaded })
+            const dir = await backupDirFor(b)
+            if (!dir) return sendJson(res, 400, { ok: false, error: '无法确定远端备份目录' })
+            const archive = `${dir.replace(/\/+$/, '')}/${file}`
+            const r = await restoreAllBackup(b.pool, { archive, fallbackRoot: '/tmp' })
+            audit('restore', `restore ${file} (${r.members} workspace(s))`, r.ok ? 0 : 1, b)
+            if (!r.ok) return sendJson(res, 500, { ok: false, error: r.error })
             return sendJson(res, 200, {
               ok: true,
-              restored: { file, mode: r.mode, target, members: r.members, from: where },
-              uploaded,
-              text: `已${r.mode === 'merge' ? '合并' : '替换'}恢复 ${file} → ${target}（${r.members} 个文件）`,
+              restored: { file, targets: r.entries, count: r.members },
+              text: `已恢复 ${r.members} 个工作区：${(r.entries || []).join('、')}`,
+              // A partial restore reports what moved AND what failed.
+              warning: r.error || '',
               ...(await collect(b)),
             })
           }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-remote",
-  "version": "0.8.39",
-  "description": "Remote-work assistant for DeepSeek Harness: connect SSH (password/key/agent/keyboard-interactive/proxy jump), pick a remote workspace, operate on it with 25 rw_* tools (incl. rw_edit/rw_stat/rw_mkdir/rw_remove/rw_move/rw_forward), conflict-aware mirror sync, workspace backup/restore, port forwarding, optional side-bar remote file editing, audit log, keychain passwords.",
+  "version": "0.8.40",
+  "description": "Remote-work assistant for DeepSeek Harness: connect SSH (password/key/agent/keyboard-interactive/proxy jump), pick a remote workspace, operate on it with 25 rw_* tools (incl. rw_edit/rw_stat/rw_mkdir/rw_remove/rw_move/rw_forward), conflict-aware mirror sync, one-click backup/restore of every sidebar workspace, remote dsh deploy, port forwarding, optional side-bar remote file editing, audit log, keychain passwords.",
   "license": "MIT",
   "author": "flymysql <flyphp@outlook.com>",
   "readme": "README.md",