dsh-ssh-workbench 0.0.0-stage → 1.7.0

package/lib/core/mentions.js

@@ -0,0 +1,216 @@
+/**
+ * Per-session resource hints for the composer and the injected context.
+ *
+ * Every remote tool call carries its own `server`, so this store only
+ * remembers which managed resources the human mentioned with `@name` in the
+ * current conversation. It is a hint for the model and the UI, never an
+ * execution binding. The durable input is still the Session log, which
+ * `replayTargets()` folds back in after a resume.
+ */
+import { loadServers } from './store.js'
+import { findServerRef } from './server-ref.js'
+
+/** Source kind recorded on the injected resource-context message. */
+export const TARGET_CONTEXT_KIND = 'ssh-workbench-target'
+
+/** Concatenate the text blocks of one message. */
+export function extractUserText(message) {
+  if (!message || message.role !== 'user' || !Array.isArray(message.content)) return ''
+  return message.content
+    .filter((block) => block && block.type === 'text' && typeof block.text === 'string')
+    .map((block) => block.text)
+    .join('\n')
+}
+
+/** Find the latest human-authored user message in a step's messages. */
+export function lastHumanMessage(messages) {
+  if (!Array.isArray(messages)) return undefined
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index]
+    if (message && message.role === 'user' && message.source?.kind === 'user') return message
+  }
+  return undefined
+}
+
+/**
+ * Match `@name` tokens against the managed inventory (name or id,
+ * case-insensitive). Returns matched server records in mention order, without
+ * duplicates. Unknown tokens are ignored.
+ */
+export function extractServerMentions(text, servers) {
+  if (typeof text !== 'string' || !Array.isArray(servers) || servers.length === 0) return []
+  const byAlias = new Map()
+  for (const server of servers) {
+    if (!server || typeof server.name !== 'string' || server.name.length === 0) continue
+    byAlias.set(server.name.toLowerCase(), server)
+    if (typeof server.id === 'string' && server.id.length > 0) byAlias.set(server.id.toLowerCase(), server)
+  }
+  // Match known aliases directly instead of a generic `@token` regex: a CJK
+  // server name is often followed immediately by CJK text (`@测试机看下磁盘`),
+  // so only the known name length tells us where the mention ends.
+  const aliases = [...byAlias.keys()].sort((left, right) => right.length - left.length)
+  const seen = new Set()
+  const matched = []
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] !== '@') continue
+    // Like an email address: `ops@example.com` is not a mention.
+    const previous = index > 0 ? text[index - 1] : ''
+    if (previous && /[A-Za-z0-9._-]/.test(previous)) continue
+    for (const alias of aliases) {
+      if (text.slice(index + 1, index + 1 + alias.length).toLowerCase() !== alias) continue
+      const tail = text[index + 1 + alias.length] ?? ''
+      // `@web-12` is a different token than `@web-1`; CJK continuation is fine.
+      if (tail && /[A-Za-z0-9._-]/.test(tail)) break
+      const server = byAlias.get(alias)
+      if (server && !seen.has(server.id ?? server.name)) {
+        seen.add(server.id ?? server.name)
+        matched.push(server)
+      }
+      break
+    }
+  }
+  return matched
+}
+
+function sameList(left, right) {
+  if (left.length !== right.length) return false
+  return left.every((value, index) => value === right[index])
+}
+
+function mentionNames(mentions) {
+  const names = []
+  for (const server of Array.isArray(mentions) ? mentions : []) {
+    const name = typeof server?.name === 'string' ? server.name : ''
+    if (name && !names.includes(name)) names.push(name)
+  }
+  return names
+}
+
+function freshState() {
+  return { candidates: [], lastHumanId: null, version: 0, injectedVersion: -1, seeded: false }
+}
+
+/** Remember the latest @mentions. No target is selected or cleared. */
+export function applyMentions(state, mentions) {
+  const names = mentionNames(mentions)
+  if (names.length === 0) return state
+  if (sameList(state.candidates, names)) return state
+  return { ...state, candidates: names, version: state.version + 1 }
+}
+
+/** Replay the mention hints over a Session's historical messages. */
+export function replayTargets(messages, servers) {
+  let state = freshState()
+  if (Array.isArray(messages)) {
+    for (const message of messages) {
+      if (message?.role !== 'user' || message.source?.kind !== 'user') continue
+      const mentions = extractServerMentions(extractUserText(message), servers)
+      if (mentions.length > 0) state = applyMentions(state, mentions)
+    }
+  }
+  return state
+}
+
+/** Resolve one resource reference against the inventory (name or id). */
+export function findTarget(servers, ref) {
+  return findServerRef(servers, ref)
+}
+
+/**
+ * Create the per-session resource-hint store.
+ * @param {{ loadInventory?: () => object[] }} [options]
+ */
+export function createTargetStore(options = {}) {
+  const loadInventory = options.loadInventory ?? loadServers
+  /** @type {Map<string, object>} */
+  const sessions = new Map()
+
+  function sessionKey(session) {
+    if (session === undefined || session === null) return undefined
+    if (typeof session === 'string') return session
+    const id = session.id
+    return typeof id === 'string' && id.length > 0 ? id : undefined
+  }
+
+  function get(key) {
+    const sessionId = sessionKey(key)
+    if (sessionId === undefined) return undefined
+    return sessions.get(sessionId)
+  }
+
+  function ensure(key) {
+    const sessionId = sessionKey(key)
+    if (sessionId === undefined) return undefined
+    let state = sessions.get(sessionId)
+    if (state === undefined) {
+      state = freshState()
+      sessions.set(sessionId, state)
+    }
+    return state
+  }
+
+  /** Seed one session once from its historical messages (resume support). */
+  function ensureSeeded(key, messages, servers = loadInventory()) {
+    const state = ensure(key)
+    if (state === undefined || state.seeded) return state
+    const replayed = replayTargets(messages, servers)
+    const history = Array.isArray(messages) ? messages : []
+    const lastHuman = [...history].reverse().find(
+      (message) => message?.role === 'user' && message.source?.kind === 'user',
+    )
+    const next = {
+      ...state,
+      candidates: replayed.candidates,
+      lastHumanId: typeof lastHuman?.id === 'string' ? lastHuman.id : state.lastHumanId,
+      version: replayed.candidates.length > 0 ? 1 : 0,
+      seeded: true,
+    }
+    sessions.set(sessionKey(key), next)
+    return next
+  }
+
+  /**
+   * Fold one human message into the hint state.
+   * A new human message always bumps `version` so the per-turn resource
+   * context is injected even when the message contains no @mention.
+   */
+  function bindMentions(key, mentions, humanId) {
+    const state = ensure(key)
+    if (state === undefined) return undefined
+    const newHuman = typeof humanId === 'string' && humanId.length > 0 && humanId !== state.lastHumanId
+    const names = mentionNames(mentions)
+    const changedMentions = names.length > 0 && !sameList(state.candidates, names)
+    if (!newHuman && !changedMentions) return state
+    const next = {
+      ...state,
+      candidates: names.length > 0 ? names : state.candidates,
+      lastHumanId: typeof humanId === 'string' && humanId.length > 0 ? humanId : state.lastHumanId,
+      version: state.version + 1,
+      seeded: true,
+    }
+    sessions.set(sessionKey(key), next)
+    return next
+  }
+
+  function markInjected(key, version) {
+    const state = get(key)
+    if (state === undefined) return
+    if (state.injectedVersion === version) return
+    sessions.set(sessionKey(key), { ...state, injectedVersion: version })
+  }
+
+  function clear(key) {
+    const sessionId = sessionKey(key)
+    if (sessionId !== undefined) sessions.delete(sessionId)
+  }
+
+  function clearAll() {
+    sessions.clear()
+  }
+
+  function size() {
+    return sessions.size
+  }
+
+  return { get, ensure, ensureSeeded, bindMentions, markInjected, clear, clearAll, size, loadInventory }
+}

