dsh-ssh-manage 0.2.2 → 0.3.0

package/README.en.md

@@ -64,7 +64,7 @@ No more jumping between a terminal and DSH, and no need to remember where each h
 - Ciphertext and key live in the same user directory, so this mainly protects against accidental file reads, not against malicious processes running as the same user.
 - Groups, tags, favorites, notes and inspection data live in `hosts.json`; passwords live in `vault.json`; configuration changes are snapshotted to the backup directory.
 
-> **Host key verification:** the transport does not verify `known_hosts` host keys (ssh2 accepts the server-provided key, same as the previous one-shot command path). **Use the interactive terminal only on trusted networks** and do not type sudo passwords on untrusted networks.
+> **Host key verification:** connections verify host keys against `known_hosts` (default `~/.ssh/known_hosts`, override with `SSH_KNOWN_HOSTS`). The first connection to an unknown host, or a changed host key, is refused with the server `SHA256:` fingerprint, expected fingerprint and known_hosts path. Verify the fingerprint out of band, then add the host line (`host key-type base64-blob`, or `[host]:port ...` for non-22) or import it with `ssh-keyscan`; `DSH_SSH_MANAGER_INSECURE_HOSTKEY=1` disables verification for emergency use only. Host certificates signed by a CA are not supported.
 
 ### Agent tool
 
@@ -96,16 +96,16 @@ Creating a host requires alias, hostname and password. The password is not writt
 
 ### From npm (recommended)
 
