dsh-remote 0.8.21 → 0.8.23

package/lib/client.js

@@ -48,9 +48,19 @@ window.__ModuleLoader__.load({
         'settings.noActive': '当前没有活动远程机：保存的机器只是备用连接，不会自动进入会话上下文（本地会话不受影响）。',
         'settings.addMachine': '添加机器',
         'settings.editMachine': '编辑机器',
+        'settings.badgeSshConfig': 'ssh cfg',
         'settings.sshImport': '从 ~/.ssh/config 导入',
         'settings.sshCollapse': '收起',
         'settings.sshNoEntries': '~/.ssh/config 里没有可导入的 Host 条目',
+        'settings.sshUseAlias': '用别名（不复制）',
+        'settings.sshCopyFields': '复制字段',
+        'settings.sshAliasHint': '别名模式：机器只记住「{alias}」这个名字，主机/用户/端口/私钥/跳板每次连接都从 ~/.ssh/config 实时解析（改配置立刻生效）。',
+        'settings.useSshConfig': '使用 ~/.ssh/config 别名（只存别名，不存副本）',
+        'settings.useSshConfigHint': '留空或保持默认的字段（用户 root、端口 22、私钥、跳板）将从 ~/.ssh/config 实时解析；填了非默认值则覆盖。',
+        'settings.sshResolvedTo': '→ {user}@{host}:{port}',
+        'settings.sshResolvedNone': '~/.ssh/config 中没有匹配「{alias}」的 Host 条目',
+        'settings.sshResolvedWarn': '注意：{msg}',
+        'settings.sshAliasSaved': '已按别名保存（连接时解析）',
         'settings.name': '名称',
         'settings.host': '主机',
         'settings.port': '端口',
@@ -262,9 +272,19 @@ window.__ModuleLoader__.load({
         'settings.noActive': 'No active remote machine: saved machines are standby connections and never enter a session context automatically (local sessions are unaffected).',
         'settings.addMachine': 'Add machine',
         'settings.editMachine': 'Edit machine',
+        'settings.badgeSshConfig': 'ssh cfg',
         'settings.sshImport': 'Import from ~/.ssh/config',
         'settings.sshCollapse': 'Collapse',
         'settings.sshNoEntries': 'No importable Host entries in ~/.ssh/config',
+        'settings.sshUseAlias': 'Use alias (no copy)',
+        'settings.sshCopyFields': 'Copy fields',
+        'settings.sshAliasHint': 'Alias mode: the machine remembers only the name "{alias}"; host/user/port/key/jump host are resolved from ~/.ssh/config at every connect, so editing that file takes effect immediately.',
+        'settings.useSshConfig': 'Use a ~/.ssh/config alias (keep the alias, not a copy)',
+        'settings.useSshConfigHint': 'Fields left empty or at their default (user root, port 22, key, jump host) come from ~/.ssh/config at connect time; a non-default value overrides it.',
+        'settings.sshResolvedTo': '→ {user}@{host}:{port}',
+        'settings.sshResolvedNone': 'no ~/.ssh/config block matches "{alias}"',
+        'settings.sshResolvedWarn': 'Heads-up: {msg}',
+        'settings.sshAliasSaved': 'Saved as an alias (resolved on connect)',
         'settings.name': 'Name',
         'settings.host': 'Host',
         'settings.port': 'Port',
@@ -741,6 +761,9 @@ window.__ModuleLoader__.load({
         name: '', host: '', port: '22', username: 'root', password: '', privateKeyPath: '',
         passphrase: '', workspace: '', hostKeyMode: '', useAgent: false, keyboardInteractive: false,
         encryptPassword: false, proxyHost: '', proxyPort: '22', proxyUser: '', proxyPassword: '', proxyKey: '', id: '',
+        // Issue #38: alias mode — `host` is a ~/.ssh/config Host name and the
+        // resolved values are never copied into the registry.
+        useSshConfig: false,
       })
       const [busy, setBusy] = React.useState(false)
       const [msg, setMsg] = React.useState('')
@@ -762,12 +785,20 @@ window.__ModuleLoader__.load({
         api('POST', '/dsh-remote/test-connect', {
           host: form.host, port: Number(form.port) || 22, username: form.username || 'root',
           password: form.password, privateKeyPath: form.privateKeyPath, passphrase: form.passphrase,
+          useSshConfig: !!form.useSshConfig,
           proxy: form.proxyHost ? { host: form.proxyHost, port: Number(form.proxyPort) || 22, username: form.proxyUser || '', password: form.proxyPassword || '', privateKeyPath: form.proxyKey || '' } : undefined,
         })
           .then((r) => {
             if (r && r.ok) {
               const shellTag = r.platform === 'windows' ? (r.gitBash ? tr('settings.shellWin') : tr('settings.shellWinNoGit')) : (r.platform === 'posix' ? tr('settings.shellPosix') : '')
-              setTst('ok'); setMsg(r.latencyMs != null ? tr('settings.connOkWith', { user: r.user, host: r.host, latency: r.latencyMs, shell: shellTag }) : tr('settings.connOk')); refresh()
+              setTst('ok'); setMsg(r.latencyMs != null ? tr('settings.connOkWith', { user: r.user, host: r.host, latency: r.latencyMs, shell: shellTag }) : tr('settings.connOk'))
+              // Issue #38: show where an alias resolved to (and what could not
+              // be honoured), instead of leaving the user guessing.
+              if (r.alias) {
+                setMsg((m) => m + ' ' + tr('settings.sshResolvedTo', { user: r.alias.user || '?', host: r.alias.host, port: r.alias.port }))
+                if (r.alias.warnings && r.alias.warnings.length) setErr(tr('settings.sshResolvedWarn', { msg: r.alias.warnings.join(' ') }))
+              }
+              refresh()
             }
             else { setTst('failing'); setErr((r && r.error) || tr('settings.connFail')) }
           })
@@ -832,13 +863,14 @@ window.__ModuleLoader__.load({
           proxyHost: (m.proxy && m.proxy.host) || '', proxyPort: String((m.proxy && m.proxy.port) || 22),
           proxyUser: (m.proxy && m.proxy.username) || '', proxyPassword: '', proxyKey: (m.proxy && m.proxy.privateKeyPath) || '',
           id: m.id,
+          useSshConfig: !!m.useSshConfig,
         })
         // 编辑时若该机器用了高级配置(私钥/agent/跳板/钥匙串等),自动展开折叠区
         if (m.privateKeyPath || m.useAgent || m.keyboardInteractive || m.workspace || (m.proxy && m.proxy.host) || (m.credentialBackend && m.credentialBackend !== 'plain')) {
           setAdvOpen(true)
         }
       }
-      const clearForm = () => setForm({ name: '', host: '', port: '22', username: 'root', password: '', privateKeyPath: '', passphrase: '', workspace: '', hostKeyMode: '', useAgent: false, keyboardInteractive: false, encryptPassword: false, proxyHost: '', proxyPort: '22', proxyUser: '', proxyPassword: '', proxyKey: '', id: '' })
+      const clearForm = () => setForm({ name: '', host: '', port: '22', username: 'root', password: '', privateKeyPath: '', passphrase: '', workspace: '', hostKeyMode: '', useAgent: false, keyboardInteractive: false, encryptPassword: false, proxyHost: '', proxyPort: '22', proxyUser: '', proxyPassword: '', proxyKey: '', id: '', useSshConfig: false })
       const save = (action) => {
         setBusy(true); setErr(''); setMsg('')
         if (action === 'delete') {
@@ -849,7 +881,7 @@ window.__ModuleLoader__.load({
           action: form.id ? 'update' : 'add', id: form.id || undefined, name: form.name, host: form.host, port: Number(form.port) || 22,
           username: form.username, password: form.password, privateKeyPath: form.privateKeyPath, passphrase: form.passphrase,
           workspace: form.workspace, hostKeyMode: form.hostKeyMode, useAgent: form.useAgent, keyboardInteractive: form.keyboardInteractive,
-          encryptPassword: form.encryptPassword,
+          encryptPassword: form.encryptPassword, useSshConfig: !!form.useSshConfig,
           proxy: form.proxyHost ? { host: form.proxyHost, port: Number(form.proxyPort) || 22, username: form.proxyUser || '', password: form.proxyPassword || '', privateKeyPath: form.proxyKey || '' } : undefined,
         }).then((r) => {
           refresh(); clearForm()
@@ -869,10 +901,25 @@ window.__ModuleLoader__.load({
         api('GET', '/dsh-remote/ssh-config').then((r) => setSshEntries(r && r.present ? (r.entries || []) : []))
           .catch((e) => setErr(tr('settings.sshReadFail', { msg: String((e && e.message) || e) })))
       }
+      // Issue #38, primary action: save the machine as an ALIAS. Nothing from
+      // ~/.ssh/config is copied into the registry — the host/user/port/key/jump
+      // host are re-read at every connect, so editing that file is enough.
+      const useSshAlias = (e) => {
+        setForm({
+          ...form,
+          name: e.host, host: e.host, port: '22', username: 'root',
+          privateKeyPath: '', passphrase: '', useSshConfig: true,
+        })
+        setSshEntries(null)
+        setMsg(tr('settings.sshAliasHint', { alias: e.host }))
+      }
+      // Legacy/escape hatch: materialise the current values as a normal machine
+      // (for users who want to override them individually).
       const applySshEntry = (e) => {
-        setForm({ ...form,
+        setForm({
+          ...form,
           name: e.host, host: e.hostName || e.host, port: String(e.port || 22),
-          username: e.user || 'root', privateKeyPath: e.identityFile || '',
+          username: e.user || 'root', privateKeyPath: e.identityFile || '', useSshConfig: false,
         })
         setSshEntries(null)
         setMsg(tr('settings.filledSsh'))
@@ -921,13 +968,21 @@ window.__ModuleLoader__.load({
                 React.createElement('div', { style: { flex: 1, fontSize: 13, minWidth: 180 } },
                   React.createElement('div', { style: { display: 'flex', gap: 6, alignItems: 'center', flexWrap: 'wrap' } },
                     React.createElement('span', { style: { fontWeight: 600 } }, m.name),
-                    React.createElement('code', { style: { fontSize: 12, opacity: 0.8 } }, m.username + '@' + m.host + ':' + m.port),
+                    React.createElement('code', { style: { fontSize: 12, opacity: 0.8 } },
+                      m.useSshConfig ? (m.host + (m.sshConfigResolved && m.sshConfigResolved.matched ? '  ' + tr('settings.sshResolvedTo', { user: m.sshConfigResolved.username || '?', host: m.sshConfigResolved.host, port: m.sshConfigResolved.port }) : ''))
+                        : (m.username + '@' + m.host + ':' + m.port)),
+                    m.useSshConfig ? pill('', tr('settings.badgeSshConfig')) : null,
                     m.id === currentId ? pill('is-ok', tr('settings.current')) : null,
                     m.passwordSet ? pill('', tr('settings.badgePwd')) : null,
                     (m.credentialBackend && m.credentialBackend !== 'plain') ? pill('', tr('settings.badgeKeychain')) : null,
                     m.proxy && m.proxy.host ? pill('', tr('settings.badgeProxy')) : null,
                     m.latencyMs != null ? React.createElement('span', { style: { fontSize: 11, opacity: 0.6 } }, m.latencyMs + 'ms') : null,
-                  )),
+                  ),
+                  // Issue #38: an alias that no longer resolves (or a ProxyJump
+                  // the plugin had to trim) must be visible, not silent.
+                  (m.sshConfigResolved && m.sshConfigResolved.warnings && m.sshConfigResolved.warnings.length)
+                    ? React.createElement('div', { style: { fontSize: 11, color: T.warn, marginTop: 2 } }, tr('settings.sshResolvedWarn', { msg: m.sshConfigResolved.warnings.join(' ') }))
+                    : null),
                 React.createElement('div', { style: { display: 'flex', gap: 6, flexShrink: 0 } },
                   React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: buttonS, onClick: () => startEdit(m) }, tr('settings.edit')),
                   React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: buttonS, onClick: () => del(m.id) }, tr('settings.delete')),
@@ -943,13 +998,30 @@ window.__ModuleLoader__.load({
           React.createElement('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 6 } },
             React.createElement('div', { style: { fontSize: 13, fontWeight: 600 } }, form.id ? tr('settings.editMachine') : tr('settings.addMachine')),
             React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, fontSize: 12, padding: '3px 8px' }, onClick: () => (sshEntries ? setSshEntries(null) : importSsh()) }, sshEntries ? tr('settings.sshCollapse') : tr('settings.sshImport'))),
-          sshEntries ? React.createElement('div', { style: { marginBottom: 8, maxHeight: 160, overflowY: 'auto', border: '1px solid ' + T.border, borderRadius: T.radius } },
-            sshEntries.length ? sshEntries.map((e) => React.createElement('div', { key: e.host, className: 'dsh-rw-list-item', onClick: () => applySshEntry(e), style: { padding: '6px 10px', cursor: 'pointer', fontSize: 12, borderBottom: '1px solid ' + T.border } },
-              e.host + '  →  ' + (e.hostName || '?') + (e.user ? '  (' + e.user + ')' : '') + (e.identityFile ? '  [key]' : '') + (e.proxyJump ? '  ⛳' : '')))
+          sshEntries ? React.createElement('div', { style: { marginBottom: 8, maxHeight: 200, overflowY: 'auto', border: '1px solid ' + T.border, borderRadius: T.radius } },
+            sshEntries.length ? sshEntries.map((e) => React.createElement('div', { key: e.host, className: 'dsh-rw-list-item', style: { padding: '6px 10px', fontSize: 12, borderBottom: '1px solid ' + T.border, display: 'flex', gap: 8, alignItems: 'center' } },
+              React.createElement('div', { onClick: () => useSshAlias(e), style: { flex: 1, cursor: 'pointer' }, title: tr('settings.sshUseAlias') },
+                e.host + '  →  ' + (e.hostName || '?') + (e.user ? '  (' + e.user + ')' : '') + (e.identityFile ? '  [key]' : '') + (e.proxyJump ? '  ⛳' : '')),
+              React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, fontSize: 11, padding: '2px 8px', whiteSpace: 'nowrap' }, onClick: () => useSshAlias(e) }, tr('settings.sshUseAlias')),
+              React.createElement('button', { type: 'button', className: 'dsh-rw-btn', style: { ...buttonS, fontSize: 11, padding: '2px 8px', whiteSpace: 'nowrap', opacity: 0.8 }, onClick: () => applySshEntry(e) }, tr('settings.sshCopyFields'))))
               : React.createElement('div', { style: { padding: 8, fontSize: 12, opacity: 0.6 } }, tr('settings.sshNoEntries')))
           : null,
           row(tr('settings.name'), React.createElement('input', { className: 'dsh-rw-input', value: form.name, onChange: setF('name'), placeholder: tr('settings.name') + ' (e.g. build-server)', style: inputS }), 'n'),
-          row(tr('settings.host'), React.createElement('input', { className: 'dsh-rw-input', value: form.host, onChange: setF('host'), placeholder: 'IP or hostname', style: inputS }), 'h'),
+          row(tr('settings.host'), React.createElement('input', { className: 'dsh-rw-input', value: form.host, onChange: setF('host'), placeholder: form.useSshConfig ? tr('settings.sshImport') + ' Host 别名' : 'IP or hostname', style: inputS }), 'h'),
+          row(tr('settings.useSshConfig'), React.createElement('input', { type: 'checkbox', checked: !!form.useSshConfig, onChange: setFb('useSshConfig') }), 'sshc'),
+          form.useSshConfig ? React.createElement('div', { style: { fontSize: 11, opacity: 0.8, marginBottom: 8, lineHeight: 1.5 } }, tr('settings.useSshConfigHint')) : null,
+          form.useSshConfig ? (() => {
+            // Preview where the alias points, from the same resolution the
+            // connect path uses (the host list carries it — issue #38).
+            const preview = machines.find((m) => m.host === form.host && m.useSshConfig)
+            const res = preview && preview.sshConfigResolved
+            if (!res) return null
+            return React.createElement('div', { style: { fontSize: 11, marginBottom: 8, color: res.matched ? T.ok : T.warn, lineHeight: 1.5 } },
+              res.matched
+                ? form.host + ' ' + tr('settings.sshResolvedTo', { user: res.username || '?', host: res.host, port: res.port })
+                : tr('settings.sshResolvedNone', { alias: form.host }),
+              (res.warnings && res.warnings.length) ? React.createElement('div', { style: { opacity: 0.85 } }, tr('settings.sshResolvedWarn', { msg: res.warnings.join(' ') })) : null)
+          })() : null,
           row(tr('settings.port'), React.createElement('input', { className: 'dsh-rw-input', value: form.port, onChange: setF('port'), placeholder: '22', style: { ...inputS, width: 70 } }), 'p'),
           row(tr('settings.user'), React.createElement('input', { className: 'dsh-rw-input', value: form.username, onChange: setF('username'), placeholder: 'root', style: inputS }), 'u'),
           row(tr('settings.password'), React.createElement('input', { className: 'dsh-rw-input', type: 'password', value: form.password, onChange: setF('password'), placeholder: 'SSH password (hidden)', style: inputS }), 'w'),
@@ -1141,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])
@@ -1175,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)
           })
         })
@@ -1207,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)
@@ -1301,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 ? '\\' : '/'
@@ -1314,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) => {
@@ -1335,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) => {
@@ -1362,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 = () => {
@@ -1512,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
             }