package/lib/core/paths.js

@@ -0,0 +1,104 @@
+/**
+ * Filesystem layout for dsh-ssh-workbench.
+ *
+ * Everything the plugin persists lives under the harness home so a profile
+ * export/import carries it, and so tests can redirect it with DSH_SSH_WORKBENCH_DIR.
+ */
+import os from 'node:os'
+import path from 'node:path'
+import fs from 'node:fs'
+
+function dshHome() {
+  return process.env.DSH_HOME || path.join(os.homedir(), '.dsh')
+}
+
+/** New storage directory name, plus the pre-1.6.4 name for one-time migration. */
+const DIR_NAME = 'ssh-workbench'
+const LEGACY_DIR_NAME = 'ssh-ops'
+
+/**
+ * Directory that holds servers, credentials, known hosts and preferences.
+ *
+ * `DSH_SSH_WORKBENCH_DIR` wins in tests and for power users. Otherwise the
+ * plugin uses `$DSH_HOME/ssh-workbench` and, on the first launch after the
+ * 1.6.4 rename, moves an existing `$DSH_HOME/ssh-ops` directory into place so
+ * credentials and trusted host keys are not lost. If the move fails (for
+ * example because of permissions) the legacy directory stays in use.
+ */
+export function workbenchDir() {
+  const configured = process.env.DSH_SSH_WORKBENCH_DIR
+  if (configured) return configured
+  const current = path.join(dshHome(), DIR_NAME)
+  if (!fs.existsSync(current)) {
+    const legacy = path.join(dshHome(), LEGACY_DIR_NAME)
+    if (fs.existsSync(legacy)) {
+      try {
+        fs.renameSync(legacy, current)
+      } catch {
+        return legacy
+      }
+    }
+  }
+  return current
+}
+
+export function serversPath() {
+  return path.join(workbenchDir(), 'servers.json')
+}
+
+export function activityPath() {
+  return path.join(workbenchDir(), 'activity.json')
+}
+
+export function knownHostsPath() {
+  return path.join(workbenchDir(), 'known_hosts')
+}
+
+export function secretsPath() {
+  return path.join(workbenchDir(), 'secrets.json')
+}
+
+export function secretsKeyPath() {
+  return path.join(workbenchDir(), 'secrets.key')
+}
+
+export function prefsPath() {
+  return path.join(workbenchDir(), 'prefs.json')
+}
+
+/** Create a private directory (0700) if missing. */
+function ensurePrivateDir(dir = workbenchDir()) {
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+  try {
+    fs.chmodSync(dir, 0o700)
+  } catch {
+    // Windows cannot honour POSIX modes; the mkdir mode is best effort there.
+  }
+  return dir
+}
+
+/** Write a private file atomically (temp file + rename, 0600). */
+export function writePrivateFile(file, text) {
+  ensurePrivateDir(path.dirname(file))
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`
+  fs.writeFileSync(tmp, text, { mode: 0o600 })
+  try {
+    fs.chmodSync(tmp, 0o600)
+  } catch {
+    // best effort on Windows
+  }
+  fs.renameSync(tmp, file)
+  try {
+    fs.chmodSync(file, 0o600)
+  } catch {
+    // best effort on Windows
+  }
+}
+
+export function readTextFile(file, fallback = '') {
+  try {
+    return fs.readFileSync(file, 'utf8')
+  } catch {
+    return fallback
+  }
+}

package/lib/core/posix-quote.js

@@ -0,0 +1,4 @@
+/** POSIX single-quote escaping for a remote shell word. */
+export function quotePosix(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`
+}

