dsh-linked-workspace 0.8.2 → 0.8.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.8.3 — 2026-11-11
+
+Second review round: follow-ups to the 0.8.2 paging and preview work.
+
+- **Preview overlay (medium)**: the sanitizer now strips inline `style` attributes as well. A document containing `<div style="position:fixed;inset:0;z-index:99999;background:#fff">` used to cover the whole DSH window and could impersonate a login page (click-jacking / phishing without any script).
+- **Paging survives refresh (medium)**: the local tree refreshes every 4 seconds; it now re-requests only the number of entries already loaded instead of resetting to the first page, so “Load more” results no longer disappear after up to 4 s.
+- **Paging offset with hidden files (medium)**: “Load more” uses the raw server offset, so with hidden files toggled off entries are neither duplicated (200 duplicates before) nor skipped; the remaining count follows the same offset.
+- **Directory listing cache (medium)**: `fs.list` caches a listing for 5 seconds, so paging a huge directory reads it once instead of re-running a full `listDir` (20,000 entries: ~10.4 s per call). Writes, mkdir, rename, move, delete, copy and transfers invalidate the cache, and `limit` is clamped server-side to 1..5000.
+- **Partial copy cleanup (low)**: if a directory copy fails midway (for example on a >64 MB file), the partial target is removed and the error is `FS_INCOMPLETE`; `FS_TOO_LARGE` now only means an actual size cap.
+- **Connection reuse (low)**: `HostPool` keys in-flight connects by host *and* authority, so an address change cannot attach an old connection to a new request; a connection replaced while connecting is disposed instead of leaked, and `setHosts` clears stale pending entries.
+- **Right-sidebar requests (low)**: the linked-workspace tree source de-duplicates in-flight loads instead of sending the same request twice.
+- **Large pickers and PDF export (low)**: the local/remote directory pickers render at most 500 entries plus a “type the path directly” note; markdown-to-PDF export stops after 999 name suffixes with an explicit error instead of looping forever.
+- **Tests**: fixed two self-inconsistent assertions in `test/host-api.mjs` (a folder left behind made a later create return 409, and an already-existing folder was expected to answer 400); the suite now passes all 28 steps.
+
 ## 0.8.2 — 2026-11-11
 
 Three-day review round: security, data-integrity and large-directory fixes.

package/README.en.md

@@ -119,6 +119,20 @@ Old “Remote directories” tabs are restored after refresh through hidden lega
 
 See [CHANGELOG.md](CHANGELOG.md) for the full version history.
 
+### 0.8.3
+
+Follow-up fixes to the 0.8.2 paging and preview work (second review round):
+
+- Document previews now also drop inline `style` attributes, so a `position:fixed` overlay can no longer cover the whole app and impersonate a login page (click-jacking/phishing surface).
+- Tree refreshes (the local tree every 4 s) re-request only the entries already loaded, so “Load more” results are no longer reset to the first page.
+- With hidden files toggled, “Load more” uses the true server offset: entries are neither duplicated nor skipped, and the “N left” label is computed from that offset.
+- `fs.list` gained a 5-second listing cache: paging reads the directory once, and any write, mkdir, rename, move, delete, copy or transfer invalidates it.
+- A directory copy that fails midway removes the partial copy and reports `FS_INCOMPLETE`; `FS_TOO_LARGE` is now reserved for real size limits.
+- Concurrent first connects are keyed by host *and* address, so an address change cannot hand the old connection to the new request, and replaced connections are released.
+- The right-sidebar tree source de-duplicates in-flight loads instead of issuing the same request twice.
+- Directory pickers render at most 500 entries and suggest typing the path; PDF export stops after 999 name suffixes with an explicit error instead of looping forever.
+- Tests: two self-inconsistent assertions in `test/host-api.mjs` were fixed (a leftover folder made a later create return 409, and an existing name was expected to return 400); all 28 steps now pass.
+
 ### 0.8.2
 
 Security, data-integrity and large-directory fixes from the three-day review round:

package/README.md