-npm package: [`dsh-ssh-manage`](https://www.npmjs.com/package/dsh-ssh-manage) (current version `0.2.2`).
+npm package: [`dsh-ssh-manage`](https://www.npmjs.com/package/dsh-ssh-manage) (current version `0.3.0`).
 
 ```text
-plugin_manager action=install_bundle target=dsh-ssh-manage@0.2.2
+plugin_manager action=install_bundle target=dsh-ssh-manage@0.3.0
 ```
 
 Or with the DSH CLI:
 
 ```bash
-dsh plugin add dsh-ssh-manage@0.2.2
+dsh plugin add dsh-ssh-manage@0.3.0
 ```
 
 After installation, refresh the Web page; the sidebar shows an "SSH Hosts" entry with id `dsh-ssh-manage`.
@@ -137,7 +137,7 @@ and make sure the package is resolvable by the profile (for example `link:` to t
 
 | | Requirement |
 | --- | --- |
-| **DSH** | **`>=0.2.2-rc.3 <0.3.0`** (validated on DSH Desktop `0.2.2-rc.3`) |
+| **DSH** | **`>=0.2.1-rc.3 <0.3.0`** (validated on DSH Desktop `0.2.1-rc.3`) |
 | **Node.js** | `>=20` (follows the DSH runtime) |
 | **Platform** | Validated on macOS; the test suite only uses Node built-ins and runs cross-platform |
 | **Network** | Reachable SSH port (22 by default, or the configured port) |
@@ -190,7 +190,7 @@ and make sure the package is resolvable by the profile (for example `link:` to t
 - `vault.json` uses AES-256-GCM with a key in the current user directory; `hosts.json` holds groups/tags/notes and other non-secret metadata.
 - All Host / PTY / static-asset routes require an authenticated DSH browser session; unauthenticated requests return 401.
 - Terminal traffic only flows between your browser and the target SSH host; no third-party service is involved.
-- `known_hosts` host-key verification is not implemented; only use it on trusted networks for sensitive input.
+- Host keys are verified against `~/.ssh/known_hosts` / `SSH_KNOWN_HOSTS`; unknown or changed keys are refused. This plugin only reads those files, not ssh_config `UserKnownHostsFile`/`GlobalKnownHostsFile`, and does not validate SSH CA host certificates — such hosts will be blocked until their key is added to the configured known_hosts file.
 
 ## Development
 
@@ -215,8 +215,8 @@ The terminal uses vendored xterm.js 6.0.0 (MIT, see `assets/LICENSE.xterm`) and
 
 ## Known limitations
 
-- **Host key verification** is not implemented; ssh2 accepts the server-provided key. Use trusted networks only.
-- **Session lifetime**: sessions are kept on the Host; switching to another DSH session, temporarily leaving the panel, or refreshing the page re-attaches to the existing shell and replays roughly the last 256 KB of output. Only closing the tab or exiting the Host process ends them; orphaned sessions are reaped after 6 hours of inactivity (max 16 sessions).
+- **Host key verification** uses `known_hosts`; hosts with no matching entry are refused with a fingerprint and path hint. No in-panel trust/import flow yet; custom `UserKnownHostsFile`/SSH CA setups need manual entry.
+- **Session lifetime**: sessions are kept on the Host; switching to another DSH session, temporarily leaving the panel, or refreshing the page re-attaches to the existing shell and replays roughly the last 256 KB of output. The browser sends a `/pty/touch` heartbeat every 60s while the page is open; a session with no output, input or heartbeat for 30 minutes is reaped (max 16 sessions).
 - **Password auth only**: IdentityFile / SSH agent / ProxyJump are not used for transport; those config fields are preserved but ignored. ProxyJump hosts fail with a clear error.
 - **Config editing scope**: the editor only changes `Host`, `HostName`, `User`, `Port` and plugin metadata; maintain other SSH directives in `~/.ssh/config`.
 - **Batch commands** run one command; they are not an interactive terminal. Per-host output is capped at 1 MB and marked `truncated` when exceeded.

package/README.md

@@ -44,7 +44,7 @@
 ### 交互式终端
 
 - 点「连接」打开真正的 PTY shell，不是一条命令一条命令地执行。
-- 多台主机以标签页常驻：切换到其它 DSH 会话再回来，终端会重新附着到原来的 shell，并回放最近约 256 KB 输出；关闭标签才结束会话。
+- 多台主机以标签页常驻：切换到其它 DSH 会话再回来，终端会重新附着到原来的 shell，并回放最近约 256 KB 输出；关闭标签、Host 退出，或 30 分钟无输出/输入/心跳才会结束会话。
 - xterm.js 6.0.0 渲染，支持 256 色、光标、滚动回看、选中复制、粘贴、窗口 resize。
 - 终端主题跟随 DSH 明暗主题；会话顶部有地址、密码状态、测试连接、文件、详情、清屏、关闭等快捷操作。
 - 输出走同源 HTTP/SSE 长连接，输入 / 尺寸 / 关闭走同源 HTTP POST；插件同时保留经过测试的 WebSocket 备用通道。
@@ -64,7 +64,7 @@
 - 密码密文与本地密钥位于同一用户目录，主要防止文件被直接误读，不能抵御同一用户下的恶意进程。
 - 主机分组、标签、收藏、备注、巡检结果保存在 `hosts.json`；密码保存在 `vault.json`；删除/修改配置前写入备份目录。
 
-> **主机密钥校验**：当前传输未接入 `known_hosts` 主机密钥校验，ssh2 默认接受服务器提供的主机密钥（与之前的单条命令执行一致）。**请在可信网络中使用交互式终端**，不要在不可信网络中输入 sudo 密码等敏感信息。
+> **主机密钥校验**：连接会按 `known_hosts` 校验主机密钥（默认 `~/.ssh/known_hosts`，可用 `SSH_KNOWN_HOSTS` 指向其它文件）。首次连接或服务器密钥变更时会拒绝连接，错误信息包含服务器 `SHA256:` 指纹、期望指纹和 known_hosts 路径；请先通过可信渠道核对指纹，再将该主机的 `[host]:port key-type base64-blob` 行写入 known_hosts（或使用 `ssh-keyscan` 后人工核对）。`DSH_SSH_MANAGER_INSECURE_HOSTKEY=1` 会完全关闭校验，仅限紧急排障，不要长期使用。
 
 ### Agent 工具
 
@@ -98,16 +98,16 @@
 
 ### 从 npm 安装（推荐）
 
-npm 包：[`dsh-ssh-manage`](https://www.npmjs.com/package/dsh-ssh-manage)（当前版本 `0.2.2`）。
+npm 包：[`dsh-ssh-manage`](https://www.npmjs.com/package/dsh-ssh-manage)（当前版本 `0.3.0`）。
 
 ```text
-plugin_manager action=install_bundle target=dsh-ssh-manage@0.2.2
+plugin_manager action=install_bundle target=dsh-ssh-manage@0.3.0
 ```
 
 或使用 DSH CLI：
 
 ```bash
-dsh plugin add dsh-ssh-manage@0.2.2
+dsh plugin add dsh-ssh-manage@0.3.0
 ```
 
 安装后刷新 Web 页面，左侧栏会出现「SSH 主机」入口，入口 id 为 `dsh-ssh-manage`。
@@ -139,7 +139,7 @@ plugin_manager action=install_bundle target=<仓库绝对路径>/dsh-ssh-manage
 
 | | 要求 |
 | --- | --- |
-| **DSH** | **`>=0.2.2-rc.3 <0.3.0`**（实机验证版本：DSH Desktop `0.2.2-rc.3`） |
+| **DSH** | **`>=0.2.1-rc.3 <0.3.0`**（实机验证版本：DSH Desktop `0.2.1-rc.3`） |
 | **Node.js** | `>=20`（跟随 DSH 内置运行时） |
 | **平台** | 实机验证 macOS；测试套件只依赖 Node 内置模块，可跨平台运行 |
 | **网络** | 需要能访问目标 SSH 主机的 22 端口（或配置的端口） |
@@ -178,7 +178,8 @@ plugin_manager action=install_bundle target=<仓库绝对路径>/dsh-ssh-manage
 | --- | --- |
 | `index.js` | Host 插件：HTTP/SSE/WS 路由、action 分发、PTY 会话、`ssh_manager` 工具。 |
 | `client.js` | 浏览器插件：侧边栏入口、管理页、xterm 终端；只 `require('react')`。 |
-| `lib/ssh-client.js` | ssh2 密码认证、PTY、exec、SFTP、巡检。 |
+| `lib/ssh-client.js` | ssh2 密码认证、PTY、exec、SFTP、巡检；known_hosts 主机密钥校验与 keepalive。 |
+| `lib/known-hosts.js` | `known_hosts` 解析与主机密钥校验（plain/bracket/wildcard/hashed/revoked，SHA256 指纹）。 |
 | `lib/ssh-config.js` | `~/.ssh/config` 解析、局部写入、备份、原子保存。 |
 | `lib/storage.js` / `lib/vault.js` / `lib/metadata.js` | 状态目录、AES-256-GCM 凭据仓库、主机元数据。 |
 | `lib/ws.js` | 无依赖 RFC6455 WebSocket 服务端（备用 PTY 通道）。 |
@@ -192,7 +193,7 @@ plugin_manager action=install_bundle target=<仓库绝对路径>/dsh-ssh-manage
 - 状态目录中的 `vault.json` 使用 AES-256-GCM 加密，密钥在当前用户目录；`hosts.json` 保存分组/标签/备注等非敏感元数据。
 - 所有 Host / PTY / 静态资源路由都要求 DSH 浏览器会话认证，未认证请求返回 401。
 - 终端输出仅在你自己的浏览器与目标 SSH 主机之间传输，不经过第三方服务。
-- 当前未实现 `known_hosts` 主机密钥校验；请只在可信网络输入敏感信息。
+- 连接按 OpenSSH `known_hosts` 校验主机密钥（默认 `~/.ssh/known_hosts`，可用 `SSH_KNOWN_HOSTS` 覆盖）；未知或变更的主机密钥会拒绝连接，并显示 `SHA256:` 指纹与 known_hosts 路径提示。`DSH_SSH_MANAGER_INSECURE_HOSTKEY=1` 仅限紧急排障时关闭校验。
 
 ## 开发
 
@@ -217,8 +218,8 @@ npm test
 
 ## 已知限制
 
-- **主机密钥校验**：未接入 `known_hosts`，ssh2 默认接受服务器主机密钥；仅在可信网络使用。
-- **会话生命周期**：终端会话由 Host 保留，切换 DSH 会话/暂时离开插件面板/刷新页面后会重新附着并回放最近约 256 KB 输出；只有关闭标签或 Host 进程退出才真正结束。Host 侧空闲超过 6 小时会清理孤儿会话（最大 16 个）。
+- **主机密钥校验**：依赖本机 `known_hosts`；首次连接需要先导入主机密钥（连接会失败并给出服务器 `SHA256:` 指纹、期望指纹与 known_hosts 路径）。只读取 `~/.ssh/known_hosts` / `SSH_KNOWN_HOSTS`，不读取 ssh_config 的 `UserKnownHostsFile`/`GlobalKnownHostsFile`，也不支持 SSH CA 主机证书。紧急情况下可设置 `DSH_SSH_MANAGER_INSECURE_HOSTKEY=1` 临时关闭校验。
+- **会话生命周期**：终端会话由 Host 保留，切换 DSH 会话/暂时离开插件面板/刷新页面后会重新附着并回放最近约 256 KB 输出；浏览器通过 `/pty/touch` 心跳续期，Host 侧超过 30 分钟无输出、输入或心跳的会话会作为孤儿清理（最大 16 个）。
 - **仅密码认证**：不支持 IdentityFile / SSH agent / ProxyJump 传输；配置中的这些字段会原样保留，但不会用于连接。ProxyJump 主机会明确报错。
 - **配置编辑范围**：编辑器只修改 `Host`、`HostName`、`User`、`Port` 与插件元数据；其它 SSH 指令请在 `~/.ssh/config` 中维护。
 - **批量命令**：一次执行一条命令，不等同于交互式终端；单台输出上限 1 MB，超出会标记 `truncated`。

package/client.js

@@ -18,6 +18,12 @@ window.__ModuleLoader__.load({
       'tabs.sessions': ['会话', 'Sessions'],
       'session.restoring': ['正在恢复终端会话…', 'Restoring terminal sessions…'],
       'session.tooMany': ['最多同时打开 16 个终端会话，请先关闭一个。', 'At most 16 terminal sessions can be open. Close one first.'],
+      'session.attention': ['有会话已结束或出错', 'A session exited or failed'],
+      'session.state.loading': ['加载中', 'Loading'],
+      'session.state.connecting': ['连接中', 'Connecting'],
+      'session.state.ready': ['运行中', 'Running'],
+      'session.state.closed': ['已结束', 'Exited'],
+      'session.state.error': ['错误', 'Error'],
       'tabs.batch': ['批量命令', 'Batch'],
       'tabs.settings': ['设置', 'Settings'],
       'session.new': ['新建连接', 'New connection'],
@@ -154,6 +160,7 @@ window.__ModuleLoader__.load({
       'terminal.reconnect': ['重新连接', 'Reconnect'],
       'terminal.openDetails': ['打开主机详情', 'Open details'],
       'terminal.assetsError': ['终端组件加载失败：{message}。如果刚更新插件，请重启 DSH 后重试。', 'Could not load the terminal component: {message}. If the plugin was just updated, restart DSH and retry.'],
+      'terminal.resyncFailed': ['终端输出曾中断，已尝试重新同步；如仍异常请重连。', 'Terminal output was interrupted; attempted a resync. Reconnect if problems persist.'],
       'terminal.backendHint': ['无法连接到插件后端。如果刚更新插件，请重启 DSH 后重试。', 'Cannot reach the plugin backend. If the plugin was just updated, restart DSH and retry.'],
       'terminal.passwordMissing': ['该主机还没有保存密码，请先打开「主机详情」设置服务器密码。', 'No password stored for this host. Open Details and set the server password first.'],
       'drawer.exit': ['退出码 {code}', 'exit {code}'],
@@ -1181,11 +1188,16 @@ window.__ModuleLoader__.load({
       const [activeSessionId, setActiveSessionId] = React.useState(() => persistentPanelState.activeSessionId)
       const [treeWidth, setTreeWidth] = React.useState(readTreeWidth)
       const [clearSignals, setClearSignals] = React.useState({})
+      const [sessionStates, setSessionStates] = React.useState({})
       const toastTimer = React.useRef(null)
       const floatingRef = React.useRef(null)
       const editorCloseGuard = React.useRef(null)
       const groupsCloseGuard = React.useRef(null)
 
+      const setSessionState = React.useCallback((id, status) => {
+        setSessionStates((prev) => (prev[id] === status ? prev : { ...prev, [id]: status }))
+      }, [])
+
       const notify = React.useCallback((message, tone = 'info') => {
         if (toastTimer.current) clearTimeout(toastTimer.current)
         setToastState({ message, tone })
@@ -1314,6 +1326,13 @@ window.__ModuleLoader__.load({
           for (const key of keys) if (ids.has(key)) next[key] = prev[key]
           return next
         })
+        setSessionStates((prev) => {
+          const keys = Object.keys(prev)
+          if (keys.every((key) => ids.has(key))) return prev
+          const next = {}
+          for (const key of keys) if (ids.has(key)) next[key] = prev[key]
+          return next
+        })
       }, [sessions])
 
       // Keep one valid active session, and leave the sessions tab when it becomes empty.
@@ -1700,6 +1719,8 @@ window.__ModuleLoader__.load({
         setTreeWidth,
         sessions,
         activeSessionId,
+        sessionStates,
+        setSessionState,
         setActiveSessionId,
         clearSignals,
         openSession,
@@ -1884,9 +1905,15 @@ window.__ModuleLoader__.load({
         ]
       }
 
+      const sessionAttention = sessions.some((session) => {
+        const state = sessionStates[session.id]
+        return state === 'error' || state === 'closed'
+      })
       const tabItems = [
         ['hosts', t('tabs.hosts')],
-        ...(sessions.length > 0 ? [['sessions', t('tabs.sessions')]] : []),
+        ...(sessions.length > 0
+          ? [['sessions', h('span', { className: 'ssh-tabLabel' }, t('tabs.sessions'), sessionAttention ? h('span', { className: 'ssh-tabAlert', title: t('session.attention') }) : null)]]
+          : []),
         ['batch', t('tabs.batch')],
         ['settings', t('tabs.settings')],
       ]
@@ -2669,6 +2696,7 @@ window.__ModuleLoader__.load({
         t,
         hosts,
         sessions,
+        sessionStates,
         activeSessionId,
         setActiveSessionId,
         setActiveAlias,
@@ -2732,6 +2760,10 @@ window.__ModuleLoader__.load({
                 h('span', {
                   className: cx('ssh-sessionDot', credential ? (credential.key === 'password' ? 'ok' : 'warn') : 'warn'),
                 }),
+                h('span', {
+                  className: cx('ssh-sessionState', sessionStates[session.id] ?? 'loading'),
+                  title: t(`session.state.${sessionStates[session.id] ?? 'loading'}`),
+                }),
                 h('span', { className: 'ssh-sessionTabTitle' }, host ? hostName(host) : session.hostAlias),
                 h(
                   'button',
@@ -3118,12 +3150,28 @@ window.__ModuleLoader__.load({
     const PTY_EVENTS_ROUTE = '/dsh-ssh-manage/pty/events'
     const PTY_ATTACH_ROUTE = '/dsh-ssh-manage/pty/attach'
     const PTY_CLEAR_ROUTE = '/dsh-ssh-manage/pty/clear'
+    const PTY_TOUCH_ROUTE = '/dsh-ssh-manage/pty/touch'
     const ptyStream = { source: null, ready: false, promise: null, listeners: new Map() }
     const ptyActiveIds = new Set()
     const ptyClosedIds = new Set()
     const MAX_TERMINAL_SESSIONS = 16
     const ptyStreamLostHandlers = new Set()
 
+    if (typeof window !== 'undefined') {
+      const heartbeat = setInterval(() => {
+        if (ptyActiveIds.size === 0) return
+        try {
+          void fetch(PTY_TOUCH_ROUTE, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ ids: [...ptyActiveIds] }),
+            keepalive: true,
+          }).catch(() => {})
+        } catch {}
+      }, 60_000)
+      heartbeat.unref?.()
+    }
+
     function closePtySession(id) {
       if (!id) return
       ptyClosedIds.add(id)
@@ -3286,7 +3334,13 @@ window.__ModuleLoader__.load({
       const [message, setMessage] = React.useState('')
       const [retryToken, setRetryToken] = React.useState(0)
       const clearRequested = React.useRef(false)
+      const reportStatus = model.setSessionState
+
+      React.useEffect(() => {
+        reportStatus?.(sessionId, status)
+      }, [reportStatus, sessionId, status])
       const syncedRef = React.useRef(false)
+      const clearEpochRef = React.useRef(0)
 
       React.useEffect(() => {
         activeRef.current = active === true
@@ -3303,6 +3357,7 @@ window.__ModuleLoader__.load({
 
       React.useEffect(() => {
         if (!clearSignal) return
+        clearEpochRef.current += 1
         // Only a clear issued before attach needs to survive into the attach
         // replay. A clear on a live, synced terminal is handled by the server
         // route directly and must not truncate the next attach replay.
@@ -3443,7 +3498,6 @@ window.__ModuleLoader__.load({
           sessionKey = sessionId
           const id = sessionKey
           let synced = false
-          let lastSeq = 0
           const pendingEvents = []
 
           const clearTerminal = () => {
@@ -3454,16 +3508,87 @@ window.__ModuleLoader__.load({
             } catch {}
           }
 
+          let resyncing = false
+          let resyncFailedAt = 0
+          let resyncAttempts = 0
+          let resyncGraceUntil = 0
+          const resyncQueue = []
+          let lastSeq = 0
+
           const applyOutput = (event) => {
             const seq = Number(event.seq)
             if (Number.isFinite(seq)) {
               if (seq <= lastSeq) return
-              lastSeq = seq
+              if (lastSeq > 0 && seq > lastSeq + 1) {
+                if (Date.now() < resyncGraceUntil) {
+                  lastSeq = seq
+                } else {
+                  resyncAttempts += 1
+                  if (resyncAttempts > 3) {
+                    resyncAttempts = 0
+                    resyncGraceUntil = Date.now() + 5_000
+                    lastSeq = seq
+                  } else {
+                    resyncQueue.push(event)
+                    void resync()
+                    return
+                  }
+                }
+              } else {
+                lastSeq = seq
+                resyncAttempts = 0
+              }
             }
             try { term.write(decodeBase64(event.data)) } catch {}
           }
 
+          const resync = async () => {
+            if (resyncing || stopped || finished || !sessionKey) return
+            const clearEpoch = clearEpochRef.current
+            resyncing = true
+            try {
+              const value = await ptyPost(PTY_ATTACH_ROUTE, {
+                id: sessionKey,
+                cols: term?.cols ?? 80,
+                rows: term?.rows ?? 24,
+              }, 15_000)
+              if (removed || stopped || finished) {
+                resyncing = false
+                return
+              }
+              if (clearEpochRef.current !== clearEpoch) {
+                clearRequested.current = false
+                clearTerminal()
+              } else if (value && value.output) {
+                try {
+                  term.reset()
+                  term.write(decodeBase64(value.output))
+                } catch {}
+              }
+              const seq = Number(value?.seq)
+              if (Number.isFinite(seq)) lastSeq = seq
+              resyncing = false
+              for (const event of resyncQueue.splice(0)) {
+                if (finished || stopped) break
+                handleEvent(event)
+              }
+            } catch {
+              resyncing = false
+              resyncFailedAt = Date.now()
+              resyncGraceUntil = Date.now() + 5_000
+              try { model.notify?.(t('terminal.resyncFailed'), 'error') } catch {}
+              for (const event of resyncQueue.splice(0)) {
+                if (finished || stopped) break
+                handleEvent(event)
+              }
+            }
+          }
+
           const handleEvent = (event) => {
+            if (resyncing) {
+              resyncQueue.push(event)
+              return
+            }
             if (event.kind === 'output') {
               if (!synced) pendingEvents.push(event)
               else applyOutput(event)
@@ -4823,6 +4948,12 @@ body.ssh-col-resizing,body.ssh-col-resizing *{cursor:col-resize!important;user-s
 .ssh-terminalOverlayBody{max-width:560px;font-size:11.5px;line-height:1.7;color:var(--ssh-text-3);word-break:break-word}
 .ssh-terminalOverlayActions{display:flex;gap:8px;flex-wrap:wrap;justify-content:center}
 .ssh-sessionLayer{flex:1;min-height:0;display:flex;flex-direction:column;background:var(--ssh-bg)}
+.ssh-sessionState{width:6px;height:6px;border-radius:50%;background:var(--ssh-dim);flex:0 0 auto}
+.ssh-sessionState.loading,.ssh-sessionState.connecting{background:var(--ssh-warn)}
+.ssh-sessionState.ready{background:var(--ssh-success)}
+.ssh-sessionState.error,.ssh-sessionState.closed{background:var(--ssh-danger)}
+.ssh-tabLabel{display:inline-flex;align-items:center;gap:5px}
+.ssh-tabAlert{display:inline-block;width:6px;height:6px;border-radius:50%;background:var(--ssh-danger);flex:0 0 auto}
 .ssh-sessions{flex:1;min-height:0;display:flex;flex-direction:column}
 .ssh-sessionBar{flex:0 0 auto;display:flex;align-items:center;gap:10px;padding:7px 12px;border-bottom:.5px solid var(--ssh-border);min-height:48px}
 .ssh-sessionTabs{flex:1;min-width:0;display:flex;align-items:center;gap:4px;overflow-x:auto;overflow-y:hidden;padding-bottom:1px}

package/index.js

@@ -18,9 +18,10 @@ const PTY_RESIZE_ROUTE = '/dsh-ssh-manage/pty/resize'
 const PTY_ATTACH_ROUTE = '/dsh-ssh-manage/pty/attach'
 const PTY_CLOSE_ROUTE = '/dsh-ssh-manage/pty/close'
 const PTY_CLEAR_ROUTE = '/dsh-ssh-manage/pty/clear'
+const PTY_TOUCH_ROUTE = '/dsh-ssh-manage/pty/touch'
 const MAX_PTY_SESSIONS = 16
 const PTY_BUFFER_BYTES = 256 * 1024
-const PTY_IDLE_MS = 6 * 60 * 60 * 1000
+const PTY_IDLE_MS = 30 * 60 * 1000
 const MAX_PTY_BUFFER_BYTES = 4 * 1024 * 1024
 const PACKAGE_DIRECTORY = path.dirname(fileURLToPath(import.meta.url))
 const ASSETS = [
@@ -552,18 +553,48 @@ function registerPtyHttpRoutes(ctx, paths, runtime) {
       label,
     )
   }
+
+  register(
+    {
+      kind: 'exact',
+      path: PTY_TOUCH_ROUTE,
+      handler: async (req, res) => {
+        if (rejectUnauthenticated(ctx, req, res)) return
+        if (req.method !== 'POST') {
+          res.statusCode = 405
+          res.setHeader('allow', 'POST')
+          res.end()
+          return
+        }
+        const body = (await readJsonBody(req)) ?? {}
+        const ids = Array.isArray(body.ids) ? body.ids.slice(0, 256) : []
+        const now = Date.now()
+        let touched = 0
+        for (const id of ids) {
+          if (typeof id !== 'string') continue
+          const entry = ptyTextSessions.get(id)
+          if (!entry) continue
+          entry.lastActivity = now
+          touched += 1
+        }
+        sendJson(res, 200, { ok: true, value: { touched } })
+      },
+    },
+    'pty touch route',
+  )
 }
 
-const ptyIdleTimer = setInterval(() => {
-  // An attached SSE client keeps its sessions alive even at a silent prompt;
-  // only reap orphans after every browser event stream has gone away.
-  if (ptyEventClients.size > 0) return
-  const now = Date.now()
-  for (const [id, entry] of ptyTextSessions) {
-    if (now - entry.lastActivity > PTY_IDLE_MS) closeTextSession(id)
+/** Close every PTY text session idle beyond PTY_IDLE_MS and return the number reaped. */
+function sweepIdlePtySessions(now = Date.now()) {
+  let reaped = 0
+  for (const [id, entry] of [...ptyTextSessions]) {
+    if (now - entry.lastActivity > PTY_IDLE_MS) {
+      closeTextSession(id)
+      reaped += 1
+    }
   }
-}, 60_000)
-ptyIdleTimer.unref?.()
+  return reaped
+}
 
 function boundedInteger(value, min, max, fallback) {
   const numeric = Number(value)
@@ -762,7 +793,7 @@ function registerAssetRoutes(ctx) {
   }
 }
 
-export const __test = { resolveSshPaths, listSshHosts, saveSshHost, deleteSshHost, runAction, managerTool, MAX_BODY_BYTES, PTY_ROUTE, PTY_EVENTS_ROUTE, PTY_OPEN_ROUTE, PTY_ATTACH_ROUTE, PTY_INPUT_ROUTE, PTY_RESIZE_ROUTE, PTY_CLOSE_ROUTE, PTY_CLEAR_ROUTE, MAX_PTY_SESSIONS, PTY_BUFFER_BYTES, ASSETS, handlePtyUpgrade, ptyTextSessions }
+export const __test = { resolveSshPaths, listSshHosts, saveSshHost, deleteSshHost, runAction, managerTool, MAX_BODY_BYTES, PTY_ROUTE, PTY_EVENTS_ROUTE, PTY_OPEN_ROUTE, PTY_ATTACH_ROUTE, PTY_INPUT_ROUTE, PTY_RESIZE_ROUTE, PTY_CLOSE_ROUTE, PTY_CLEAR_ROUTE, PTY_TOUCH_ROUTE, PTY_IDLE_MS, sweepIdlePtySessions, MAX_PTY_SESSIONS, PTY_BUFFER_BYTES, ASSETS, handlePtyUpgrade, ptyTextSessions }
 
 export const inject = ['webServer']
 
@@ -772,6 +803,14 @@ export function apply(ctx) {
   }
   const paths = resolveSshPaths(process.env)
   const runtime = createPtyRuntime()
+  const runtimeIdleTimer = setInterval(() => {
+    if (!runtime.active) return
+    // Browser heartbeats (/pty/touch) keep attached sessions alive, so a session
+    // left behind by a closed tab is reclaimed even while another tab retains
+    // an SSE stream. All liveness sources refresh lastActivity.
+    sweepIdlePtySessions()
+  }, 60_000)
+  runtimeIdleTimer.unref?.()
   ctx.effect(
     () =>
       ctx.webServer.register({
@@ -857,7 +896,7 @@ export function apply(ctx) {
         try { shutdown() } catch {}
       }
       runtime.upgrades.clear()
-      clearInterval(ptyIdleTimer)
+      clearInterval(runtimeIdleTimer)
       for (const session of ptySessions) {
         try { session.close() } catch {}
       }

package/lib/known-hosts.js

@@ -0,0 +1,136 @@
+import { createHash, createHmac, timingSafeEqual } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+
+/** Resolve the known_hosts file: SSH_KNOWN_HOSTS, else ~/.ssh/known_hosts. */
+export function knownHostsPath(env = process.env) {
+  return env.SSH_KNOWN_HOSTS || path.join(env.HOME || os.homedir(), '.ssh', 'known_hosts')
+}
+
+/** OpenSSH-style SHA256 fingerprint of a raw SSH public key blob. */
+export function keyFingerprint(key) {
+  const buffer = Buffer.isBuffer(key) ? key : Buffer.from(key ?? '')
+  return `SHA256:${createHash('sha256').update(buffer).digest('base64').replace(/=+$/, '')}`
+}
+
+/** Host token used by known_hosts: plain host on port 22, bracketed host:port otherwise. */
+export function hostKeyTarget(host) {
+  const hostname = String((host && (host.hostname || host.host)) || '')
+  const raw = Number((host && host.port) || 22)
+  const port = Number.isInteger(raw) && raw > 0 && raw <= 65535 ? raw : 22
+  return port === 22 ? hostname : `[${hostname}]:${port}`
+}
+
+function hashedPatternMatches(pattern, target) {
+  const parts = pattern.split('|')
+  if (parts.length !== 4 || parts[1] !== '1') return false
+  let salt
+  let expected
+  try {
+    salt = Buffer.from(parts[2], 'base64')
+    expected = Buffer.from(parts[3], 'base64')
+  } catch {
+    return false
+  }
+  if (salt.length === 0 || expected.length === 0) return false
+  const candidates = target === target.toLowerCase() ? [target] : [target, target.toLowerCase()]
+  return candidates.some((candidate) => {
+    const actual = createHmac('sha1', salt).update(candidate).digest()
+    return actual.length === expected.length && timingSafeEqual(actual, expected)
+  })
+}
+
+function globPatternMatches(pattern, target) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.')
+  return new RegExp(`^${escaped}$`, 'i').test(target)
+}
+
+/** Match one known_hosts host pattern against a target token (supports hashes, wildcards and negation). */
+export function matchHostPattern(pattern, target) {
+  const value = String(pattern ?? '').trim()
+  if (value === '') return false
+  if (value.startsWith('|1|')) return hashedPatternMatches(value, target)
+  if (value.includes('*') || value.includes('?')) return globPatternMatches(value, target)
+  return value.toLowerCase() === target.toLowerCase()
+}
+
+function patternsMatch(patterns, target) {
+  let matched = false
+  for (const raw of patterns) {
+    const pattern = String(raw ?? '').trim()
+    if (pattern === '') continue
+    const negated = pattern.startsWith('!')
+    const body = negated ? pattern.slice(1) : pattern
+    if (!matchHostPattern(body, target)) continue
+    if (negated) return false
+    matched = true
+  }
+  return matched
+}
+
+/** Parse a known_hosts file body into `{ marker, patterns, keyType, keyBlob }` entries. */
+export function parseKnownHosts(text = '') {
+  const entries = []
+  for (const raw of String(text).split(/\r?\n/)) {
+    const line = raw.trim()
+    if (line === '' || line.startsWith('#')) continue
+    const tokens = line.split(/\s+/)
+    let index = 0
+    let marker = null
+    if (tokens[0].startsWith('@')) {
+      marker = tokens[0].toLowerCase()
+      index = 1
+    }
+    const patternToken = tokens[index]
+    const keyType = tokens[index + 1]
+    const keyBlob = tokens[index + 2]
+    if (!patternToken || !keyType || !keyBlob) continue
+    entries.push({ marker, patterns: patternToken.split(','), keyType, keyBlob, line })
+  }
+  return entries
+}
+
+function sameBlob(knownHostsBlob, presented) {
+  const known = Buffer.from(String(knownHostsBlob), 'base64')
+  return known.length > 0 && known.equals(presented)
+}
+
+/**
+ * Synchronously verify a server host key (raw SSH public key blob) against known_hosts.
+ * Returns `{ ok: true, fingerprint, path, target }` or
+ * `{ ok: false, reason, fingerprint, path, target }`; mismatches also include `expected`.
+ */
+export function verifyHostKey(host, key, env = process.env) {
+  const keyBuffer = Buffer.isBuffer(key) ? key : Buffer.from(key ?? '')
+  const fingerprint = keyFingerprint(keyBuffer)
+  const target = hostKeyTarget(host)
+  const filePath = knownHostsPath(env)
+  let text
+  try {
+    text = readFileSync(filePath, 'utf8')
+  } catch (error) {
+    const reason = error?.code === 'ENOENT'
+      ? `known_hosts is missing at ${filePath}`
+      : `cannot read known_hosts at ${filePath}: ${error?.message ?? String(error)}`
+    return { ok: false, reason, fingerprint, path: filePath, target }
+  }
+  const entries = parseKnownHosts(text).filter((entry) => patternsMatch(entry.patterns, target))
+  const revoked = entries.find((entry) => entry.marker === '@revoked' && sameBlob(entry.keyBlob, keyBuffer))
+  if (revoked) return { ok: false, reason: `host key is revoked for ${target}`, fingerprint, path: filePath, target }
+  let hostMatched = false
+  let expected = ''
+  for (const entry of entries) {
+    if (entry.marker) continue
+    hostMatched = true
+    if (sameBlob(entry.keyBlob, keyBuffer)) return { ok: true, fingerprint, path: filePath, target }
+    if (expected === '') {
+      const blob = Buffer.from(entry.keyBlob, 'base64')
+      if (blob.length > 0) expected = keyFingerprint(blob)
+    }
+  }
+  if (hostMatched) return { ok: false, reason: `host key mismatch for ${target}`, fingerprint, expected, path: filePath, target }
+  return { ok: false, reason: `host key is not in known_hosts for ${target}`, fingerprint, path: filePath, target }
+}
+
+export const __test = { patternsMatch, globPatternMatches, hashedPatternMatches }

package/lib/ssh-client.js

@@ -1,4 +1,5 @@
 import { Client } from 'ssh2'
+import { verifyHostKey } from './known-hosts.js'
 
 const DEFAULT_TIMEOUT = 15_000
 const MAX_OUTPUT_BYTES = 1024 * 1024
@@ -13,14 +14,28 @@ const PROBE_COMMAND = [
   `printf 'SYS=%s\\nOS=%s\\nCORES=%s\\nMEM_MB=%s\\nDISK_MB=%s\\n' "$SYS" "$OS" "$CORES" "$MEM_MB" "$DISK_MB"`,
 ].join('\n')
 
-function connectionConfig(host, password) {
+function connectionConfig(host, password, verifyState = {}) {
+  const label = host.host || host.hostname || ''
   const config = {
     host: host.hostname || host.host,
     port: Number(host.port || 22),
     username: host.user || undefined,
     password,
     readyTimeout: DEFAULT_TIMEOUT,
+    keepaliveInterval: 15_000,
+    keepaliveCountMax: 3,
     tryKeyboard: true,
+    hostVerifier: (key) => {
+      // Emergency-only escape hatch: disables host-key verification entirely.
+      if (process.env.DSH_SSH_MANAGER_INSECURE_HOSTKEY === '1') return true
+      const result = verifyHostKey(host, key)
+      if (result.ok) return true
+      const expected = result.expected ? ` (expected ${result.expected})` : ''
+      verifyState.error = new Error(
+        `Host key verification failed for "${label}": ${result.reason}${expected} (fingerprint ${result.fingerprint}; known_hosts: ${result.path})`,
+      )
+      return false
+    },
   }
   if (host.proxyJump) throw new Error('ProxyJump is not supported by the plugin transport yet')
   return config
@@ -30,6 +45,7 @@ function connect(host, password, timeout = DEFAULT_TIMEOUT) {
   if (typeof password !== 'string' || password.length === 0) return Promise.reject(new Error('Password is required'))
   return new Promise((resolve, reject) => {
     const client = new Client()
+    const verifyState = {}
     let settled = false
     const timer = setTimeout(() => {
       if (settled) return
@@ -42,7 +58,8 @@ function connect(host, password, timeout = DEFAULT_TIMEOUT) {
       settled = true
       clearTimeout(timer)
       client.end()
-      reject(error instanceof Error ? error : new Error(String(error)))
+      const reported = verifyState.error ?? error
+      reject(reported instanceof Error ? reported : new Error(String(reported)))
     }
     client.once('ready', () => {
       if (settled) return
@@ -55,7 +72,7 @@ function connect(host, password, timeout = DEFAULT_TIMEOUT) {
     client.on('keyboard-interactive', (_name, _instructions, _language, prompts, finish) => {
       finish(prompts.map(() => password))
     })
-    try { client.connect(connectionConfig(host, password)) } catch (error) { fail(error) }
+    try { client.connect(connectionConfig(host, password, verifyState)) } catch (error) { fail(error) }
   })
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ssh-manage",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "A DSH sidebar plugin for managing SSH host profiles with a real interactive PTY terminal.",
   "license": "MIT",
   "private": false,