dsh-ssh-workbench 0.0.0-stage → 1.7.0

package/lib/core/known-hosts.js

@@ -0,0 +1,74 @@
+/**
+ * Plugin-local known_hosts with strict-by-default trust.
+ *
+ * ssh2 verifies the host key with `hostHash: 'sha256'`; the verifier receives
+ * the hex digest, so this store keeps `<address> sha256:<hex>` lines. Unknown
+ * hosts are rejected unless the user explicitly trusts the fingerprint.
+ */
+import { knownHostsPath, readTextFile, writePrivateFile } from './paths.js'
+
+function addressOf(server) {
+  return `${server.host}:${server.port}`
+}
+
+function normalizeFingerprint(fingerprint) {
+  const value = String(fingerprint ?? '').trim().toLowerCase()
+  if (!value) return ''
+  return value.startsWith('sha256:') ? value : `sha256:${value}`
+}
+
+function parse(text) {
+  const map = new Map()
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim()
+    if (!line || line.startsWith('#')) continue
+    const match = /^(\S+)\s+(sha256:[0-9a-f]+)$/i.exec(line)
+    if (match) map.set(match[1], match[2].toLowerCase())
+  }
+  return map
+}
+
+export function createKnownHosts({ file = knownHostsPath() } = {}) {
+  const load = () => parse(readTextFile(file))
+  const save = (map) => {
+    const lines = [...map.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([address, fp]) => `${address} ${fp}`)
+    writePrivateFile(file, `${lines.join('\n')}${lines.length ? '\n' : ''}`)
+  }
+  return {
+    addressOf,
+    /** `mode: 'strict'` rejects unknown hosts; `'accept-new'` records them (TOFU). */
+    verify(server, fingerprint, mode = 'strict') {
+      const address = addressOf(server)
+      const normalized = normalizeFingerprint(fingerprint)
+      if (!normalized) return false
+      const map = load()
+      const known = map.get(address)
+      if (known) return known === normalized
+      if (mode === 'accept-new') {
+        map.set(address, normalized)
+        save(map)
+        return true
+      }
+      return false
+    },
+    trust(server, fingerprint) {
+      const normalized = normalizeFingerprint(fingerprint)
+      if (!normalized) throw new Error('a fingerprint is required')
+      const map = load()
+      map.set(addressOf(server), normalized)
+      save(map)
+    },
+    revoke(server) {
+      const map = load()
+      const deleted = map.delete(addressOf(server))
+      save(map)
+      return deleted
+    },
+    list() {
+      return [...load().entries()].map(([address, fingerprint]) => ({ address, fingerprint }))
+    },
+    has(server) {
+      return load().has(addressOf(server))
+    },
+  }
+}

package/lib/core/live-executions.js

