dsh-ssh-workbench 1.6.4 → 1.7.0

package/lib/core/{targets.js → mentions.js}

@@ -1,26 +1,18 @@
 /**
- * Per-session remote target binding.
+ * Per-session resource hints for the composer and the injected context.
  *
- * A session owns at most one *active* target: the managed server its native
- * `bash` tool runs on. `@name` mentions in a human message are the primary
- * input; the `ssh_workbench_target` tool switches the active target explicitly so a
- * conversation that mentions several servers stays unambiguous.
- *
- * State is process-local and keyed by Session id. It is a derived cache, not a
- * source of truth: the durable input is the human messages in the Session log,
- * which `replayTargets()` folds back in when a Session resumes.
+ * 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'
 
-/** Tool name the model calls to switch targets. */
-export const TARGET_TOOL_NAME = 'ssh_workbench_target'
-
-/** Source kind recorded on the injected target-context message. */
+/** Source kind recorded on the injected resource-context message. */
 export const TARGET_CONTEXT_KIND = 'ssh-workbench-target'
 
-/** The sentinel that detaches the session from any remote target. */
-export const LOCAL_TARGET = 'local'
-
 /** Concatenate the text blocks of one message. */
 export function extractUserText(message) {
   if (!message || message.role !== 'user' || !Array.isArray(message.content)) return ''
@@ -85,52 +77,47 @@ function sameList(left, right) {
   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: [], active: null, version: 0, injectedVersion: -1, notifiedVersion: -1, seeded: false }
+  return { candidates: [], lastHumanId: null, version: 0, injectedVersion: -1, seeded: false }
 }
 
-/**
- * Fold the mention rules over one session state.
- *
- * - one mention       → that server becomes the active target;
- * - several mentions  → candidates are remembered, active target is cleared;
- * - no mention        → state is unchanged (a follow-up keeps its target).
- */
+/** Remember the latest @mentions. No target is selected or cleared. */
 export function applyMentions(state, mentions) {
-  if (!Array.isArray(mentions) || mentions.length === 0) return state
-  const names = mentions.map((server) => server.name)
-  if (mentions.length === 1) {
-    if (state.active === names[0] && sameList(state.candidates, names)) return state
-    return { ...state, candidates: names, active: names[0], version: state.version + 1 }
-  }
-  // Several mentions never pick a target by guesswork; the model must call the
-  // selector tool. The previous active target is dropped for the same reason.
-  const active = null
-  if (active === state.active && sameList(state.candidates, names)) return state
-  return { ...state, candidates: names, active, version: state.version + 1 }
+  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 rules over a Session's historical messages. */
+/** 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
-      state = applyMentions(state, extractServerMentions(extractUserText(message), servers))
+      const mentions = extractServerMentions(extractUserText(message), servers)
+      if (mentions.length > 0) state = applyMentions(state, mentions)
     }
   }
   return state
 }
 
-/** Resolve one target reference against the inventory (name or id). */
+/** Resolve one resource reference against the inventory (name or id). */
 export function findTarget(servers, ref) {
-  const value = String(ref ?? '').trim()
-  if (!value) return undefined
-  return servers.find((server) => server.id === value || server.name === value)
+  return findServerRef(servers, ref)
 }
 
 /**
- * Create the per-session target store.
+ * Create the per-session resource-hint store.
  * @param {{ loadInventory?: () => object[] }} [options]
  */
 export function createTargetStore(options = {}) {
@@ -167,52 +154,42 @@ export function createTargetStore(options = {}) {
     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,
-      active: replayed.active,
-      version: replayed.version,
+      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
   }
 
-  function bindMentions(key, mentions) {
+  /**
+   * 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 next = { ...applyMentions(state, mentions), seeded: true }
-    if (next !== state) sessions.set(sessionKey(key), next)
-    return next
-  }
-
-  /** Switch the active target explicitly. `local` detaches. */
-  function setActive(key, ref, servers = loadInventory()) {
-    const state = ensure(key)
-    if (state === undefined) return { ok: false, error: 'session is not addressable' }
-    if (String(ref).trim().toLowerCase() === LOCAL_TARGET) {
-      // Detaching also clears any pending @a @b ambiguity, so bash is plainly
-      // local again instead of staying blocked on "choose a target".
-      const next = { ...state, active: null, candidates: [], version: state.version + 1, seeded: true }
-      sessions.set(sessionKey(key), next)
-      return { ok: true, state: next }
-    }
-    const server = findTarget(servers, ref)
-    if (server === undefined) {
-      return { ok: false, error: `unknown server "${String(ref)}"`, state }
-    }
-    if (server.enabled === false) {
-      return { ok: false, error: `server "${server.name}" is disabled`, state }
-    }
+    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,
-      active: server.name,
-      candidates: state.candidates.includes(server.name) ? state.candidates : [server.name],
+      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 { ok: true, state: next, server }
+    return next
   }
 
   function markInjected(key, version) {
@@ -222,17 +199,6 @@ export function createTargetStore(options = {}) {
     sessions.set(sessionKey(key), { ...state, injectedVersion: version })
   }
 
-  /**
-   * Remember that the bash router already showed the target to the model/UI
-   * (one stderr line after each target change), so it is not repeated per call.
-   */
-  function markNotified(key, version) {
-    const state = get(key)
-    if (state === undefined) return
-    if (state.notifiedVersion === version) return
-    sessions.set(sessionKey(key), { ...state, notifiedVersion: version })
-  }
-
   function clear(key) {
     const sessionId = sessionKey(key)
     if (sessionId !== undefined) sessions.delete(sessionId)
@@ -246,5 +212,5 @@ export function createTargetStore(options = {}) {
     return sessions.size
   }
 
-  return { get, ensure, ensureSeeded, bindMentions, setActive, markInjected, markNotified, clear, clearAll, size, loadInventory }
+  return { get, ensure, ensureSeeded, bindMentions, markInjected, clear, clearAll, size, loadInventory }
 }

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

@@ -10,7 +10,7 @@ import { prefsPath, readTextFile, writePrivateFile } from './paths.js'
 export const DEFAULT_PREFS = Object.freeze({ sidebar: true })
 
 /** Coerce a stored document into the current preference shape. */
-export function normalizePrefs(raw) {
+function normalizePrefs(raw) {
   const prefs = { ...DEFAULT_PREFS }
   if (!raw || typeof raw !== 'object') return prefs
   if (typeof raw.sidebar === 'boolean') prefs.sidebar = raw.sidebar