@@ -114,6 +114,20 @@ dsh plugin --profile "$DSH_PROFILE" add "file:$PWD/dsh-linked-workspace"
 
 已打开的旧右侧栏「远程目录」标签页会在刷新后自动恢复（插件保留了两个隐藏的旧 tab 类型别名），标签标题也会自动改成「联动工作区目录」，新开的标签使用新的 `dsh-linked-workspace` 类型。
 
+### 0.8.3 变化
+
+针对 0.8.2 分页与预览的后续修复（第二轮评审）：
+
+- 文档预览同时删除内联 `style`，`position:fixed` 全屏覆盖层不再能把整页伪装成登录页（点击劫持/钓鱼面）。
+- 目录树刷新（本地树每 4 秒）只重取已加载的条目数，不再把「加载更多」的结果打回第一页。
+- 含隐藏文件时「加载更多」用服务端真实偏移，条目不再重复或遗漏；「剩余 N 项」按真实偏移计算。
+- `fs.list` 增加 5 秒列表缓存：翻页只读一次目录；写、建、改名、移动、删除、复制、传输后立即失效。
+- 目录复制中途失败会清理已复制的半成品并返回 `FS_INCOMPLETE`（原 `FS_TOO_LARGE` 只用于真实超限）。
+- 并发首次连接按「主机 + 地址」复用，主地址变化时不再把旧连接交给新地址请求，被替换的连接会释放。
+- 右侧栏树的数据源增加请求去重，重复加载不再重复发请求。
+- 目录选择器最多渲染 500 项并提示可直接输入路径；导出 PDF 的同名后缀最多尝试 999 次，超限报错而不是无限循环。
+- 测试：修复 `test/host-api.mjs` 自身两处断言缺陷（重复创建文件夹残留、把已存在当 400），全套 28 步通过。
+
 ### 0.8.2 变化
 
 安全、数据完整性与大目录体验修复（三日评审轮）：

package/docs/API.md

@@ -58,7 +58,7 @@ relative to the scope root, or absolute inside it.
 | `workspaces.remove` | `{ id }` | `{}` |
 | `workspaces.rename` | `{ id, name }` | `{ workspace }` |
 | `workspaces.test` | `{ id }` | `{ ok, latencyMs?, resolvedPath?, error? }` |
-| `fs.list` | `{ workspaceId?/linkedId?, path, limit?, offset? }` | `{ path, entries: RemoteEntry[], total, offset, limit, hasMore }` (default 500, max 5000) |
+| `fs.list` | `{ workspaceId?/linkedId?, path, limit?, offset? }` | `{ path, entries: RemoteEntry[], total, offset, limit, hasMore }` (default 500, max 5000). Listings are cached for 5 s for `offset > 0`; writes, mkdir, rename, move, delete, copy and transfers invalidate the cache. |
 | `fs.read` | `{ workspaceId?/linkedId?, path, maxBytes? }` | `FileRead` |
 | `media.read` | `{ workspaceId?/linkedId?, path }` | `{ path, size, mtime, mime, base64 }` (PNG/JPG/GIF/WebP/BMP/ICO/AVIF/SVG, max 24 MB) |
 | `fs.write` | `{ workspaceId?/linkedId?, path, content, expectedMtime?, createOnly? }` | `{ path, size, mtime }` (`createOnly: true`: existing target → 409) |

package/docs/VERIFY.md