package/lib/core/posix-shell.js

@@ -0,0 +1,89 @@
+/**
+ * Shared POSIX remote-shell helpers.
+ *
+ * Pure command construction used by `remote_bash` and `remote_exec`; the
+ * native local `bash` tool never reaches this module.
+ */
+import { quotePosix } from './posix-quote.js'
+
+const MIN_TIMEOUT_MS = 1000
+
+/**
+ * Wrap a remote command with the remote `timeout` utility.
+ *
+ * A client-side timeout only closes the SSH channel; a process that ignores
+ * SIGHUP (nohup/background) keeps running on the server. Wrapping the command
+ * gives the remote side the same deadline: coreutils `timeout` runs the
+ * managed command in its own process group and signals the whole group, so
+ * when the client gives up the remote work stops too. `kill` adds `-k <n>`
+ * (KILL after TERM); `basic` sends TERM only; `none` (or an unknown
+ * capability) leaves the command untouched.
+ *
+ * The wrapper re-enters the remote login shell (`<shell> -c`) so shell
+ * semantics do not change. The shell path comes from the capability probe and
+ * is referenced as a quoted literal, so this also works on fish/csh (no POSIX
+ * `${SHELL:-...}` expansion). The command itself is single-quote escaped and
+ * therefore expanded exactly once, inside that shell.
+ *
+ * @param {string} command
+ * @param {number} timeoutMs
+ * @param {'kill'|'basic'|'none'|{mode?: string, shell?: string}} [capability]
+ * @param {{ killAfterMs?: number }} [options]
+ */
+export function wrapRemoteTimeout(command, timeoutMs, capability = 'none', options = {}) {
+  const info = typeof capability === 'string' ? { mode: capability } : (capability ?? {})
+  const mode = info.mode === 'kill' || info.mode === 'basic' ? info.mode : 'none'
+  if (mode === 'none') return String(command ?? '')
+  const shell = typeof info.shell === 'string' && info.shell.startsWith('/') ? info.shell : '/bin/sh'
+  const killAfterMs = Number.isFinite(options.killAfterMs) ? options.killAfterMs : 5000
+  const killSeconds = Math.max(0, Math.ceil(killAfterMs / 1000))
+  const seconds = Math.max(1, Number(timeoutMs) / 1000)
+  const suffix = mode === 'kill' && killSeconds > 0 ? `-k ${killSeconds} ` : ''
+  return `timeout ${suffix}${seconds} ${quotePosix(shell)} -c ${quotePosix(command)}`
+}
+
+/**
+ * Turn the model-facing `workdir` into a shell prefix and the value's cwd label.
+ *
+ * The remote shell starts in the login home; absolute paths are used verbatim,
+ * `~`/`~/x` and relative paths are anchored at `$HOME`.
+ *
+ * @returns {{ command: string, cwd: string } | { error: string }}
+ */
+export function applyWorkdir(command, workdir) {
+  const raw = typeof workdir === 'string' ? workdir.trim() : ''
+  const body = String(command ?? '')
+  if (!raw) return { command: body, cwd: '~' }
+  if (raw.includes('\n') || raw.includes('\r')) return { error: 'workdir must not contain newlines' }
+  if (raw.startsWith('~')) {
+    const rest = raw === '~' ? '' : raw.slice(1)
+    if (rest !== '' && !rest.startsWith('/')) return { error: 'workdir must be an absolute path, ~/path, or a relative path' }
+    const target = rest === '' ? '"$HOME"' : `"$HOME"${quotePosix(rest)}`
+    return { command: `cd -- ${target} && ${body}`, cwd: raw }
+  }
+  if (raw.startsWith('/')) {
+    return { command: `cd -- ${quotePosix(raw)} && ${body}`, cwd: raw }
+  }
+  return { command: `cd -- "$HOME"/${quotePosix(raw)} && ${body}`, cwd: `~/${raw}` }
+}
+
+/** Effective timeout for one call, clamped to the configured ceiling. */
+export function resolveTimeoutMs(args, config) {
+  const ceiling = Number.isInteger(config?.maxCommandTimeoutMs) ? config.maxCommandTimeoutMs : 30 * 60 * 1000
+  const requested = Number.isInteger(args?.timeoutMs) ? args.timeoutMs : undefined
+  const fallback = Number.isInteger(config?.commandTimeoutMs) ? config.commandTimeoutMs : 120000
+  const value = requested ?? fallback
+  return Math.max(MIN_TIMEOUT_MS, Math.min(value, ceiling))
+}
+
+/**
+ * Whether a runtime result means the command never reached the remote shell.
+ * Timeouts and aborts are real command outcomes (timedOut / aborted on the
+ * native value), not transport failures.
+ */
+export function isTransportFailure(result) {
+  if (!result || typeof result !== 'object') return true
+  if (result.exitCode !== null && result.exitCode !== undefined) return false
+  if (typeof result.signal === 'string' && result.signal.length > 0) return false
+  return result.outcome === 'failed'
+}

