dsh-remote 0.8.22 → 0.8.23

package/lib/client.js

@@ -1213,9 +1213,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 +1263,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 +1394,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 +1494,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 +1534,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 +1546,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 +1568,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 +1731,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

@@ -360,18 +360,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 +530,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 +570,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 +587,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 +601,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 +1248,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 +2257,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 +2312,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 +2746,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 远程暂不支持 ~ 解析，请直接输入绝对路径' })

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote",
-  "version": "0.8.22",
+  "version": "0.8.23",
   "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>",