dsh-ssh-manage 0.2.1 → 0.3.0

package/index.js

@@ -17,9 +17,11 @@ const PTY_INPUT_ROUTE = '/dsh-ssh-manage/pty/input'
 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 = [
@@ -75,14 +77,26 @@ function errorMessage(error) {
 }
 
 async function state(paths) {
-  const [current, metadata, passwords] = await Promise.all([listSshHosts(paths), loadMetadata(paths), listPasswordAliases(paths)])
+  const [current, metadataResult, passwordsResult] = await Promise.all([
+    listSshHosts(paths),
+    loadMetadata(paths).then((value) => ({ value }), (error) => ({ error })),
+    listPasswordAliases(paths).then((value) => ({ value }), (error) => ({ error })),
+  ])
+  const warnings = []
+  let entries = {}
+  if ('error' in metadataResult) warnings.push({ store: 'metadata', message: errorMessage(metadataResult.error) })
+  else entries = metadataResult.value.entries
+  let passwords = []
+  if ('error' in passwordsResult) warnings.push({ store: 'vault', message: errorMessage(passwordsResult.error) })
+  else passwords = passwordsResult.value
   const passwordSet = new Set(passwords)
   const stateDir = storagePaths(paths).stateDir
   return {
     ...current,
     stateDir,
     backupDir: paths.backupDir || path.join(stateDir, 'backups'),
-    hosts: current.hosts.map((host) => ({ ...host, ...(metadata.entries[host.host] || {}), passwordConfigured: passwordSet.has(host.host) })),
+    hosts: current.hosts.map((host) => ({ ...host, ...(entries[host.host] || {}), passwordConfigured: passwordSet.has(host.host) })),
+    warnings,
   }
 }
 
@@ -282,6 +296,16 @@ const ptyPendingIds = new Set()
 const ptyEventClients = new Set()
 let ptyOpening = 0
 
+function createPtyRuntime() {
+  return { generation: 0, active: true, upgrades: new Set() }
+}
+
+const defaultPtyRuntime = createPtyRuntime()
+
+function isPtyRuntimeActive(runtime, generation) {
+  return runtime.active && runtime.generation === generation
+}
+
 function closeTextSession(id, notify = true) {
   const entry = ptyTextSessions.get(id)
   if (!entry) return
@@ -311,15 +335,17 @@ function broadcastPty(event) {
   for (const client of [...ptyEventClients]) writePtyEvent(client, event)
 }
 
-async function openTextSession(paths, payload) {
+async function openTextSession(paths, payload, runtime = defaultPtyRuntime) {
+  if (!runtime.active) throw new Error('Terminal runtime is not active')
   const id = typeof payload?.id === 'string' ? payload.id.trim() : ''
   if (!/^[A-Za-z0-9_-]{8,80}$/.test(id)) throw new Error('A valid session id is required')
+  const cols = boundedInteger(payload?.cols, 20, 500, 120)
+  const rows = boundedInteger(payload?.rows, 5, 300, 32)
+  const alias = typeof payload?.host === 'string' ? payload.host.trim() : ''
+  if (alias === '') throw new Error('host is required')
   if (ptyTextSessions.has(id) || ptyPendingIds.has(id)) throw new Error('Terminal session already exists')
+  const generation = runtime.generation
   ptyPendingIds.add(id)
-  const cols = boundedInteger(payload.cols, 20, 500, 120)
-  const rows = boundedInteger(payload.rows, 5, 300, 32)
-  const alias = typeof payload.host === 'string' ? payload.host.trim() : ''
-  if (alias === '') throw new Error('host is required')
   ptyOpening += 1
   try {
     if (ptySessions.size + ptyTextSessions.size + ptyOpening > MAX_PTY_SESSIONS) {
@@ -327,7 +353,12 @@ async function openTextSession(paths, payload) {
     }
     const host = await findHost(paths, alias)
     const password = await requirePassword(paths, host)
+    if (!isPtyRuntimeActive(runtime, generation)) throw new Error('Terminal runtime is not active')
     const session = await openPty(host, password, { cols, rows })
+    if (!isPtyRuntimeActive(runtime, generation)) {
+      try { session.close() } catch {}
+      throw new Error('Terminal runtime is not active')
+    }
     if (ptyTextSessions.has(id)) {
       try { session.close() } catch {}
       throw new Error('Terminal session already exists')
@@ -363,7 +394,7 @@ async function openTextSession(paths, payload) {
   }
 }
 
-function registerPtyHttpRoutes(ctx, paths) {
+function registerPtyHttpRoutes(ctx, paths, runtime) {
   const register = (route, label) => {
     ctx.effect(() => ctx.webServer.register(route), `dsh-ssh-manage: ${label}`)
   }
@@ -423,7 +454,7 @@ function registerPtyHttpRoutes(ctx, paths) {
         }
         const body = await readJsonBody(req)
         try {
-          const value = await openTextSession(paths, body ?? {})
+          const value = await openTextSession(paths, body ?? {}, runtime)
           sendJson(res, 200, { ok: true, value })
         } catch (error) {
           sendJson(res, 200, { ok: false, error: { code: 'pty-open-failed', message: errorMessage(error) } })
@@ -473,6 +504,7 @@ function registerPtyHttpRoutes(ctx, paths) {
     [PTY_INPUT_ROUTE, 'input', 'pty input route'],
     [PTY_RESIZE_ROUTE, 'resize', 'pty resize route'],
     [PTY_CLOSE_ROUTE, 'close', 'pty close route'],
+    [PTY_CLEAR_ROUTE, 'clear', 'pty clear route'],
   ]) {
     register(
       {
@@ -504,6 +536,10 @@ function registerPtyHttpRoutes(ctx, paths) {
                 0,
                 0,
               )
+            } else if (action === 'clear') {
+              entry.buffer = []
+              entry.bufferBytes = 0
+              broadcastPty({ kind: 'clear', id })
             } else {
               closeTextSession(id)
             }
@@ -517,18 +553,48 @@ function registerPtyHttpRoutes(ctx, paths) {
       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)
@@ -554,7 +620,11 @@ function upgradeRejection(ctx, req) {
   return rejection === undefined ? undefined : rejection
 }
 
-async function handlePtyUpgrade(ctx, paths, req, socket, head) {
+async function handlePtyUpgrade(ctx, paths, req, socket, head, runtime = defaultPtyRuntime) {
+  if (!runtime.active) {
+    denyUpgrade(socket, 403)
+    return
+  }
   if (!isWebSocketUpgrade(req)) {
     try { socket.write('HTTP/1.1 400 Bad Request\r\nConnection: close\r\nContent-Length: 0\r\n\r\n') } catch {}
     socket.destroy()
@@ -567,22 +637,30 @@ async function handlePtyUpgrade(ctx, paths, req, socket, head) {
   }
   const ws = acceptWebSocket(req, socket, head)
   if (!ws) return
+  const generation = runtime.generation
   let session = null
   let opening = false
   let cleaned = false
   let paused = false
+  let shutdown = null
   const keepalive = setInterval(() => ws.ping(), 25_000)
   keepalive.unref?.()
   const cleanup = () => {
     if (cleaned) return
     cleaned = true
     clearInterval(keepalive)
+    if (shutdown) runtime.upgrades.delete(shutdown)
     if (session) {
       ptySessions.delete(session)
       try { session.close() } catch {}
       session = null
     }
   }
+  shutdown = () => {
+    cleanup()
+    try { ws.close(1001) } catch {}
+  }
+  runtime.upgrades.add(shutdown)
   ws.on('close', cleanup)
   socket.on('drain', () => {
     if (!paused || !session) return
@@ -599,7 +677,7 @@ async function handlePtyUpgrade(ctx, paths, req, socket, head) {
     }
     if (!message || typeof message.type !== 'string' || cleaned) return
     if (!session) {
-      if (message.type !== 'open' || opening) return
+      if (message.type !== 'open' || opening || !runtime.active) return
       opening = true
       ptyOpening += 1
       try {
@@ -610,8 +688,9 @@ async function handlePtyUpgrade(ctx, paths, req, socket, head) {
         const rows = boundedInteger(message.rows, 5, 300, 32)
         const host = await findHost(paths, alias)
         const password = await requirePassword(paths, host)
+        if (!isPtyRuntimeActive(runtime, generation)) throw new Error('Terminal runtime is not active')
         session = await openPty(host, password, { cols, rows })
-        if (cleaned) {
+        if (cleaned || !isPtyRuntimeActive(runtime, generation)) {
           try { session.close() } catch {}
           session = null
           return
@@ -714,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, 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']
 
@@ -723,6 +802,15 @@ export function apply(ctx) {
     throw new Error('dsh-ssh-manage requires DeepSeek Harness >=0.2.1-rc.3: ctx.webServer.register is unavailable.')
   }
   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({
@@ -772,7 +860,7 @@ export function apply(ctx) {
       }),
     'dsh-ssh-manage: action route',
   )
-  registerPtyHttpRoutes(ctx, paths)
+  registerPtyHttpRoutes(ctx, paths, runtime)
   registerAssetRoutes(ctx)
   if (typeof ctx.webServer.tapIndex === 'function') {
     const tags = [
@@ -793,7 +881,7 @@ export function apply(ctx) {
       ctx.webServer.registerUpgrade({
         path: PTY_ROUTE,
         handler: (req, socket, head) => {
-          void handlePtyUpgrade(ctx, paths, req, socket, head).catch(() => {
+          void handlePtyUpgrade(ctx, paths, req, socket, head, runtime).catch(() => {
             try { socket.destroy() } catch {}
           })
         },
@@ -802,7 +890,13 @@ export function apply(ctx) {
   )
   ctx.effect(
     () => () => {
-      clearInterval(ptyIdleTimer)
+      runtime.active = false
+      runtime.generation += 1
+      for (const shutdown of [...runtime.upgrades]) {
+        try { shutdown() } catch {}
+      }
+      runtime.upgrades.clear()
+      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/metadata.js

@@ -1,5 +1,4 @@
-import * as fs from 'node:fs/promises'
-import { atomicWriteFile, readJson, storagePaths } from './storage.js'
+import { atomicWriteFile, readJson, storagePaths, withStoreLock } from './storage.js'
 
 function clean(value, max = 80) {
   return String(value ?? '').trim().slice(0, max)
@@ -27,7 +26,12 @@ function normalizeEntry(alias, input = {}) {
   }
 }
 
-export async function loadMetadata(paths) {
+function metadataLockKey(paths) {
+  return `metadata:${storagePaths(paths).stateDir}`
+}
+
+/** Read the metadata store without taking the store lock; mutators hold it. */
+async function loadMetadataUnlocked(paths) {
   const resolved = storagePaths(paths)
   const value = await readJson(resolved.metadataPath, {})
   if (!value || typeof value !== 'object' || Array.isArray(value)) return { paths: resolved, entries: {} }
@@ -35,24 +39,37 @@ export async function loadMetadata(paths) {
   return { paths: resolved, entries }
 }
 
-export async function saveMetadata(paths, entries) {
+/** Write the metadata store without taking the store lock; mutators hold it. */
+async function saveMetadataUnlocked(paths, entries) {
   const resolved = storagePaths(paths)
   const normalized = Object.fromEntries(Object.entries(entries || {}).map(([alias, data]) => [alias, normalizeEntry(alias, data)]))
   await atomicWriteFile(resolved.metadataPath, `${JSON.stringify(normalized, null, 2)}\n`, 0o600)
   return { saved: true }
 }
 
+export async function loadMetadata(paths) {
+  return loadMetadataUnlocked(paths)
+}
+
+export async function saveMetadata(paths, entries) {
+  return withStoreLock(metadataLockKey(paths), () => saveMetadataUnlocked(paths, entries))
+}
+
 export async function updateMetadata(paths, alias, data) {
-  const current = await loadMetadata(paths)
-  current.entries[alias] = normalizeEntry(alias, { ...current.entries[alias], ...data })
-  await saveMetadata(current.paths, current.entries)
-  return current.entries[alias]
+  return withStoreLock(metadataLockKey(paths), async () => {
+    const current = await loadMetadataUnlocked(paths)
+    current.entries[alias] = normalizeEntry(alias, { ...current.entries[alias], ...data })
+    await saveMetadataUnlocked(current.paths, current.entries)
+    return current.entries[alias]
+  })
 }
 
 export async function deleteMetadata(paths, alias) {
-  const current = await loadMetadata(paths)
-  delete current.entries[alias]
-  await saveMetadata(current.paths, current.entries)
+  return withStoreLock(metadataLockKey(paths), async () => {
+    const current = await loadMetadataUnlocked(paths)
+    delete current.entries[alias]
+    await saveMetadataUnlocked(current.paths, current.entries)
+  })
 }
 
 export const __test = { normalizeEntry }

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/lib/ssh-config.js

@@ -2,6 +2,7 @@ import { randomBytes } from 'node:crypto'
 import * as fs from 'node:fs/promises'
 import os from 'node:os'
 import path from 'node:path'
+import { withStoreLock } from './storage.js'
 
 const HOST_RE = /^[A-Za-z0-9][A-Za-z0-9_.@-]{0,63}$/
 const OPTION_NAMES = new Map([
@@ -246,13 +247,15 @@ export async function listSshHosts(paths = resolveSshPaths()) {
   return { configPath: paths.configPath, hosts: parsed.hosts, exists: text.length > 0 }
 }
 
-export async function saveSshHost({ paths = resolveSshPaths(), host, originalHost } = {}) {
+async function saveSshHostUnlocked({ paths, host, originalHost }) {
   const nextHost = validateHost(host)
   const aliasesProvided = Array.isArray(host?.aliases) && host.aliases.filter(Boolean).length > 0
   const previous = originalHost ? String(originalHost).trim() : null
+  if (previous !== null && (!HOST_RE.test(previous) || isWildPattern(previous))) throw new Error('Invalid SSH host alias')
   const text = await readConfig(paths)
   const parsed = parseSshConfig(text)
   const block = previous ? blockForHost(parsed, previous) : null
+  if (previous !== null && !block) throw new Error(`SSH host "${previous}" was not found`)
   const collision = blockForHost(parsed, nextHost.host)
   if (collision && (!block || collision.start !== block.start)) throw new Error(`SSH host "${nextHost.host}" already exists`)
   let lines = parsed.lines
@@ -274,7 +277,12 @@ export async function saveSshHost({ paths = resolveSshPaths(), host, originalHos
   return { saved: true, host: nextHost, backup }
 }
 
-export async function deleteSshHost({ paths = resolveSshPaths(), host } = {}) {
+export async function saveSshHost(options = {}) {
+  const paths = options?.paths ?? resolveSshPaths()
+  return withStoreLock(`config:${paths.configPath}`, () => saveSshHostUnlocked({ ...options, paths }))
+}
+
+async function deleteSshHostUnlocked({ paths, host }) {
   const name = String(host ?? '').trim()
   if (!HOST_RE.test(name) || isWildPattern(name)) throw new Error('Invalid SSH host alias')
   const text = await readConfig(paths)
@@ -289,4 +297,9 @@ export async function deleteSshHost({ paths = resolveSshPaths(), host } = {}) {
   return { removed: true, backup }
 }
 
+export async function deleteSshHost(options = {}) {
+  const paths = options?.paths ?? resolveSshPaths()
+  return withStoreLock(`config:${paths.configPath}`, () => deleteSshHostUnlocked({ ...options, paths }))
+}
+
 export const __test = { patchHostBlock }