package/lib/core/prefs.js

@@ -0,0 +1,38 @@
+/**
+ * Small user-visible UI preferences that are not part of the server inventory.
+ *
+ * Kept in the same private data directory as the inventory so a profile export
+ * carries them, and so the plugin manager's sidebar switch can change them
+ * without rewriting the profile's cordis.patch.yml.
+ */
+import { prefsPath, readTextFile, writePrivateFile } from './paths.js'
+
+export const DEFAULT_PREFS = Object.freeze({ sidebar: true })
+
+/** Coerce a stored document into the current preference shape. */
+function normalizePrefs(raw) {
+  const prefs = { ...DEFAULT_PREFS }
+  if (!raw || typeof raw !== 'object') return prefs
+  if (typeof raw.sidebar === 'boolean') prefs.sidebar = raw.sidebar
+  return prefs
+}
+
+export function loadPrefs() {
+  const text = readTextFile(prefsPath(), '')
+  if (!text.trim()) return { ...DEFAULT_PREFS }
+  try {
+    return normalizePrefs(JSON.parse(text))
+  } catch {
+    // A corrupt preferences file must never make the plugin unusable; fall
+    // back to the defaults and let the next save rewrite it.
+    return { ...DEFAULT_PREFS }
+  }
+}
+
+/** Merge one patch into the stored preferences and persist the result. */
+export function savePrefs(patch) {
+  if (!patch || typeof patch !== 'object') throw new Error('prefs patch must be an object')
+  const next = normalizePrefs({ ...loadPrefs(), ...patch })
+  writePrivateFile(prefsPath(), `${JSON.stringify(next, null, 2)}\n`)
+  return next
+}