@@ -145,3 +145,14 @@ Host code (lib/) reloads live with `plugin_manager set_plugin include:linked-wor
 6. **复制上限**：在远端复制一个 >64 MB 的文本/二进制文件：应提示「超过 64 MB，无法复制」，目标目录不得出现被截断的副本。
 7. **非空目录删除（工具）**：让 agent 用 `linked_workspace` 的 `delete` 删除一个含文件的远端目录：应递归删除成功，不再报 SFTP `Failure`。
 8. **Excel 截断提示**：打开一个 >200 行或 >40 列的 xlsx：表格上方应出现「仅显示前 200 行 × 40 列」；工作表超过 20 个时出现「仅显示前 20 个工作表」。
+
+## 分页续修与预览覆盖（0.8.3）
+
+1. **预览覆盖层**：放一个 Markdown 文件，内容为 `<div style="position:fixed;inset:0;z-index:99999;background:#fff;padding:24px">FAKE-LOGIN-PAGE</div>` 加一行普通文字；预览后不应出现全屏白底覆盖层，`div` 上不应残留 `style` 属性，页面其余部分照常可点。
+2. **加载更多不被刷新清空**：在本地树展开一个 >500 项的目录，点「加载更多」后**静置 10 秒**（跨过两次 4 秒刷新）：行数与剩余计数应保持不变，不回退到 500 行。
+3. **隐藏文件下的分页**：目录中同时放 300 个 `.hidden*.txt` 与 600 个 `visible*.txt`；先关闭「显示隐藏的文件」再展开该目录，点「加载更多」：可见条目不应重复、不应遗漏，最终数量为 600，剩余计数归零。
+4. **目录选择器上限**：进入一个含 600+ 子目录的父目录：列表面板最多显示 500 项，并提示「目录项过多，仅显示前 500 项；可直接在输入框中输入路径」；在输入框直接键入子路径仍可选择。
+5. **翻页性能**：对 20 000 项的远端目录连续点两次「加载更多」：第二次起应明显快于首次（5 秒内命中列表缓存），且界面不卡顿。
+6. **复制失败清理（开发核验）**：复制一个内含 >64 MB 文件的目录：应报错且目标目录不留半成品（可用 `git status` 之外的目录列表确认）。
+7. **导出 PDF 上限（开发核验）**：同目录放 999 个同名 `<name>.pdf` 后再次导出同名的 Markdown：应提示「同名 PDF 过多，请先清理目录中的旧导出」，不进入无限循环。
+8. **host-api 套件**：在有 SSH 主机与 DSH 运行时 Node 的机器上跑 `node test/host-api.mjs`（本机系统 Node 24.13 删除中日韩字符目录会崩溃，用 DSH 自带 Electron Node 执行）：应为 28 步全部通过。

package/lib/client.js

@@ -1937,10 +1937,20 @@ function urlAttributeViolation(name, value, tagName) {
   return scheme + ': URL';
 }
 
+// Complete attribute policy for the document preview. Inline styles are dropped
+// as well: `position:fixed; inset:0; z-index:99999` can cover the whole Harness
+// window, which turns a preview into a clickjacking / phishing surface without
+// a single line of script.
+function attributeViolation(name, value, tagName) {
+  if (String(name || '').toLowerCase() === 'style') return 'inline style';
+  return urlAttributeViolation(name, value, tagName);
+}
+
     var TREE_TAB_TYPE = 'dsh-linked-workspace';
     var REMOTE_TAB_TYPE = 'dsh-linked-workspace:remote';
     // One tree page; a folder with 20k entries must not render 20k rows.
     var TREE_PAGE_SIZE = 500;
+    var TREE_PAGE_MAX = 5000;
     var linkedLocalKeys = new Set();
     var linkedWorkspaceKeys = new Set();
     var hasRemoteDirectories = false;
@@ -2156,6 +2166,7 @@ function urlAttributeViolation(name, value, tagName) {
       noEntries: '空目录',
       loadMore: '加载更多（剩余 {{count}} 项）',
       loadMoreShort: '加载更多',
+      pickerTruncated: '目录项过多，仅显示前 {{count}} 项；可直接在输入框中输入路径',
       sheetTruncated: '仅显示前 {{rows}} 行 × {{cols}} 列',
       sheetMore: '工作表较多，仅显示前 20 个',
       noCredential: '缺少凭据',
@@ -2489,6 +2500,7 @@ function urlAttributeViolation(name, value, tagName) {
       noEntries: 'Empty directory',
       loadMore: 'Load more ({{count}} left)',
       loadMoreShort: 'Load more',
+      pickerTruncated: 'Too many entries; only the first {{count}} are shown. Type a path directly.',
       sheetTruncated: 'Showing the first {{rows}} rows × {{cols}} columns',
       sheetMore: 'Showing the first 20 worksheets only',
       noCredential: 'No credentials',
@@ -2897,7 +2909,7 @@ function urlAttributeViolation(name, value, tagName) {
         parsed.querySelectorAll('script,style,iframe,object,embed,link,meta,base,form').forEach(function (node) { node.remove(); });
         parsed.querySelectorAll('*').forEach(function (element) {
           Array.from(element.attributes).forEach(function (attribute) {
-            if (urlAttributeViolation(attribute.name, attribute.value, element.tagName)) {
+            if (attributeViolation(attribute.name, attribute.value, element.tagName)) {
               element.removeAttribute(attribute.name);
             }
           });
@@ -3764,6 +3776,10 @@ function urlAttributeViolation(name, value, tagName) {
 
       var listing = local.listing;
       var entries = listing ? listing.entries : [];
+      // A folder with thousands of sub-folders must not build thousands of DOM
+      // rows; the input box below still accepts any path.
+      var PICKER_LIMIT = 500;
+      var shownEntries = entries.slice(0, PICKER_LIMIT);
       var crumbs = useMemo(function () {
         if (!listing || !listing.path) return [];
         var path = listing.path;
@@ -3816,12 +3832,15 @@ function urlAttributeViolation(name, value, tagName) {
             ? h('div', { className: 'rw-row-msg' }, IconAlert(12), local.error)
             : entries.length === 0
               ? h('div', { className: 'rw-row-msg' }, t('emptyFolder'))
-              : entries.map(function (entry) {
+              : shownEntries.map(function (entry) {
                 return h('button', {
                   key: entry.path, type: 'button', className: 'rw-browser-row', role: 'listitem',
                   onClick: function () { navigate(entry.path); },
                 }, h('span', { className: 'rw-dir-icon' }, IconFolder(13, false)), h('span', null, entry.name));
-              })),
+              }),
+          entries.length > PICKER_LIMIT
+            ? h('div', { className: 'rw-row-msg' }, t('pickerTruncated', { count: PICKER_LIMIT }))
+            : null),
         h('div', { className: 'rw-browser-actions', style: { padding: '8px', gap: 8 } },
           h('div', { className: 'rw-inline', style: { minWidth: 0, flex: '1 1 auto' } },
             h('input', {
@@ -3893,6 +3912,9 @@ function urlAttributeViolation(name, value, tagName) {
 
       var listing = remote.listing;
       var dirs = listing ? (listing.entries || []).filter(function (entry) { return entry.type === 'dir'; }) : [];
+      var PICKER_LIMIT = 500;
+      var shownDirs = dirs.slice(0, PICKER_LIMIT);
+      var pickerTruncated = dirs.length > PICKER_LIMIT || Boolean(listing && listing.hasMore);
       var crumbs = useMemo(function () {
         if (!listing || !listing.path) return [];
         var pieces = listing.path.split('/').filter(function (piece) { return piece !== ''; });
@@ -3924,12 +3946,15 @@ function urlAttributeViolation(name, value, tagName) {
             ? h('div', { className: 'rw-row-msg' }, IconAlert(12), remote.error)
             : dirs.length === 0
               ? h('div', { className: 'rw-row-msg' }, t('noEntries'))
-              : dirs.map(function (entry) {
+              : shownDirs.map(function (entry) {
                 return h('button', {
                   key: entry.path, type: 'button', className: 'rw-browser-row', role: 'listitem',
                   onClick: function () { navigate(entry.path); },
                 }, h('span', { className: 'rw-dir-icon' }, IconFolder(13, false)), h('span', null, entry.name));
-              })),
+              }),
+          pickerTruncated
+            ? h('div', { className: 'rw-row-msg' }, t('pickerTruncated', { count: PICKER_LIMIT }))
+            : null),
         h('div', { className: 'rw-browser-actions', style: { padding: '8px' } },
           h('span', { className: 'rw-hint rw-input-mono', title: remote.input || (listing && listing.path) || '' },
             (listing && listing.path) || (remote.input !== '' ? remote.input : t('home'))),
@@ -4628,8 +4653,8 @@ function urlAttributeViolation(name, value, tagName) {
         });
       }
 
-      function listRequest(path, offset) {
-        var params = { path: path, limit: TREE_PAGE_SIZE, offset: offset };
+      function listRequest(path, offset, limit) {
+        var params = { path: path, limit: limit || TREE_PAGE_SIZE, offset: offset };
         return props.kind === 'local'
           ? apiCall('local.list', params)
           : apiCall('fs.list', Object.assign(params, scopeParams(props.scope)));
@@ -4644,13 +4669,17 @@ function urlAttributeViolation(name, value, tagName) {
       function load(path, silent) {
         if (pending.current.has(path)) return;
         pending.current.add(path);
+        var previousRecord = cache.entries.get(path) || {};
+        // A silent refresh keeps as many rows as the user already loaded:
+        // re-reading only the first page would drop everything past it.
+        var keep = silent ? Math.min(Math.max(Number(previousRecord.raw) || 0, TREE_PAGE_SIZE), TREE_PAGE_MAX) : TREE_PAGE_SIZE;
         setCache(function (previous) {
           var entries = new Map(previous.entries);
           var existing = entries.get(path) || {};
-          entries.set(path, { loading: !silent, error: null, entries: existing.entries || [], loaded: existing.loaded });
+          entries.set(path, { loading: !silent, error: null, entries: existing.entries || [], loaded: existing.loaded, raw: existing.raw, total: existing.total, hasMore: existing.hasMore });
           return { entries: entries };
         });
-        listRequest(path, 0).then(function (result) {
+        listRequest(path, 0, keep).then(function (result) {
           pending.current.delete(path);
           setCache(function (previous) {
             var next = new Map(previous.entries);
@@ -4659,6 +4688,7 @@ function urlAttributeViolation(name, value, tagName) {
               error: null,
               loaded: true,
               entries: applyEntries(result.entries || []),
+              raw: (result.entries || []).length,
               total: Number(result.total) || (result.entries || []).length,
               hasMore: Boolean(result.hasMore),
             });
@@ -4682,13 +4712,18 @@ function urlAttributeViolation(name, value, tagName) {
       function loadMore(path) {
         var record = cache.entries.get(path);
         if (!record || record.loadingMore || !record.hasMore) return;
+        // Offset is the number of RAW entries already fetched, not the number of
+        // visible rows: hidden entries are filtered out of the list but still
+        // occupy positions in the server-side listing.
+        var offset = Number(record.raw);
+        if (!Number.isFinite(offset)) offset = (record.entries || []).length;
         setCache(function (previous) {
           var next = new Map(previous.entries);
           var current = next.get(path);
           if (current) next.set(path, Object.assign({}, current, { loadingMore: true }));
           return { entries: next };
         });
-        listRequest(path, (record.entries || []).length).then(function (result) {
+        listRequest(path, offset).then(function (result) {
           setCache(function (previous) {
             var next = new Map(previous.entries);
             var current = next.get(path) || { entries: [] };
@@ -4696,6 +4731,7 @@ function urlAttributeViolation(name, value, tagName) {
               loadingMore: false,
               loaded: true,
               entries: current.entries.concat(applyEntries(result.entries || [])),
+              raw: offset + (result.entries || []).length,
               total: Number(result.total) || current.total,
               hasMore: Boolean(result.hasMore),
             }));
@@ -6575,7 +6611,7 @@ function urlAttributeViolation(name, value, tagName) {
             }, entry.loadingMore ? Spinner(12) : null,
             entry.moreError
               ? messageOf(entry.moreError, t, locale)
-              : t('loadMore', { count: Math.max((entry.total || 0) - entry.entries.length, 0) })));
+              : t('loadMore', { count: Math.max((entry.total || 0) - (Number.isFinite(entry.raw) ? entry.raw : entry.entries.length), 0) })));
           }
         }
       }
@@ -6639,15 +6675,18 @@ function urlAttributeViolation(name, value, tagName) {
       }
 
       function load(path) {
+        // Ref-based guard: a state setter callback is not a lock, so checking
+        // record.loading inside setCache would still fire duplicate requests.
+        if (pending.current.has(path)) return;
+        pending.current.add(path);
         setCache(function (previous) {
-          var record = previous.entries.get(path);
-          if (record && record.loading) return previous;
           var entries = new Map(previous.entries);
           var existing = entries.get(path) || {};
           entries.set(path, { loading: true, error: null, entries: existing.entries || [], loaded: existing.loaded });
           return { entries: entries };
         });
         apiCall('fs.list', listRequest(path, 0)).then(function (result) {
+          pending.current.delete(path);
           setCache(function (previous) {
             var entries = new Map(previous.entries);
             entries.set(path, {
@@ -6655,6 +6694,7 @@ function urlAttributeViolation(name, value, tagName) {
               error: null,
               loaded: true,
               entries: result.entries || [],
+              raw: (result.entries || []).length,
               total: Number(result.total) || (result.entries || []).length,
               hasMore: Boolean(result.hasMore),
             });
@@ -6666,6 +6706,7 @@ function urlAttributeViolation(name, value, tagName) {
             return next;
           });
         }).catch(function (error) {
+          pending.current.delete(path);
           setCache(function (previous) {
             var entries = new Map(previous.entries);
             entries.set(path, { loading: false, error: error, loaded: false, entries: [] });
@@ -6677,13 +6718,14 @@ function urlAttributeViolation(name, value, tagName) {
       function loadMore(path) {
         var record = cache.entries.get(path);
         if (!record || record.loadingMore || !record.hasMore) return;
+        var offset = Number.isFinite(Number(record.raw)) ? Number(record.raw) : (record.entries || []).length;
         setCache(function (previous) {
           var entries = new Map(previous.entries);
           var current = entries.get(path);
           if (current) entries.set(path, Object.assign({}, current, { loadingMore: true }));
           return { entries: entries };
         });
-        apiCall('fs.list', listRequest(path, (record.entries || []).length)).then(function (result) {
+        apiCall('fs.list', listRequest(path, offset)).then(function (result) {
           setCache(function (previous) {
             var entries = new Map(previous.entries);
             var current = entries.get(path) || { entries: [] };
@@ -6691,6 +6733,7 @@ function urlAttributeViolation(name, value, tagName) {
               loadingMore: false,
               loaded: true,
               entries: current.entries.concat(result.entries || []),
+              raw: offset + (result.entries || []).length,
               total: Number(result.total) || current.total,
               hasMore: Boolean(result.hasMore),
             }));

package/lib/index.js

@@ -87,6 +87,21 @@ const OP_TIMEOUT_MS = 60_000
 // cannot stall the Host or flood the renderer.
 const LIST_PAGE_SIZE = 500
 const LIST_PAGE_MAX = 5000
+// SFTP readdir has no paging, so a directory is always read in one call. A
+// freshly read listing is kept briefly so "load more" does not repeat the same
+// expensive scan; a first page (offset 0) is always re-read.
+const LISTING_CACHE_TTL_MS = 5000
+const LISTING_CACHE_LIMIT = 128
+const listingCache = new Map()
+const listingCacheKey = (scope, target) => `${scope.kind === 'linked' ? 'L' : 'W'}:${scope.id}:${target}`
+const rememberListing = (key, listing) => {
+  listingCache.delete(key)
+  listingCache.set(key, { at: Date.now(), listing })
+  while (listingCache.size > LISTING_CACHE_LIMIT) {
+    listingCache.delete(listingCache.keys().next().value)
+  }
+}
+const forgetListings = () => listingCache.clear()
 
 /** Clamp a requested page window to the listing limits. */
 const pageWindow = (params = {}, total = 0) => {
@@ -111,6 +126,7 @@ const ERROR_STATUS = {
   FS_IS_DIR: 400,
   FS_NOT_DIR: 400,
   FS_TOO_LARGE: 413,
+  FS_INCOMPLETE: 500,
   FS_EXISTS: 409,
   CONFLICT: 409,
   INTERNAL: 500,
@@ -703,7 +719,7 @@ class HostPool {
     this.knownHostsFile = knownHostsFile
     this.records = new Map() // hostId -> HostRecord
     this.connections = new Map() // hostId -> { authority, remote: RemoteHost }
-    this.connecting = new Map() // hostId -> in-flight connect promise
+    this.connecting = new Map() // hostId -> { authority, promise }
     this.statuses = new Map() // hostId -> { state, message?, latencyMs?, checkedAt }
   }
 
@@ -718,6 +734,12 @@ class HostPool {
         this.connections.delete(hostId)
       }
     }
+    // In-flight connects for removed or re-addressed hosts must not be reused:
+    // the attempt itself notices the lost map entry and disposes its socket.
+    for (const [hostId, pending] of [...this.connecting]) {
+      const host = this.records.get(hostId)
+      if (!host || `${host.host}:${host.port}` !== pending.authority) this.connecting.delete(hostId)
+    }
   }
 
   host(hostId) {
@@ -751,9 +773,11 @@ class HostPool {
     }
     // Two concurrent first requests for one host must share one connection;
     // otherwise the second RemoteHost overwrites the map entry and the first
-    // SSH socket leaks.
+    // SSH socket leaks. The pending attempt is bound to the address it dials,
+    // so a host edit during connect never hands the old socket to the new
+    // address.
     const pending = this.connecting.get(hostRecord.id)
-    if (pending) return pending
+    if (pending && pending.authority === authority) return pending.promise
     const remote = new RemoteHost({
       host: hostRecord,
       knownHostsFile: this.knownHostsFile,
@@ -765,16 +789,22 @@ class HostPool {
     const attempt = (async () => {
       try {
         await remote.connect()
+        // The host may have been removed while the socket was connecting: keep
+        // the map state authoritative so the unused connection is closed.
+        if (this.connections.get(hostRecord.id) !== entry) {
+          remote.dispose().catch(() => {})
+        }
         return remote
       } catch (error) {
         if (this.connections.get(hostRecord.id) === entry) this.connections.delete(hostRecord.id)
         remote.dispose().catch(() => {})
         throw error
       } finally {
-        this.connecting.delete(hostRecord.id)
+        const current = this.connecting.get(hostRecord.id)
+        if (current && current.promise === attempt) this.connecting.delete(hostRecord.id)
       }
     })()
-    this.connecting.set(hostRecord.id, attempt)
+    this.connecting.set(hostRecord.id, { authority, promise: attempt })
     return attempt
   }
 
@@ -1387,7 +1417,7 @@ export function apply(ctx) {
       }
       const read = await remote.readFile(source, { maxBytes: LINKED_OPEN_FILE_CAP })
       if (read.truncated || read.data.length !== stat.size) {
-        throw new ApiError('FS_TOO_LARGE', `${posix.basename(source)} 读取不完整，已取消复制`)
+        throw new ApiError('FS_INCOMPLETE', `${posix.basename(source)} 读取不完整，已取消复制`)
       }
       await remote.writeFileAtomic(target, read.data)
       return 1
@@ -1595,6 +1625,7 @@ export function apply(ctx) {
   // ── document bridge (Markdown/PDF/DOCX/XLSX/PPTX) ──────────────────────
 
   const DOC_MAX_BYTES = 80 * 1024 * 1024
+  const DOC_PDF_SUFFIX_MAX = 999
   const DOC_TOOL = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'doc_tool.py')
   const DOC_KIND_BY_EXT = new Map([
     ['.md', 'markdown'], ['.markdown', 'markdown'],
@@ -1867,7 +1898,18 @@ export function apply(ctx) {
       const target = params.path === undefined || params.path === ''
         ? scope.root
         : scopeTarget(scope, params.path)
-      const listing = await scope.remote.listDir(target)
+      const limit = Math.min(Math.max(Number(params.limit) || LIST_PAGE_SIZE, 1), LIST_PAGE_MAX)
+      const requestedOffset = Math.max(Number(params.offset) || 0, 0)
+      const key = listingCacheKey(scope, target)
+      let listing
+      if (requestedOffset > 0) {
+        const hit = listingCache.get(key)
+        if (hit && Date.now() - hit.at < LISTING_CACHE_TTL_MS) listing = hit.listing
+      }
+      if (!listing) {
+        listing = await scope.remote.listDir(target)
+        rememberListing(key, listing)
+      }
       const all = listing.entries.map((entry) => ({
         name: entry.name,
         path: entry.path,
@@ -1876,7 +1918,7 @@ export function apply(ctx) {
         mtime: entry.mtime,
         relative: scopeRelative(scope, entry.path),
       }))
-      const page = pageWindow(params, all.length)
+      const page = pageWindow({ limit, offset: requestedOffset }, all.length)
       return {
         path: target,
         entries: all.slice(page.offset, page.offset + page.limit),
@@ -1959,6 +2001,7 @@ export function apply(ctx) {
         mode: current ? current.mode : undefined,
       })
       await scopeMirror(scope, target, data)
+      forgetListings()
       return { path: target, size: info.size, mtime: info.mtime }
     },
 
@@ -2083,19 +2126,21 @@ export function apply(ctx) {
         const directory = posix.dirname(outputPath)
         let candidate = outputPath
         let index = 1
-        while (await target.scope.remote.stat(candidate).catch(() => null)) {
+        while (index <= DOC_PDF_SUFFIX_MAX && await target.scope.remote.stat(candidate).catch(() => null)) {
           candidate = posix.join(directory, posix.basename(base) + '-' + index + '.pdf')
           index += 1
         }
+        if (index > DOC_PDF_SUFFIX_MAX) throw new ApiError('FS_EXISTS', '同名 PDF 过多，请先清理目录中的旧导出')
         outputPath = candidate
       } else {
         const directory = dirname(outputPath)
         let candidate = outputPath
         let index = 1
-        while (existsSync(candidate)) {
+        while (index <= DOC_PDF_SUFFIX_MAX && existsSync(candidate)) {
           candidate = join(directory, basename(base) + '-' + index + '.pdf')
           index += 1
         }
+        if (index > DOC_PDF_SUFFIX_MAX) throw new ApiError('FS_EXISTS', '同名 PDF 过多，请先清理目录中的旧导出')
         outputPath = candidate
       }
       const temp = await makeDocTemp()
@@ -2141,6 +2186,7 @@ export function apply(ctx) {
         if (current) throw new ApiError('FS_EXISTS', '目标已存在，请使用其他名称')
       }
       await scope.remote.mkdirp(target)
+      forgetListings()
       return {}
     },
 
@@ -2151,6 +2197,7 @@ export function apply(ctx) {
       if (from === scope.root) throw new ApiError('BAD_REQUEST', '不能移动工作区根目录')
       await scope.remote.rename(from, to)
       await scopeMirrorRemove(scope, from)
+      forgetListings()
       return {}
     },
 
@@ -2172,6 +2219,7 @@ export function apply(ctx) {
       if (await scope.remote.stat(target).catch(() => null)) throw new ApiError('FS_EXISTS', '目标目录中已存在同名文件或文件夹')
       await scope.remote.rename(source, target)
       await scopeMirrorRemove(scope, source)
+      forgetListings()
       return { path: target }
     },
 
@@ -2181,6 +2229,7 @@ export function apply(ctx) {
       if (target === scope.root) throw new ApiError('BAD_REQUEST', '不能删除工作区根目录')
       await remoteDeleteRecursive(scope.remote, target)
       await scopeMirrorRemove(scope, target)
+      forgetListings()
       return {}
     },
 
@@ -2188,7 +2237,9 @@ export function apply(ctx) {
       const scope = await requireScope(params)
       if (scope.kind !== 'linked') throw new ApiError('BAD_REQUEST', '只有联动工作区支持文件传输')
       if (params.side === 'local') {
-        return await transferLocalToRemote(scope.record, scope.remote, params.path)
+        const result = await transferLocalToRemote(scope.record, scope.remote, params.path)
+        forgetListings()
+        return result
       }
       const target = scopeTarget(scope, params.path)
       return await transferToMirror(scope.record, scope.remote, target)
@@ -2219,7 +2270,16 @@ export function apply(ctx) {
         throw new ApiError('BAD_REQUEST', '不能把目录复制到自身内部')
       }
       const target = await remoteUniqueTarget(scope.remote, parent, posix.basename(source))
-      const files = await remoteCopyRecursive(scope.remote, source, target)
+      let files
+      try {
+        files = await remoteCopyRecursive(scope.remote, source, target)
+      } catch (error) {
+        // A half-copied tree is worse than a clean failure: remove what this
+        // call created (the target name was unique, so nothing else lives there).
+        await remoteDeleteRecursive(scope.remote, target).catch(() => {})
+        throw error
+      }
+      forgetListings()
       return { path: target, files }
     },
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-linked-workspace",
-  "version": "0.8.2",
+  "version": "0.8.3",
   "description": "Linked local ⇄ remote workspaces and SSH-backed remote directories for DeepSeek Harness: theme-aware split editor, file-type icons, and an agent tool that edits remote files directly.",
   "type": "module",
   "main": "lib/index.js",