@@ -0,0 +1,101 @@
+/**
+ * In-flight remote executions, for the composer's "current target" indicator.
+ *
+ * This is a display-only projection. It never selects a target, never reaches
+ * a tool, and disappears as soon as the dispatch settles. Every remote tool is
+ * explicit-server, so this map is the only place where the UI can learn what a
+ * running tool is touching.
+ */
+import { sessionKeyOf } from './remote-shell-tool.js'
+import {
+  REMOTE_EDIT_TOOL_NAME,
+  REMOTE_GLOB_TOOL_NAME,
+  REMOTE_GREP_TOOL_NAME,
+  REMOTE_READ_TOOL_NAME,
+  REMOTE_WRITE_TOOL_NAME,
+} from './remote-file-tools.js'
+import { REMOTE_EXEC_TOOL_NAME } from './remote-exec-tool.js'
+
+const SINGLE_SERVER_TOOLS = new Set([
+  'remote_bash',
+  'remote_pwsh',
+  REMOTE_READ_TOOL_NAME,
+  REMOTE_WRITE_TOOL_NAME,
+  REMOTE_EDIT_TOOL_NAME,
+  REMOTE_GLOB_TOOL_NAME,
+  REMOTE_GREP_TOOL_NAME,
+])
+
+/** Extract the explicit server names a remote tool call will touch. */
+export function serversOf(exec) {
+  const name = exec?.name
+  const args = exec?.arguments
+  if (!name || !args || typeof args !== 'object') return []
+  if (name === REMOTE_EXEC_TOOL_NAME) {
+    const tasks = Array.isArray(args.tasks) ? args.tasks : []
+    const names = []
+    for (const task of tasks) {
+      if (task && typeof task.server === 'string' && task.server.length > 0 && !names.includes(task.server)) {
+        names.push(task.server)
+      }
+    }
+    return names
+  }
+  if (!SINGLE_SERVER_TOOLS.has(name)) return []
+  return typeof args.server === 'string' && args.server.length > 0 ? [args.server] : []
+}
+
+/** @param {{ now?: () => number }} [options] */
+export function createLiveExecutions(options = {}) {
+  const now = options.now ?? Date.now
+  let nextToken = 0
+  /** @type {Map<number, { sessionId: string, tool: string, servers: string[], startedAt: number }>} */
+  const active = new Map()
+
+  /** Register one dispatch; returns undefined when this is not a remote call. */
+  function begin(exec) {
+    const servers = serversOf(exec)
+    if (servers.length === 0) return undefined
+    const sessionId = sessionKeyOf(exec)
+    if (!sessionId) return undefined
+    const token = ++nextToken
+    active.set(token, {
+      sessionId,
+      tool: typeof exec.name === 'string' ? exec.name : '',
+      servers,
+      startedAt: now(),
+    })
+    return token
+  }
+
+  function end(token) {
+    if (token !== undefined) active.delete(token)
+  }
+
+  /** @returns {{ count: number, servers: { name: string, count: number, startedAt: number }[] }} */
+  function snapshot(sessionId) {
+    const byName = new Map()
+    let calls = 0
+    for (const entry of active.values()) {
+      if (entry.sessionId !== sessionId) continue
+      calls += 1
+      for (const name of entry.servers) {
+        const previous = byName.get(name)
+        byName.set(name, {
+          name,
+          count: (previous?.count ?? 0) + 1,
+          startedAt: previous ? Math.min(previous.startedAt, entry.startedAt) : entry.startedAt,
+        })
+      }
+    }
+    return { count: calls, servers: [...byName.values()] }
+  }
+
+  function clear(sessionId) {
+    for (const [token, entry] of active) {
+      if (sessionId === undefined || entry.sessionId === sessionId) active.delete(token)
+    }
+  }
+
+  return { begin, end, snapshot, clear, size: () => active.size }
+}

package/lib/core/local-file-api.js

