dsh-remote 0.8.22 → 0.8.24

package/lib/client.js

@@ -139,8 +139,10 @@ window.__ModuleLoader__.load({
         'settings.updateFail': '检查更新失败',
         'settings.updateAvailable': '发现新版本 v{version}',
         'settings.updateLatest': '已是最新版本（v{version}）',
-        'settings.updateConfirm': '将更新 dsh-remote 到 v{version}，替换本机插件文件。更新后需重启 Harness 生效。继续？',
-        'settings.updateApplied': '✅ 已更新到 v{to}（{from} → {to}）。重启 Harness 生效。',
+        'settings.updateConfirm': '将更新 dsh-remote 到 v{version}，替换本机插件文件并在线热切换宿主半（不重启 Harness）。继续？',
+        'settings.updateApplied': '✅ 已更新到 v{to}（{from} → {to}），宿主半已在线热切换。',
+'settings.updateAppliedNoReload': '✅ 已更新到 v{to}（{from} → {to}）。重启 Harness 生效。',
+'settings.updatePendingReload': '⚠️ 磁盘已是 v{disk}，运行中的仍是 v{loaded}；点「立即更新」或重启 Harness 完成切换。',
         'settings.updateFailed': '更新失败',
         'settings.updateFailedMsg': '更新失败: {msg}',
         'settings.registryUnreachable': '无法连接 npm registry',
@@ -363,8 +365,10 @@ window.__ModuleLoader__.load({
         'settings.updateFail': 'Failed to check for updates',
         'settings.updateAvailable': 'New version found: v{version}',
         'settings.updateLatest': 'Already up to date (v{version})',
-        'settings.updateConfirm': 'Update dsh-remote to v{version}? This replaces the local plugin files and requires a Harness restart to take effect. Continue?',
-        'settings.updateApplied': '✅ Updated to v{to} ({from} → {to}). Restart Harness to apply.',
+        'settings.updateConfirm': 'Update dsh-remote to v{version}? This replaces the local plugin files and hot-swaps the host half in place (no Harness restart). Continue?',
+        'settings.updateApplied': '✅ Updated to v{to} ({from} → {to}); the host half hot-swapped in place.',
+'settings.updateAppliedNoReload': '✅ Updated to v{to} ({from} → {to}). Restart Harness to apply.',
+'settings.updatePendingReload': '⚠️ v{disk} is on disk but v{loaded} is still running; update again or restart Harness to switch.',
         'settings.updateFailed': 'Update failed',
         'settings.updateFailedMsg': 'Update failed: {msg}',
         'settings.registryUnreachable': 'Cannot reach the npm registry',
@@ -836,9 +840,13 @@ window.__ModuleLoader__.load({
         setUpdBusy(true); setUpdMsg('')
         api('POST', '/dsh-remote/update-apply', { version: upd.latest })
           .then((r) => {
-            if (r && r.ok) setUpdMsg(tr('settings.updateApplied', { to: r.to, from: (r.from || '') }))
+            if (r && r.ok) setUpdMsg(tr(r.reloadScheduled ? 'settings.updateApplied' : 'settings.updateAppliedNoReload', { to: r.to, from: (r.from || '') }))
             else setUpdMsg((r && r.error) || tr('settings.updateFailed'))
-            checkUpdate(true)
+            // The host half swaps itself ~300ms after answering, so the panel
+            // must not re-check immediately: it would still be talking to the
+            // outgoing fiber and report the pre-swap version, i.e. "update
+            // available" right after a successful update.
+            window.setTimeout(() => checkUpdate(true), 2000)
           })
           .catch((e) => setUpdMsg(tr('settings.updateFailedMsg', { msg: String((e && e.message) || e) })))
           .finally(() => setUpdBusy(false))
@@ -1127,6 +1135,10 @@ window.__ModuleLoader__.load({
               }, m === 'manual' ? tr('settings.modeManual') : m === 'auto' ? tr('settings.modeAuto') : tr('settings.modeOff')),
             ),
           ),
+          upd && upd.pendingReload
+            ? React.createElement('div', { style: { marginTop: 6, fontSize: 12, color: T.warn } },
+                tr('settings.updatePendingReload', { disk: upd.disk, loaded: upd.loaded }))
+            : null,
           updMsg ? React.createElement('div', { style: { marginTop: 6, fontSize: 12, color: updMsg.startsWith('✅') ? T.ok : 'inherit', opacity: 0.9 } }, updMsg) : null,
         ),
         React.createElement('div', { style: { display: 'flex', gap: 12, alignItems: 'center', flexWrap: 'wrap', fontSize: 11, opacity: 0.65, borderTop: '1px solid ' + T.border, paddingTop: 10, marginTop: 4 } },
@@ -1213,9 +1225,25 @@ window.__ModuleLoader__.load({
       const [mkdirPrompt, setMkdirPrompt] = React.useState(false)
       const suggestTimer = React.useRef(null)
       const suggestRef = React.useRef(null)
+      // Autocomplete performance (slow per-keystroke remote scans):
+      //  - postedCurrentRef/currentPromiseRef: POST /current once per machine
+      //    switch; concurrent callers share ONE in-flight promise and a failed
+      //    switch REJECTS (never run /ls — or cache its listing — on the wrong
+      //    machine)
+      //  - lsCacheRef/lsInflightRef: one /ls per (machine, dir), TTL-cached
+      //  - lsGenRef/fetchSeqRef: per-key fetch generation — a cache write from
+      //    a superseded fetch (fresh navigation, picker reopen) is dropped
+      //  - suggestSeqRef: drop stale suggestion responses (older keystrokes)
+      const postedCurrentRef = React.useRef('')
+      const currentPromiseRef = React.useRef(null)
+      const lsCacheRef = React.useRef(new Map())
+      const lsInflightRef = React.useRef(new Map())
+      const lsGenRef = React.useRef(new Map())
+      const fetchSeqRef = React.useRef(0)
+      const suggestSeqRef = React.useRef(0)
       React.useEffect(() => {
         if (!suggestOpen) return
-        const onDown = (ev) => { if (suggestRef.current && !suggestRef.current.contains(ev.target)) setSuggestOpen(false) }
+        const onDown = (ev) => { if (suggestRef.current && !suggestRef.current.contains(ev.target)) { suggestSeqRef.current++; setSuggestOpen(false) } }
         document.addEventListener('mousedown', onDown)
         return () => document.removeEventListener('mousedown', onDown)
       }, [suggestOpen])
@@ -1247,26 +1275,125 @@ window.__ModuleLoader__.load({
         return b.replace(/[\\/]+$/, '') + sep + n
       }
 
-      const loadLevels = (id, p, toIndex) => {
-        if (!id) return
-        setLoading(true); setErr('')
-        api('POST', '/dsh-remote/current', { id }).catch(() => {})
-        .then(() => api('GET', '/dsh-remote/ls?path=' + encodeURIComponent(p || '')))
-        .then((res) => {
-          setWin(res && res.platform === 'windows')
-          const real = res && res.path ? res.path : (p || '')
+      // Identity of the machine a listing was answered for (the /ls response
+      // echoes it), checked against the machine the fetch INTENDED. The picker
+      // memoizes "machine already active", but the settings page can switch
+      // machines too — validate every listing before trusting the memo. A
+      // machine may show up as its ~/.ssh/config alias OR its resolved host, so
+      // accept either identity; nothing to compare against → accept.
+      const echoMatches = (id, echo) => {
+        if (!echo || !echo.host) return true // older host half without an echo
+        const m = (machines || []).find((x) => x && x.id === id)
+        if (!m) return true
+        const cands = [{ host: String(m.host || ''), port: Number(m.port) || 22, username: String(m.username || '') }]
+        const r = m.sshConfigResolved
+        if (r && r.host) cands.push({ host: String(r.host), port: Number(r.port) || 22, username: String(r.username || m.username || '') })
+        return cands.some((c) => c.host === String(echo.host) && c.port === (Number(echo.port) || 22) && c.username === String(echo.username || ''))
+      }
+
+      // POST /current once per machine switch. The picker used to post it before
+      // EVERY /ls; the host re-applies the machine on that route, which used to
+      // close the live SSH connection — so each autocomplete keystroke paid a
+      // full reconnect. The memo is set only on SUCCESS and concurrent callers
+      // share ONE in-flight promise, so no request can overtake a pending switch
+      // and read the OLD machine's listing. A failed switch REJECTS: the
+      // caller's fetch chain aborts WITHOUT writing the cache.
+      const ensureCurrent = (id) => {
+        if (!id) return Promise.resolve()
+        if (postedCurrentRef.current === id) return Promise.resolve()
+        const inflight = currentPromiseRef.current
+        if (inflight) {
+          if (inflight.id === id) return inflight.promise
+          // Serialize switches: ours must land AFTER any pending one (the host
+          // applies whichever POST arrives last), never race it.
+          return inflight.promise.then(() => ensureCurrent(id), () => ensureCurrent(id))
+        }
+        const p = api('POST', '/dsh-remote/current', { id }).then(() => {
+          postedCurrentRef.current = id
+        })
+        const entry = { id, promise: p }
+        currentPromiseRef.current = entry
+        const clear = () => { if (currentPromiseRef.current === entry) currentPromiseRef.current = null }
+        p.then(clear, clear)
+        return p
+      }
+
+      const LS_TTL_MS = 30000
+      // Cached remote listing per (machine, dir): typing inside one parent
+      // directory used to re-fetch the identical list on every keystroke.
+      // `fresh` bypasses the cache (browse navigation / post-mkdir refresh) and
+      // SUPERSEDES older fetches for the key: a cache write from a superseded
+      // fetch is dropped (it still resolves its own callers), so a pre-mkdir
+      // listing can never overwrite the post-mkdir one. Concurrent identical
+      // requests share one in-flight fetch.
+      const fetchDirList = (id, dirParam, fresh) => {
+        const key = String(id) + '\u0000' + String(dirParam)
+        const hit = lsCacheRef.current.get(key)
+        if (!fresh && hit && Date.now() - hit.at < LS_TTL_MS) return Promise.resolve(hit.node)
+        const inflight = fresh ? null : lsInflightRef.current.get(key)
+        if (inflight) return inflight
+        const gen = ++fetchSeqRef.current
+        lsGenRef.current.set(key, gen)
+        const toNode = (res) => {
+          const real = res && res.path ? res.path : String(dirParam)
           // Server returns [{ type, name, size, mtime, path }] where `path` is
           // the FULL display-form path (C:\Users\dev on Windows) — the client
           // never joins paths itself, so drives and Windows paths just work.
           const list = Array.isArray(res && res.items)
             ? res.items.map((it) => ({ name: it.name, dir: it.type === 'dir', size: it.size, mtime: it.mtime, path: it.path || joinDisplay(real, it.name), drive: !!it.drive }))
             : parseLs(res && res.text)
-          const node = { path: real, dirs: sortItems(list.filter((it) => it.dir)), all: sortItems(list) }
+          return {
+            path: real,
+            platform: !!(res && res.platform === 'windows'),
+            dirs: sortItems(list.filter((it) => it.dir)),
+            all: sortItems(list),
+          }
+        }
+        const run = (retried) => ensureCurrent(id)
+        .then(() => api('GET', '/dsh-remote/ls?path=' + encodeURIComponent(dirParam)))
+        .then((res) => {
+          // External-switch defense: on an identity-echo mismatch the host is
+          // no longer on the machine this fetch intended — bust the memo, force
+          // one re-switch and retry ONCE. A mismatched listing is never cached.
+          if (!echoMatches(id, res && res.machine)) {
+            if (retried) return toNode(res)
+            postedCurrentRef.current = ''
+            return run(true)
+          }
+          const node = toNode(res)
+          if (lsGenRef.current.get(key) === gen) lsCacheRef.current.set(key, { at: Date.now(), node })
+          return node
+        })
+        const p = run(false)
+        .finally(() => { if (lsInflightRef.current.get(key) === p) lsInflightRef.current.delete(key) })
+        lsInflightRef.current.set(key, p)
+        return p
+      }
+
+      // Fresh session on every open: forget everything a previous open left
+      // behind. A stale in-flight response must not repopulate the cache
+      // (generation fence) and a stale suggestion response must not reopen the
+      // dropdown on the now-live tree.
+      const resetPickerFetchState = () => {
+        postedCurrentRef.current = ''
+        lsCacheRef.current.clear()
+        lsInflightRef.current.clear()
+        lsGenRef.current.clear()
+        suggestSeqRef.current++
+      }
+
+      const loadLevels = (id, p, toIndex) => {
+        if (!id) return
+        setLoading(true); setErr('')
+        fetchDirList(id, p || '', true)
+        .then((node) => {
+          setWin(node.platform)
+          const level = { path: node.path, dirs: node.dirs, all: node.all }
           setLevels((prev) => {
             const base = prev && prev.length ? prev.slice() : []
             let idx = typeof toIndex === 'number' && toIndex >= 0 ? toIndex : base.length
-            if (idx >= base.length) return base.concat([node])
-            base[idx] = node
+            if (idx >= base.length) return base.concat([level])
+            base[idx] = level
             return base.slice(0, idx + 1)
           })
         })
@@ -1279,6 +1406,12 @@ window.__ModuleLoader__.load({
         // path — reset the path bar (and the browse state) on every open.
         setPath(''); setLevels(null); setWin(false)
         setLocalPop(null); setNewDirName('')
+        // Fresh session: re-post /current on the first request and forget
+        // everything a previous open left behind (TTL bounds staleness within
+        // one open; reopening should see the live tree) — cached AND in-flight
+        // listings, plus any pending suggestion response.
+        resetPickerFetchState()
+        if (suggestTimer.current) { clearTimeout(suggestTimer.current); suggestTimer.current = null }
         api('GET', '/dsh-remote/machines').then((r) => {
           setMachines(r.machines || [])
           const cur = (r.machines || []).find((m) => m.id === r.currentId)
@@ -1373,11 +1506,38 @@ window.__ModuleLoader__.load({
         if (par) loadLevels(machineId, par, 1)
       }
 
+      // Drop any pending suggestion response and close the dropdown.
+      const killSuggestions = () => {
+        suggestSeqRef.current++
+        setSuggest([])
+        setSuggestOpen(false)
+      }
+
+      // One seq-guarded "fetch listing → derive suggestion paths" pipeline
+      // shared by loadSuggestions (typing: dirs matching a prefix) and
+      // continueSuggest (expanding a picked dir: all its entries) — the
+      // differing parts stay at the call sites as the `pick` parameter. Only
+      // the newest request owns the dropdown: a slow older /ls must never
+      // overwrite the suggestions for the text now in the input. The catch
+      // keeps the seq-guarded empty fallback (a failed machine switch rejects
+      // too, and must leave the dropdown closed and empty).
+      const suggestFrom = (id, dirParam, pick, fresh) => {
+        const seq = ++suggestSeqRef.current
+        return fetchDirList(id, dirParam, fresh).then((node) => {
+          if (seq !== suggestSeqRef.current) return
+          const matches = pick(node).slice(0, 40)
+          setSuggest(matches)
+          setSuggestOpen(!!matches.length)
+        }).catch(() => {
+          if (seq !== suggestSeqRef.current) return
+          setSuggest([]); setSuggestOpen(false)
+        })
+      }
+
       const loadSuggestions = (raw, mid) => {
         const id = mid || machineId
-        if (!id || !raw) { setSuggest([]); setSuggestOpen(false); return }
         const t = String(raw || '').trim()
-        if (!t) { setSuggest([]); setSuggestOpen(false); return }
+        if (!id || !t) { killSuggestions(); return }
         // Separator-aware split: `\` when the input looks like a Windows path.
         const backslash = t.includes('\\') || /^[a-zA-Z]:/.test(t)
         const sep = backslash ? '\\' : '/'
@@ -1386,18 +1546,9 @@ window.__ModuleLoader__.load({
         if (idx < 0) { parent = backslash ? t + '\\' : '/'; lastSeg = backslash ? '' : t }
         else if (idx === t.length - 1) { parent = t.slice(0, idx) || '/'; lastSeg = '' }
         else { parent = t.slice(0, idx) || '/'; lastSeg = t.slice(idx + 1) }
-        api('POST', '/dsh-remote/current', { id }).catch(() => {})
-        .then(() => api('GET', '/dsh-remote/ls?path=' + encodeURIComponent(parent || '/')))
-        .then((res) => {
-          const list = Array.isArray(res && res.items)
-            ? res.items.map((it) => ({ name: it.name, dir: it.type === 'dir', path: it.path || joinDisplay(parent, it.name) }))
-            : []
-          const matches = list
-            .filter((it) => it.dir && (!lastSeg || it.name.toLowerCase().startsWith(String(lastSeg).toLowerCase())))
-            .slice(0, 40).map((it) => it.path)
-          setSuggest(matches)
-          setSuggestOpen(!!matches.length)
-        }).catch(() => { setSuggest([]); setSuggestOpen(false) })
+        suggestFrom(id, parent || '/', (node) => node.dirs
+          .filter((it) => !lastSeg || it.name.toLowerCase().startsWith(String(lastSeg).toLowerCase()))
+          .map((it) => it.path))
       }
 
       const onPathChange = (raw) => {
@@ -1407,18 +1558,13 @@ window.__ModuleLoader__.load({
       }
 
       const continueSuggest = (dir) => {
-        if (!machineId || !dir) { setSuggest([]); setSuggestOpen(false); return }
+        if (!machineId || !dir) { killSuggestions(); return }
         setSuggestOpen(false)
-        api('POST', '/dsh-remote/current', { id: machineId }).catch(() => {})
-        .then(() => api('GET', '/dsh-remote/ls?path=' + encodeURIComponent(String(dir).replace(/[\\/]+$/, '') || '/')))
-        .then((res) => {
-          const list = Array.isArray(res && res.items)
-            ? res.items.map((it) => ({ name: it.name, dir: it.type === 'dir', path: it.path || joinDisplay(dir, it.name) }))
-            : []
-          const kids = list.slice(0, 40).map((it) => it.path)
-          setSuggest(kids)
-          setSuggestOpen(!!kids.length)
-        }).catch(() => { setSuggest([]); setSuggestOpen(false) })
+        const target = String(dir).replace(/[\\/]+$/, '') || '/'
+        // Expanding a just-selected directory is a NAVIGATION step: the caching
+        // spec only sanctions "typing inside one parent directory, local
+        // filtering", so fetch fresh instead of serving up to 30s-stale entries.
+        suggestFrom(machineId, target, (node) => node.all.map((it) => it.path), true)
       }
 
       const selectSuggestion = (s) => {
@@ -1434,21 +1580,34 @@ window.__ModuleLoader__.load({
       const commitPath = (p) => {
         const target = String(p || '').trim()
         if (!target || !machineId || busy) return
-        setPopOpen(false); setSuggestOpen(false)
-        api('POST', '/dsh-remote/mirror', { path: target }).then((res) => (res && res.localMirror ? onPicked(res.localMirror) : setErr((res && res.error) || ''))).catch((e) => setErr(String((e && e.message) || e)))
+        setPopOpen(false); killSuggestions()
+        // State the machine this pick was made on. The picker acts on the shared
+        // active pool, and another actor (the settings page, or rw_connect in
+        // another session) can switch it while the picker is open — the mirror
+        // would then be created with THAT machine's identity while the user was
+        // looking at this one's tree. The host re-asserts the named machine
+        // instead of trusting whichever happens to be active.
+        ensureCurrent(machineId)
+          .then(() => api('POST', '/dsh-remote/mirror', { path: target, machineId }))
+          .then((res) => (res && res.localMirror ? onPicked(res.localMirror) : setErr((res && res.error) || '')))
+          .catch((e) => setErr(String((e && e.message) || e)))
       }
 
       const acceptBrowserPick = (p) => {
         setPath(String(p || ''))
-        setSuggestOpen(false)
+        killSuggestions()
         setPopOpen(false)
       }
 
       const pickHome = () => {
-        api('POST', '/dsh-remote/home').then((r) => {
-          if (r && r.home) { setPath(r.home); setErr(''); loadSuggestions(r.home) }
-          else setErr((r && (r.hint || r.error)) || tr('picker.noHome'))
-        }).catch((e) => setErr(String((e && e.message) || e)))
+        // Same identity contract as commitPath: /home is answered by the active
+        // pool, so name the machine this picker is showing.
+        ensureCurrent(machineId)
+          .then(() => api('POST', '/dsh-remote/home', { machineId }))
+          .then((r) => {
+            if (r && r.home) { setPath(r.home); setErr(''); loadSuggestions(r.home) }
+            else setErr((r && (r.hint || r.error)) || tr('picker.noHome'))
+          }).catch((e) => setErr(String((e && e.message) || e)))
       }
 
       const mkdirHere = () => {
@@ -1584,7 +1743,7 @@ window.__ModuleLoader__.load({
             if (mkdirPrompt) return
             if (e.key === 'Escape') {
               if (popOpen) { e.preventDefault(); setPopOpen(false); return }
-              if (suggestOpen) { e.preventDefault(); setSuggestOpen(false); return }
+              if (suggestOpen) { e.preventDefault(); suggestSeqRef.current++; setSuggestOpen(false); return }
               if (!busy) { e.preventDefault(); onCancel() }
               return
             }

package/lib/index.js

@@ -21,7 +21,7 @@
 import z from '@deepseek-ai/schemastery'
 import { defineTool } from '@deepseek-ai/dsh-tools'
 import { execFile } from 'node:child_process'
-import { readFileSync, mkdirSync, writeFileSync, existsSync, readdirSync, statSync, renameSync, copyFileSync, appendFileSync, watch } from 'node:fs'
+import { readFileSync, mkdirSync, writeFileSync, existsSync, readdirSync, statSync, renameSync, copyFileSync, appendFileSync, watch, rmSync } from 'node:fs'
 import { homedir } from 'node:os'
 import path from 'node:path'
 import iconv from 'iconv-lite'
@@ -41,7 +41,7 @@ import { searchRemote } from './search.js'
 import { resolveMirror, poolKey, lookupSessionCwd, encodeSegmentSafe, readSessionHeaderCwd, requestSessionHint } from './binding.js'
 import { TaskManager } from './tasks.js'
 import { ForwardManager } from './forwards.js'
-import { selfDir, readVersion, gtVersion, fetchLatestVersion, applyUpdate, persistUpdateMode, readUpdateMode } from './update.js'
+import { selfDir, diskVersion, LOADED_VERSION, gtVersion, fetchLatestVersion, applyUpdate, persistUpdateMode, readUpdateMode, reloadSelf, scheduleSelfReload } from './update.js'
 import { loadMachines as _loadMachines, saveMachines as _saveMachines, sanitizeMachine as _sanitizeMachine, applyMachine as _applyMachine, machineId as _machineId } from './registry.js'
 import { registerHttpTransports } from './http-transport.js'
 import { SshPool } from './pool.js'
@@ -130,6 +130,10 @@ export const Config = z.object({
   updateMode: z.string().default('manual'),
   /** How often (ms) auto mode checks the npm registry for a newer release. */
   updateCheckIntervalMs: z.number().step(1).min(60000).default(6 * 3600 * 1000),
+  /** Whether a landed update also hot-swaps the running host half (default
+   *  true). With `false` an update only takes effect on the next process start
+   *  and `/dsh-remote/update-check` reports `pendingReload: true` meanwhile. */
+  updateAutoReload: z.boolean().default(true),
 })
 
 // ── shell / path helpers (pure implementations in lib/paths.js) ───────────
@@ -258,6 +262,15 @@ export async function apply(ctx, config) {
 
   migrateLegacyData()
 
+  // The update marker means "a newer version landed on disk but is not the code
+  // running yet". Reaching apply() with a marker naming the version we just
+  // loaded means the swap already happened (or this is a plain boot into the
+  // updated files) → clear it, so the UI's "restart to finish" hint stays true.
+  try {
+    const marker = path.join(selfDir(), '.dsh-remote-updated')
+    if (existsSync(marker) && readFileSync(marker, 'utf8').trim() === LOADED_VERSION) rmSync(marker, { force: true })
+  } catch {}
+
   // ── machine registry (multi-host) ─────────────────────────────────────────
   const store = loadMachines()
   const machines = store.list
@@ -360,18 +373,47 @@ export async function apply(ctx, config) {
     return machinePassword(m)
   }
 
+  /** The identity fields pool.setTarget diffs. Used to snapshot the diff
+   *  baseline BEFORE applyMachine mutates the shared config in place. */
+  const targetFields = (c) => ({
+    host: c.host, port: c.port, username: c.username,
+    password: c.password, privateKeyPath: c.privateKeyPath,
+    passphrase: c.passphrase, workspace: c.workspace,
+    useAgent: c.useAgent, keyboardInteractive: c.keyboardInteractive,
+    proxy: c.proxy, hostKeyMode: c.hostKeyMode,
+  })
+
+  /** Fingerprint of the machine record last applied to the shared pool config.
+   * Re-applying an identical record is a no-op: the picker posts /current before
+   * every /ls and used to rewrite the registry + re-read credentials + re-point
+   * the pool on every autocomplete keystroke. A record change (settings edit)
+   * changes the fingerprint, so the next /current re-applies it. The value is
+   * maintained INSIDE applyActiveMachine / clearActiveMachine (not in
+   * setCurrent) so every apply path — boot restore, rw_connect save:true,
+   * POST /current — keeps the "fingerprint == applied" invariant without extra
+   * bookkeeping. */
+  let lastAppliedMachine = ''
+
+  /** Fingerprint of the registry record the shared config is bound to ('' when
+   *  the binding is ephemeral or no machine is current). */
+  const appliedFingerprint = () => {
+    if (ephemeral || !store.currentId) return ''
+    const i = machineIndex(store.currentId)
+    return i >= 0 ? JSON.stringify(machines[i]) : ''
+  }
+
   const applyActiveMachine = async () => {
     const m = activeMachine()
     if (!m || !m.host) return
     const pw = await machinePassword(m)
+    // Snapshot the diff baseline BEFORE applyMachine mutates the shared config
+    // IN PLACE: pool.config IS this config object, so setTarget would otherwise
+    // compare the new values against themselves, find them equal and keep the
+    // OLD connection alive across a machine switch (issue #25 hazard).
+    const previous = targetFields(config)
     applyMachine(config, { ...m, password: pw || m.password || '' })
-    pool.setTarget({
-      host: config.host, port: config.port, username: config.username,
-      password: config.password, privateKeyPath: config.privateKeyPath,
-      passphrase: config.passphrase, workspace: config.workspace,
-      useAgent: config.useAgent, keyboardInteractive: config.keyboardInteractive,
-      proxy: config.proxy, hostKeyMode: config.hostKeyMode,
-    })
+    pool.setTarget(targetFields(config), previous)
+    lastAppliedMachine = appliedFingerprint()
   }
 
   // ── per-machine SSH pools (session-bound) ─────────────────────────────────
@@ -501,6 +543,34 @@ export async function apply(ctx, config) {
     return created
   }
 
+  /**
+   * Re-assert the ACTIVE machine that a machine-scoped request names.
+   *
+   * The workspace picker (and the settings page's workspace flow) acts on the
+   * shared active pool, but it remembers its own `machineId` locally. Nothing
+   * on `/mirror` / `/home` / `/fs` used to carry that identity, so a switch
+   * performed by ANOTHER actor between the picker's last fetch and its commit —
+   * the settings page's "set as current", or an `rw_connect` in another agent
+   * session — silently redirected the commit onto that other machine. Before
+   * this PR the picker re-posted /current on every keystroke, which masked the
+   * window; the per-keystroke reconnect fix removes that accident. Let the
+   * request state its intent so the host can honour it atomically instead.
+   *
+   * An absent / empty `machineId` keeps the old behaviour (the caller is
+   * machine-scoped through the active pool by design). An UNKNOWN id is
+   * refused rather than ignored: quietly mirroring onto whichever machine
+   * happens to be active is exactly the hazard this closes.
+   *
+   * @returns {Promise<boolean>} false when the request was already answered.
+   */
+  const applyRequestedMachine = async (body, res) => {
+    const id = String((body && body.machineId) || '').trim()
+    if (!id) return true
+    if (await setCurrent(id)) return true
+    sendJson(res, 404, { ok: false, error: `machine not found: ${id}` })
+    return false
+  }
+
   const setCurrent = async (id) => {
     if (!id) {
       // Explicit "active remote = none": saved machines stay in the registry
@@ -513,6 +583,11 @@ export async function apply(ctx, config) {
     }
     const i = machineIndex(id)
     if (i < 0) return false
+    // Idempotent: same machine, no ephemeral override, already applied → keep
+    // the registry file, the credentials cache and the live pool untouched.
+    // (The fingerprint is maintained by applyActiveMachine itself.)
+    const fingerprint = JSON.stringify(machines[i])
+    if (store.currentId === id && !ephemeral && config.host && lastAppliedMachine === fingerprint) return true
     store.currentId = id
     ephemeral = null
     saveMachines(machines, id)
@@ -525,7 +600,13 @@ export async function apply(ctx, config) {
    * tool fallback, but no machine workspace leaks into this session. */
   const clearActiveMachine = async () => {
     ephemeral = null
+    // Nothing is applied anymore — reset the applied-machine fingerprint too.
+    lastAppliedMachine = ''
     if (!config.host) return
+    // Snapshot the diff baseline BEFORE zeroing: pool.config IS this config
+    // object, so setTarget would otherwise see an already-zeroed config and
+    // keep the old connection alive ("active remote = none" must disconnect).
+    const previous = targetFields(config)
     // Clear host + workspace directly (applyMachine keeps the old workspace
     // when the incoming value is empty — it must not be used for a full reset).
     config.host = ''
@@ -533,7 +614,7 @@ export async function apply(ctx, config) {
     config.username = ''
     config.password = ''
     config.workspace = ''
-    pool.setTarget({ host: '', port: 22, username: '', workspace: '' })
+    pool.setTarget({ host: '', port: 22, username: '', workspace: '' }, previous)
     // Also stop any auto-push watcher bound to the old machine workspace.
     // (autoPushWatchers is declared later; read it lazily to avoid TDZ.)
     if (typeof autoPushWatchers !== 'undefined' && autoPushWatchers) {
@@ -1180,9 +1261,17 @@ export async function apply(ctx, config) {
             saveMachines(machines, store.currentId)
           }
           ephemeral = null
+          // rw_connect means "connect now": force a fresh dial even for an
+          // identical target (setTarget alone would reuse a possibly half-open
+          // cached client — same reconnect-probe reasoning as /connect).
+          pool.invalidate()
           await applyActiveMachine()
         } else {
           ephemeral = { id: machineId(), name: host, ...rec }
+          // rw_connect means "connect now": force a fresh dial even for an
+          // identical target (setTarget alone would reuse a possibly half-open
+          // cached client — same reconnect-probe reasoning as /connect).
+          pool.invalidate()
           pool.setTarget({
             host: eff.host, port: effPort, username: effUser,
             password: rec.password, privateKeyPath: eff.privateKeyPath || '',
@@ -2181,6 +2270,12 @@ export async function apply(ctx, config) {
         let payload = {}
         try {
           payload = parseJsonObject(await readBody(req))
+          // This route is a reconnect PROBE ("Connect" button): with the
+          // unchanged-target no-op in setTarget, an identical target would
+          // reuse a possibly half-open cached client and the probe could hang.
+          // invalidate() is the design's forced-reconnect escape hatch — drop
+          // the cached client so the `echo ok` below always re-dials.
+          pool.invalidate()
           pool.setTarget({
             host: payload.host,
             port: payload.port,
@@ -2230,6 +2325,11 @@ export async function apply(ctx, config) {
           const p = normalizeRemotePath(String(payload.path || ''))
           if (!p || p === '/') return sendJson(res, 400, { ok: false, error: 'path must be an absolute directory' })
           if (!config.host) return sendJson(res, 400, { ok: false, error: 'no remote host configured/connected — connect first' })
+          // The picker names the machine it was browsing. Re-assert it so a
+          // switch made elsewhere between the listing and this commit cannot
+          // mirror onto a machine the user never looked at (the picker sends
+          // /current only once per machine now, so nothing else re-applies it).
+          if (!(await applyRequestedMachine(payload, res))) return
           const okDir = await isRemoteDir(p)
           if (!okDir) return sendJson(res, 400, { ok: false, error: `not a directory (or unreachable): ${p}` })
           const local = ensureMirror(p, config.host, config.username, config.port, { alias: aliasOf(activeMachine()) })
@@ -2659,6 +2759,11 @@ export async function apply(ctx, config) {
       handler: async (req, res) => {
         if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
         try {
+          const body = parseJsonObject(await readBody(req))
+          // The picker names the machine it is showing: re-assert it before
+          // answering, so a switch made elsewhere cannot make /home describe a
+          // different host than the tree the user is looking at.
+          if (!(await applyRequestedMachine(body, res))) return
           const out = await pool.exec('echo ~', { timeoutMs: Math.min(config.commandTimeoutMs, 5000) })
           const home = String(out.stdout || '').replace(/\s+/g, '').trim()
           if (!home) return sendJson(res, 200, { ok: true, home: null, hint: 'Windows 远程暂不支持 ~ 解析，请直接输入绝对路径' })
@@ -2673,17 +2778,26 @@ export async function apply(ctx, config) {
       path: '/dsh-remote/update-check',
       handler: async (req, res) => {
         if (req.method !== 'GET') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
-        const current = readVersion()
-        const latest = await fetchLatestVersion()
-        if (latest === null) return sendJson(res, 200, { ok: false, current, error: '无法连接 npm registry' })
+        // `loaded` is the code actually running; `disk` may already be newer.
+        // They differ between an applied update and its hot swap (or a boot).
+        const loaded = LOADED_VERSION
+        const disk = diskVersion()
         const rawMode = readUpdateMode() || config.updateMode || 'manual'
+        const base = {
+          current: loaded,
+          loaded,
+          disk,
+          pendingReload: gtVersion(disk, loaded),
+          updateMode: ['manual', 'auto', 'off'].includes(rawMode) ? rawMode : 'manual',
+          updatedMarker: existsSync(path.join(selfDir(), '.dsh-remote-updated')),
+        }
+        const latest = await fetchLatestVersion()
+        if (latest === null) return sendJson(res, 200, { ok: false, ...base, error: '无法连接 npm registry' })
         return sendJson(res, 200, {
           ok: true,
-          current,
+          ...base,
           latest,
-          updateAvailable: gtVersion(latest, current),
-          updateMode: ['manual', 'auto', 'off'].includes(rawMode) ? rawMode : 'manual',
-          updatedMarker: existsSync(path.join(selfDir(), '.dsh-remote-updated')),
+          updateAvailable: gtVersion(latest, loaded),
         })
       },
     },
@@ -2693,16 +2807,45 @@ export async function apply(ctx, config) {
       handler: async (req, res) => {
         if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
         try {
+          // Capture the outgoing version BEFORE the swap: reading it afterwards
+          // reports the version we just installed, not the one we replaced.
+          const from = diskVersion()
+          const loaded = LOADED_VERSION
           const body = JSON.parse((await readBody(req)) || '{}')
           const target = String(body.version || '')
           if (!target) return sendJson(res, 400, { ok: false, error: 'version is required' })
           const result = await applyUpdate(target)
-          return sendJson(res, 200, { ok: true, from: readVersion(), ...result })
+          const wantReload = body.reload !== false && config.updateAutoReload !== false
+          // Answer first, then swap: the swap disposes the fiber serving this
+          // very request, so nothing may touch the plugin after it.
+          if (wantReload) scheduleSelfReload(ctx.loader, 300)
+          return sendJson(res, 200, {
+            ok: true,
+            from,
+            loadedBefore: loaded,
+            ...result,
+            reloadScheduled: wantReload,
+            // what the swap will land on, for a caller that wants to verify
+            loadedAfterReload: wantReload ? result.to : loaded,
+          })
         } catch (err) {
           return sendJson(res, 500, { ok: false, error: String((err && err.message) || err) })
         }
       },
     },
+    {
+      kind: 'exact',
+      path: '/dsh-remote/update-reload',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
+        // Hot-swap the host half to whatever is on disk now. Answers first (with
+        // what was loaded and what it is about to become), then swaps.
+        const loaded = LOADED_VERSION
+        const disk = diskVersion()
+        scheduleSelfReload(ctx.loader, 300)
+        return sendJson(res, 200, { ok: true, scheduled: true, loaded, disk, willReloadTo: disk })
+      },
+    },
     {
       kind: 'exact',
       path: '/dsh-remote/update-mode',
@@ -2729,12 +2872,24 @@ export async function apply(ctx, config) {
   const rawMode = readUpdateMode() || config.updateMode || 'manual'
   const effectiveUpdateMode = ['manual', 'auto', 'off'].includes(rawMode) ? rawMode : 'manual'
   if (effectiveUpdateMode === 'auto') {
-    const currentVersion = readVersion()
     const checkAndApply = async () => {
       const latest = await fetchLatestVersion()
-      if (latest && gtVersion(latest, currentVersion)) {
-        try { await applyUpdate(latest) } catch {}
+      if (!latest) return
+      // The version in flight is whichever of "already on disk" / "already
+      // loaded" is newer. Pinning it once outside this closure (as v0.8.23 did)
+      // made every later interval re-download and re-apply the same tarball,
+      // because the pinned value never moves past the version it installed.
+      const disk = diskVersion()
+      const current = gtVersion(disk, LOADED_VERSION) ? disk : LOADED_VERSION
+      if (!gtVersion(latest, current)) return
+      try {
+        await applyUpdate(latest)
+      } catch {
+        return
       }
+      // Landed: swap the running host half too, otherwise the code being served
+      // and the code being run stay one version apart until the next boot.
+      if (config.updateAutoReload !== false) scheduleSelfReload(ctx.loader, 500)
     }
     void checkAndApply()
     const updateTimer = setInterval(checkAndApply, Math.max(config.updateCheckIntervalMs, 60000))

package/lib/pool.js

@@ -41,24 +41,48 @@ export class SshPool {
     return p
   }
 
-  setTarget({ host, port, username, password, privateKeyPath, passphrase, workspace, useAgent, keyboardInteractive, proxy, hostKeyMode }) {
-    if (host !== undefined) this.config.host = String(host)
-    if (port !== undefined && Number(port)) this.config.port = Number(port)
-    if (username !== undefined) this.config.username = String(username)
-    if (password !== undefined && password !== null) this.config.password = String(password)
-    if (privateKeyPath !== undefined) this.config.privateKeyPath = String(privateKeyPath)
-    if (passphrase !== undefined) this.config.passphrase = String(passphrase)
-    if (workspace !== undefined) this.config.workspace = String(workspace)
-    if (useAgent !== undefined) this.config.useAgent = !!useAgent
-    if (keyboardInteractive !== undefined) this.config.keyboardInteractive = !!keyboardInteractive
-    if (proxy !== undefined) this.config.proxy = proxy
-    if (hostKeyMode !== undefined) this.config.hostKeyMode = String(hostKeyMode)
-    // the new target may be a different OS — re-detect on the next command
-    this.platform = 'unknown'
-    this.gitBashPath = ''
-    this.shellMode = 'native'
-    this._detecting = null
-    this.close()
+  setTarget({ host, port, username, password, privateKeyPath, passphrase, workspace, useAgent, keyboardInteractive, proxy, hostKeyMode }, previous) {
+    // Collect the requested changes first: an UNCHANGED target is a no-op. The
+    // old behavior closed the live connection and re-ran platform detection
+    // even for an identical target, so every picker keystroke
+    // (POST /current → applyActiveMachine → setTarget) paid a full SSH
+    // reconnect + re-detect — the "slow remote path autocomplete" bug.
+    //
+    // `previous` is the diff BASELINE. Callers whose shared config was already
+    // mutated BEFORE this call (applyActiveMachine: applyMachine rewrites the
+    // live config IN PLACE, and pool.config IS that config object) pass a
+    // pre-mutation snapshot — otherwise the comparison runs the new values
+    // against themselves, is always equal and never closes even for a machine
+    // switch (the wrong-host hazard of issue #25). Defaults to the current
+    // config for callers that pass fresh values read independently of it.
+    const base = previous || this.config
+    const wanted = []
+    if (host !== undefined) wanted.push(['host', String(host)])
+    if (port !== undefined && Number(port)) wanted.push(['port', Number(port)])
+    if (username !== undefined) wanted.push(['username', String(username)])
+    if (password !== undefined && password !== null) wanted.push(['password', String(password)])
+    if (privateKeyPath !== undefined) wanted.push(['privateKeyPath', String(privateKeyPath)])
+    if (passphrase !== undefined) wanted.push(['passphrase', String(passphrase)])
+    if (workspace !== undefined) wanted.push(['workspace', String(workspace)])
+    if (useAgent !== undefined) wanted.push(['useAgent', !!useAgent])
+    if (keyboardInteractive !== undefined) wanted.push(['keyboardInteractive', !!keyboardInteractive])
+    if (proxy !== undefined) wanted.push(['proxy', proxy])
+    if (hostKeyMode !== undefined) wanted.push(['hostKeyMode', String(hostKeyMode)])
+    const differs = ([k, v]) => (k === 'proxy'
+      ? JSON.stringify(base[k] ?? null) !== JSON.stringify(v ?? null)
+      : base[k] !== v)
+    // Something actually changed → apply it and force a fresh connection.
+    // (A caller that WANTS a reconnect for an identical target uses
+    // invalidate(); setTarget semantics stay "re-point when moved".)
+    if (wanted.some(differs)) {
+      for (const [k, v] of wanted) this.config[k] = v
+      // the new target may be a different OS — re-detect on the next command
+      this.platform = 'unknown'
+      this.gitBashPath = ''
+      this.shellMode = 'native'
+      this._detecting = null
+      this.close()
+    }
     return this
   }
 
@@ -484,6 +508,13 @@ export class SshPool {
     if (client) {
       try { client.end() } catch {}
     }
+    // Same teardown as close(): the forwards manager must detach from the
+    // dying client, or its stale `close -> stopAll()` listener later tears
+    // down forwards that were re-attached to the NEW client (onReady does
+    // the re-attach on the next successful connect).
+    if (this.onCloseHook) {
+      try { this.onCloseHook() } catch {}
+    }
   }
 
   close() {

package/lib/routes-fs.js

@@ -40,6 +40,17 @@ export function createFsRoutes({
           const hint = requestSessionHint(req)
           const b = await bindOrReply(req, res, hint)
           if (!b) return
+          // Identity echo (external-switch defense): name the machine this
+          // listing is answered for, straight from the pool's target — the
+          // picker validates every listing against the machine it INTENDED and
+          // re-switches on mismatch (the settings page can change the active
+          // machine under a memoized picker).
+          const tgt = (b.pool && b.pool.config) || {}
+          const machine = {
+            host: String(tgt.host || b.host || ''),
+            port: Number(tgt.port) || Number(b.port) || 22,
+            username: String(tgt.username || b.username || ''),
+          }
           await b.pool.detect()
           const q = new URL(req.url, 'http://localhost').searchParams
           const raw = q.get('path') ? decodeURIComponent(q.get('path')) : (b.ws || '')
@@ -48,9 +59,9 @@ export function createFsRoutes({
           if (canon === '/' || raw === '' || raw === '/') {
             if (win || b.pool.platform !== 'posix') {
               const drives = await listRemoteDrives(b.pool)
-              if (drives.length) return sendJson(res, 200, { path: '', platform: 'windows', items: drives, bound: b.bound })
+              if (drives.length) return sendJson(res, 200, { path: '', platform: 'windows', items: drives, bound: b.bound, machine })
             }
-            if (win) return sendJson(res, 200, { path: '', platform: 'windows', items: [], bound: b.bound })
+            if (win) return sendJson(res, 200, { path: '', platform: 'windows', items: [], bound: b.bound, machine })
           }
           const sftp = await b.pool.sftp()
           const out = await listDirStructured(sftp, canon)
@@ -64,6 +75,7 @@ export function createFsRoutes({
             items,
             missing: !!out.missing,
             bound: b.bound,
+            machine,
           })
         } catch (err) {
           return sendJson(res, 500, { error: String((err && err.message) || err) })

package/lib/update.js

@@ -8,15 +8,24 @@
 //   • checkLatestVersion() — query the npm registry for the `latest` dist-tag;
 //   • applyUpdate() — download the tarball, extract package/{lib,package.json,
 //     cordis.patch.yml} with a minimal tar reader, verify the version, then
-//     atomically copy over the installed files. A `.dsh-remote-updated` marker
-//     is written so the UI can tell the user to reload.
+//     replace the installed files atomically (temp file + rename, never a
+//     half-written lib/*.js). A `.dsh-remote-updated` marker records the version
+//     that landed; the host half removes it once that version is the code it is
+//     actually running (see LOADED_VERSION), so the marker means "restart still
+//     required" rather than "an update once happened".
+//   • reloadSelf() — swap the RUNNING host half to the code now on disk: drop
+//     Node's module caches for this package's own files, then dispose + re-init
+//     the loader entry so apply() runs again from the fresh module. Without it
+//     an update only takes effect on the next process start, which is what left
+//     the served client half newer than the loaded host half.
 //
 // Every failure aborts without touching the installed files (a bad download or
 // a version mismatch must never break the running plugin).
 
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import path from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 
 const NPM_PACKAGE = 'dsh-remote'
 const REGISTRY_URL = 'https://registry.npmjs.org/' + NPM_PACKAGE + '/latest'
@@ -40,6 +49,17 @@ export function readVersion() {
   }
 }
 
+/** Version of the code this process actually loaded (snapshot at import time).
+ *  `readVersion()` reads package.json from disk, so after an update lands it
+ *  reports the NEW version while the running module is still the old one —
+ *  comparing the two is the only way to tell "applied" from "active". */
+export const LOADED_VERSION = readVersion()
+
+/** Package version currently on disk (may be newer than {@link LOADED_VERSION}). */
+export function diskVersion() {
+  return readVersion()
+}
+
 /** Compare dotted versions; returns true when a > b. */
 export function gtVersion(a, b) {
   const pa = String(a || '').split('.').map((n) => parseInt(n, 10) || 0)
@@ -96,9 +116,10 @@ function parseTar(buf) {
  * installed files untouched).
  * @param targetVersion - exact npm version to install (e.g. "0.8.0").
  */
-export async function applyUpdate(targetVersion) {
+export async function applyUpdate(targetVersion, options = {}) {
   const tarballUrl = `https://registry.npmjs.org/${NPM_PACKAGE}/-/${NPM_PACKAGE}-${targetVersion}.tgz`
-  const dir = selfDir()
+  const dir = options.dir || selfDir()
+  const doFetch = options.fetchImpl || fetch
   const tmpRoot = path.join(dir, `.dsh-remote-update-${Date.now()}`)
   const tmpPkg = path.join(tmpRoot, 'package')
   try {
@@ -106,7 +127,7 @@ export async function applyUpdate(targetVersion) {
     const timer = setTimeout(() => controller.abort(), 60000)
     let res
     try {
-      res = await fetch(tarballUrl, { signal: controller.signal })
+      res = await doFetch(tarballUrl, { signal: controller.signal })
     } finally {
       clearTimeout(timer)
     }
@@ -135,20 +156,34 @@ export async function applyUpdate(targetVersion) {
     // break the next boot — check the file size and that it is not empty).
     const newIndex = path.join(tmpPkg, 'lib', 'index.js')
     if (!existsSync(newIndex) || statSize(newIndex) < 100) throw new Error('tarball missing lib/index.js')
-    // Atomically swap: copy fresh files over the installed ones.
+    // Swap the installed files one at a time: atomic, and idempotent.
+    //
+    // Atomicity (temp file + rename) is not cosmetic here — since the browser
+    // half is hot-swapped by dsh-client-hmr, which stat-polls lib/client.js
+    // every 500 ms, a torn write would be re-hashed and served mid-copy.
+    // Skipping byte-identical files keeps a re-apply of the same version from
+    // churning mtimes (and the host half from reloading for nothing).
     const installLib = path.join(dir, 'lib')
     const tmpLib = path.join(tmpPkg, 'lib')
+    const changed = []
+    const install = (src, dest) => {
+      const bytes = readFileSync(src)
+      if (sameFileContent(dest, bytes)) return
+      try { mkdirSync(path.dirname(dest), { recursive: true }) } catch {}
+      writeFileAtomic(dest, bytes)
+      changed.push(path.relative(dir, dest).split(path.sep).join('/'))
+    }
     for (const name of readdirSafe(tmpLib)) {
       if (!name.endsWith('.js')) continue
       const src = path.join(tmpLib, name)
-      if (existsSync(src)) copyFileSync(src, path.join(installLib, name))
+      if (existsSync(src)) install(src, path.join(installLib, name))
     }
     for (const rel of ['package.json', 'cordis.patch.yml']) {
       const src = path.join(tmpPkg, rel)
-      if (existsSync(src)) copyFileSync(src, path.join(dir, rel))
+      if (existsSync(src)) install(src, path.join(dir, rel))
     }
     writeFileSync(path.join(dir, '.dsh-remote-updated'), String(targetVersion))
-    return { ok: true, to: targetVersion }
+    return { ok: true, to: targetVersion, changed }
   } catch (err) {
     throw new Error('update failed: ' + ((err && err.message) || err))
   } finally {
@@ -174,6 +209,145 @@ function readdirSafe(dir) {
   }
 }
 
+/**
+ * Write `data` to `dest` atomically: the bytes land in a sibling temp file and
+ * are then renamed over the target, so a concurrent reader (the client-half HMR
+ * poll, or the next boot) never observes a truncated file. Falls back to an
+ * in-place copy if the platform refuses the replace, and never leaves the temp
+ * file behind.
+ * @param dest - absolute destination path.
+ * @param data - bytes to write.
+ */
+export function writeFileAtomic(dest, data) {
+  const tmp = `${dest}.dsh-tmp-${process.pid}-${Date.now().toString(36)}`
+  writeFileSync(tmp, data)
+  try {
+    renameSync(tmp, dest)
+    return
+  } catch {
+    try {
+      copyFileSync(tmp, dest)
+    } finally {
+      try { rmSync(tmp, { force: true }) } catch {}
+    }
+  }
+}
+
+/** Whether the file at `p` already holds exactly `bytes` (missing/short → false). */
+function sameFileContent(p, bytes) {
+  try {
+    return readFileSync(p).equals(bytes)
+  } catch {
+    return false
+  }
+}
+
+// ── hot swap of the running host half ─────────────────────────────────────
+
+/** Loader entry ids this package can own. */
+const SELF_ENTRY_NAMES = ['dsh-remote']
+
+/**
+ * Find our own loader entry (by id, then by module specifier). Returns undefined
+ * when the tree does not contain us (e.g. a test loader, or a renamed row).
+ * @param loader - the cordis Loader service (`ctx.loader`).
+ */
+function findSelfEntry(loader) {
+  let entries = []
+  try {
+    entries = [...(loader?.entries?.() ?? [])]
+  } catch {
+    return undefined
+  }
+  for (const want of SELF_ENTRY_NAMES) {
+    const byId = entries.find((entry) => entry?.options?.id === want)
+    if (byId) return byId
+  }
+  for (const want of SELF_ENTRY_NAMES) {
+    const byName = entries.find((entry) => entry?.options?.name === want)
+    if (byName) return byName
+  }
+  return undefined
+}
+
+/**
+ * Drop Node's module caches for this package's own files, so the next import of
+ * the plugin actually re-reads disk instead of handing back the cached module.
+ * Both caches matter: the ESM `loadCache` (a plain Map on Node 22/23, a
+ * `LoadCache extends Map` on Node 24 — hence the explicit `Map.prototype` calls)
+ * and, for CJS modules pulled in through `import()`, `require.cache`.
+ * @param loader - the cordis Loader service.
+ * @param dir - package directory whose `lib/` to evict (defaults to this
+ *   package's own install dir; overridable so the swap can be exercised against
+ *   a fixture install).
+ * @returns how many ESM entries were dropped.
+ */
+export function clearSelfModuleCache(loader, dir = selfDir()) {
+  const libDir = path.join(dir, 'lib')
+  const loadCache = loader?.internal?.loadCache
+  const req = (() => {
+    try { return createRequire(import.meta.url) } catch { return undefined }
+  })()
+  let cleared = 0
+  for (const name of readdirSafe(libDir)) {
+    if (!name.endsWith('.js')) continue
+    const url = pathToFileURL(path.join(libDir, name)).href
+    try {
+      if (loadCache && Map.prototype.has.call(loadCache, url)) {
+        Map.prototype.delete.call(loadCache, url)
+        cleared += 1
+      }
+    } catch {}
+    try {
+      const file = fileURLToPath(url)
+      if (req?.cache && req.cache[file]) delete req.cache[file]
+    } catch {}
+  }
+  return cleared
+}
+
+/**
+ * Swap the RUNNING host half to the code now on disk: clear the module caches
+ * for our own files, dispose our loader entry (tools, JSON routes, SSH pools and
+ * every `ctx.effect` disposer go with the fiber), then re-init it so `apply()`
+ * runs again from the freshly imported module.
+ *
+ * Callers must not depend on this plugin after a successful reload — the fiber
+ * that served the current request is gone. Schedule it (see
+ * {@link scheduleSelfReload}) rather than awaiting it from a request handler.
+ * @param loader - the cordis Loader service (`ctx.loader`).
+ * @returns a small result object; never throws.
+ */
+export async function reloadSelf(loader) {
+  const entry = findSelfEntry(loader)
+  if (!entry) return { ok: false, reason: 'own loader entry not found' }
+  try {
+    const cleared = clearSelfModuleCache(loader)
+    if (typeof entry._dispose === 'function') await entry._dispose()
+    else if (typeof entry.dispose === 'function') await entry.dispose()
+    else return { ok: false, reason: 'entry exposes no dispose hook' }
+    await entry.init()
+    return { ok: true, cleared }
+  } catch (err) {
+    return { ok: false, reason: String((err && err.message) || err) }
+  }
+}
+
+/**
+ * Fire-and-forget {@link reloadSelf} after a short delay, so the caller can
+ * finish answering an HTTP request (or an update check) before its own module is
+ * torn down. Failures are swallowed: a failed swap leaves the running code in
+ * place, which is the pre-hot-update behaviour, not a crash.
+ * @param loader - the cordis Loader service.
+ * @param delayMs - grace period before the swap (default 300 ms).
+ * @returns true when the swap was scheduled.
+ */
+export function scheduleSelfReload(loader, delayMs = 300) {
+  const timer = setTimeout(() => { void reloadSelf(loader).catch(() => {}) }, Math.max(0, delayMs))
+  if (typeof timer.unref === 'function') timer.unref()
+  return true
+}
+
 /** Write the persisted update-mode override (settings UI). */
 export function persistUpdateMode(mode) {
   if (!['manual', 'auto', 'off'].includes(mode)) return false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote",
-  "version": "0.8.22",
+  "version": "0.8.24",
   "description": "Remote-work assistant for DeepSeek Harness: connect SSH (password/key/agent/keyboard-interactive/proxy jump), pick a remote workspace, operate on it with 20 rw_* tools (incl. rw_edit/rw_stat/rw_mkdir/rw_remove/rw_move/rw_forward), conflict-aware mirror sync, port forwarding, optional side-bar remote file editing, audit log, keychain passwords.",
   "license": "MIT",
   "author": "flymysql <flyphp@outlook.com>",