@@ -0,0 +1,174 @@
+/**
+ * Local-filesystem implementation of the files-panel API.
+ *
+ * The workbench reuses the very same files component for remote SFTP and the
+ * local workspace. This adapter gives the local side the same method surface
+ * as the SSH runtime (`sftpHome`, `sftpList`, `sftpRead`, chunked open/read/
+ * write sessions, mkdir/remove/rename), so the panel and the file viewer stay
+ * provider-blind. Every path is resolved through the scoped local filesystem
+ * browser.
+ */
+import fsp from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
+
+export const LOCAL_FILE_REF = '__local__'
+
+const SYMLINK_WRITE_ERROR = 'refusing to write through a symlink'
+
+export function createLocalFileApi(localfs) {
+  const server = { id: LOCAL_FILE_REF, name: LOCAL_FILE_REF, platform: 'local' }
+  const sessions = new Map()
+
+  const sessionFor = (id, kind) => {
+    const session = sessions.get(id)
+    if (!session || session.kind !== kind) throw new Error('local transfer session not found')
+    return session
+  }
+
+  async function lstatOrNull(target) {
+    try {
+      return await fsp.lstat(target)
+    } catch (error) {
+      if (error && (error.code === 'ENOENT' || error.code === 'ENOTDIR')) return null
+      throw error
+    }
+  }
+
+  /**
+   * Open a local path for a transfer session.
+   *
+   * Write sessions resolve the path as a directory entry (parents followed and
+   * bounded by the root, final component not followed) and refuse to write
+   * through a final symlink, so an uploaded file cannot escape via a link.
+   * Read sessions keep follow semantics (a symlink inside the root is readable;
+   * one leaving the root is rejected by `localfs.resolve`).
+   */
+  async function openLocal(target, flags, { noFollowFinal = false } = {}) {
+    const resolved = noFollowFinal
+      ? await localfs.resolveEntry(target)
+      : await localfs.resolve(target)
+    if (noFollowFinal) {
+      const info = await lstatOrNull(resolved)
+      if (info && info.isSymbolicLink()) throw new Error(SYMLINK_WRITE_ERROR)
+    }
+    const handle = await fsp.open(resolved, flags)
+    return { resolved, handle }
+  }
+
+  /** Canonical local workspace root, mirroring the remote login home. */
+  async function sftpHome(_server) {
+    return await localfs.rootReal()
+  }
+
+  async function sftpList(_server, remotePath) {
+    const target = typeof remotePath === 'string' && remotePath.trim() ? remotePath : await localfs.rootReal()
+    const result = await localfs.list(target)
+    return result.entries
+  }
+
+  async function sftpRead(_server, remotePath, options = {}) {
+    const result = await localfs.read(remotePath, options.maxBytes)
+    const buffer = Buffer.from(result.base64, 'base64')
+    const binary = buffer.includes(0)
+    const formatted = {
+      path: result.path,
+      size: result.size,
+      bytesRead: buffer.length,
+      truncated: result.truncated,
+      binary,
+      content: binary ? undefined : buffer.toString('utf8'),
+    }
+    if (options.base64 === true) formatted.base64 = result.base64
+    return formatted
+  }
+
+  async function sftpOpenWrite(_server, remotePath, truncate = true) {
+    let opened
+    try {
+      opened = await openLocal(remotePath, truncate === false ? 'r+' : 'w', { noFollowFinal: true })
+    } catch (error) {
+      if (truncate === false && error && error.code === 'ENOENT') {
+        opened = await openLocal(remotePath, 'w', { noFollowFinal: true })
+      } else throw error
+    }
+    const id = `locw_${randomUUID()}`
+    sessions.set(id, { kind: 'write', path: opened.resolved, handle: opened.handle })
+    return { session: id, path: opened.resolved }
+  }
+
+  async function sftpWriteChunk(sessionId, offset, buffer) {
+    const session = sessionFor(sessionId, 'write')
+    await session.handle.write(buffer, 0, buffer.length, offset)
+    return { session: sessionId, bytes: buffer.length, offset }
+  }
+
+  async function sftpOpenRead(_server, remotePath) {
+    const opened = await openLocal(remotePath, 'r')
+    const info = await opened.handle.stat()
+    if (!info.isFile()) {
+      await opened.handle.close()
+      throw new Error('not a file')
+    }
+    const id = `locr_${randomUUID()}`
+    sessions.set(id, { kind: 'read', path: opened.resolved, handle: opened.handle, size: info.size })
+    return { session: id, path: opened.resolved, size: info.size }
+  }
+
+  async function sftpReadChunk(sessionId, offset, length) {
+    const session = sessionFor(sessionId, 'read')
+    const buffer = Buffer.alloc(length)
+    const { bytesRead } = await session.handle.read(buffer, 0, length, offset)
+    return { session: sessionId, bytesRead, base64: buffer.subarray(0, bytesRead).toString('base64') }
+  }
+
+  async function sftpCloseTransfer(sessionId) {
+    const session = sessions.get(sessionId)
+    // The server ref lets routes invalidate the local directory cache and log
+    // local activity under the right resource instead of "unknown" (B5/B8).
+    if (!session) return { session: sessionId, path: null, server: LOCAL_FILE_REF }
+    sessions.delete(sessionId)
+    let bytes
+    try {
+      if (session.kind === 'write') bytes = (await session.handle.stat()).size
+    } catch {
+      // A failed stat still closes the descriptor below.
+    }
+    await session.handle.close()
+    return { session: sessionId, path: session.path, bytes, server: LOCAL_FILE_REF }
+  }
+
+  async function sftpMkdir(_server, remotePath) {
+    return await localfs.mkdir(remotePath)
+  }
+
+  async function sftpRemove(_server, remotePath) {
+    return await localfs.remove(remotePath)
+  }
+
+  async function sftpRename(_server, fromPath, toPath) {
+    return await localfs.rename(fromPath, toPath)
+  }
+
+  async function dispose() {
+    for (const session of [...sessions.values()]) {
+      try { await session.handle.close() } catch { /* already closed */ }
+    }
+    sessions.clear()
+  }
+
+  return {
+    server,
+    sftpHome,
+    sftpList,
+    sftpRead,
+    sftpOpenWrite,
+    sftpWriteChunk,
+    sftpOpenRead,
+    sftpReadChunk,
+    sftpCloseTransfer,
+    sftpMkdir,
+    sftpRemove,
+    sftpRename,
+    dispose,
+  }
+}