dsh-ssh-workbench 1.6.4 → 1.7.8

package/lib/core/activity.js

@@ -63,6 +63,11 @@ export function createActivityStore({ file = activityPath(), maxEntries = MAX_AC
       ...(entry?.server !== undefined ? { server: String(entry.server) } : {}),
       ...(entry?.summary !== undefined ? { summary: String(entry.summary) } : {}),
       ...(entry?.outcome !== undefined ? { outcome: String(entry.outcome) } : {}),
+      // Session/duration let the composer dock summarize this session's remote
+      // executions without reading DSH's private session metrics. Absent on
+      // older entries; readers must tolerate that.
+      ...(typeof entry?.sessionId === 'string' && entry.sessionId.length > 0 ? { sessionId: entry.sessionId } : {}),
+      ...(Number.isFinite(entry?.durationMs) && entry.durationMs >= 0 ? { durationMs: Math.round(entry.durationMs) } : {}),
     }
     const next = [normalized, ...load()].slice(0, maxEntries)
     save(next)

package/lib/core/background.js

@@ -39,10 +39,17 @@ export function parseBackgroundStart(stdout) {
  * `nohup` + redirected stdio is what keeps the child alive after the SSH
  * channel closes; the whole launcher runs under `sh -c` so a fish/csh login
  * shell only has to parse the simple outer command.
+ *
+ * Logs default to `~/.dsh/ssh-workbench/logs` instead of `/tmp`, because a
+ * detached process may outlive the tmp cleanup window; `DSH_SSH_WORKBENCH_LOG_DIR`
+ * overrides the directory remotely, and `/tmp` stays as the fallback when the
+ * home directory is not writable.
  */
 export function buildPosixBackgroundCommand(builtCommand) {
   const script = [
-    'LOG=$(mktemp /tmp/dsh-ssh-workbench-bg.XXXXXX 2>/dev/null || echo /tmp/dsh-ssh-workbench-bg-$$-$(date +%s).log)',
+    'LOG_DIR=${DSH_SSH_WORKBENCH_LOG_DIR:-$HOME/.dsh/ssh-workbench/logs}',
+    'mkdir -p "$LOG_DIR" 2>/dev/null || LOG_DIR=/tmp',
+    'LOG=$(mktemp "$LOG_DIR/dsh-ssh-workbench-bg.XXXXXX" 2>/dev/null || echo "$LOG_DIR/dsh-ssh-workbench-bg-$$-$(date +%s).log")',
     `nohup "\${SHELL:-/bin/sh}" -lc ${quotePosix(builtCommand)} >"$LOG" 2>&1 &`,
     `echo "${BG_PID_MARKER}$!"`,
     `echo "${BG_LOG_MARKER}$LOG"`,
@@ -50,10 +57,10 @@ export function buildPosixBackgroundCommand(builtCommand) {
   return `sh -c ${quotePosix(script)}`
 }
 
-/** One model-facing description of a started background process. */
-export function renderBackgroundStart({ pid, log, errLog, target, command, dialect = 'posix' }) {
+/** The pid/log/stop lines shared by every background result renderer. */
+export function renderBackgroundDetails({ pid, log, errLog, dialect = 'posix' }) {
   const windows = dialect === 'windows'
-  const lines = [`background: started${target ? ` on ${target}` : ''}`, `command: ${command}`]
+  const lines = []
   if (pid !== undefined) lines.push(`pid: ${pid}`)
   if (log) lines.push(`log: ${log}`)
   if (errLog) lines.push(`stderr log: ${errLog}`)
@@ -65,5 +72,12 @@ export function renderBackgroundStart({ pid, log, errLog, target, command, diale
   )
   if (pid !== undefined) lines.push(windows ? `stop: Stop-Process -Id ${pid} -Force` : `stop: kill ${pid}`)
   lines.push('The process is detached from this tool call: timeoutMs does not apply and it keeps running until it exits or is stopped.')
+  return lines
+}
+
+/** One model-facing description of a started background process. */
+export function renderBackgroundStart({ pid, log, errLog, target, command, dialect = 'posix' }) {
+  const lines = [`background: started${target ? ` on ${target}` : ''}`, `command: ${command}`]
+  lines.push(...renderBackgroundDetails({ pid, log, errLog, dialect }))
   return lines.join('\n')
 }

package/lib/core/broker.js

@@ -177,13 +177,16 @@ export function createSessionBroker({ getSecret, knownHosts, config = {}, log =
     return `${server.host}|${server.port}|${server.username}|${auth}`
   }
 
-  function connectOptions(server, state) {
+  function connectOptions(server, state, connectTimeoutMs) {
     const hostKeyMode = settings.hostKeyMode === 'accept-new' ? 'accept-new' : 'strict'
+    const readyTimeout = Number.isInteger(connectTimeoutMs) && connectTimeoutMs > 0
+      ? Math.min(connectTimeoutMs, settings.connectTimeoutMs)
+      : settings.connectTimeoutMs
     return {
       host: server.host,
       port: server.port,
       username: server.username,
-      readyTimeout: settings.connectTimeoutMs,
+      readyTimeout,
       keepaliveInterval: settings.keepaliveInterval,
       keepaliveCountMax: settings.keepaliveCountMax,
       hostHash: 'sha256',
@@ -197,7 +200,7 @@ export function createSessionBroker({ getSecret, knownHosts, config = {}, log =
   }
 
   /** Open a fresh client and resolve on `ready`. */
-  async function connectClient(server) {
+  async function connectClient(server, connectTimeoutMs) {
     const { Client } = await loadSsh2()
     const state = {}
     const client = new Client()
@@ -226,7 +229,7 @@ export function createSessionBroker({ getSecret, knownHosts, config = {}, log =
         log('ssh client error', { server: server.name, error: error instanceof Error ? error.message : String(error) })
       })
       try {
-        client.connect(connectOptions(server, state))
+        client.connect(connectOptions(server, state, connectTimeoutMs))
       } catch (error) {
         fail(error)
       }
@@ -281,7 +284,7 @@ export function createSessionBroker({ getSecret, knownHosts, config = {}, log =
   }
 
 
-  async function acquire(server) {
+  async function acquire(server, options = {}) {
     const id = server.id ?? server.name
     const key = serverKey(server)
     let entry = entries.get(id)
@@ -328,7 +331,7 @@ export function createSessionBroker({ getSecret, knownHosts, config = {}, log =
     }
     created.pending = (async () => {
       try {
-        const { client, fingerprint, connectMs } = await connectClient(server)
+        const { client, fingerprint, connectMs } = await connectClient(server, options.connectTimeoutMs)
         created.client = client
         created.fingerprint = fingerprint
         created.connectMs = connectMs
@@ -589,7 +592,7 @@ export function createSessionBroker({ getSecret, knownHosts, config = {}, log =
     for (;;) {
       let acquired
       try {
-        acquired = await acquire(server)
+        acquired = await acquire(server, { connectTimeoutMs: options.connectTimeoutMs })
       } catch (error) {
         const normalized = error instanceof SshError ? error : normalizeError(error)
         const result = errorResult(normalized.code, normalized.message, { durationMs: now() - startedAt })

package/lib/core/dialect.js

@@ -9,7 +9,7 @@
  */
 
 /** The dialect values this plugin understands. */
-export const DIALECTS = Object.freeze({ POSIX: 'posix', WINDOWS: 'windows' })
+const DIALECTS = Object.freeze({ POSIX: 'posix', WINDOWS: 'windows' })
 
 /** Normalize one raw dialect/platform value. */
 export function normalizeDialect(value) {

package/lib/core/execution-stats.js

@@ -0,0 +1,88 @@
+/**
+ * Per-session execution summary for the composer target dock.
+ *
+ * DSH owns conversation/model metrics (turns, TTFT, TPS); the plugin cannot
+ * read them. This module only summarizes the activity entries the plugin
+ * writes for remote executions, so the dock can show accurate SSH-side counts
+ * and latency without inventing values it does not own.
+ */
+
+function numericDuration(entry) {
+  return Number.isFinite(entry?.durationMs) && entry.durationMs >= 0 ? entry.durationMs : 0
+}
+
+function emptyBucket(name) {
+  return { name, count: 0, success: 0, failed: 0, durationMs: 0, averageMs: 0, lastAt: null }
+}
+
+function addToBucket(bucket, entry) {
+  bucket.count += 1
+  if (entry.outcome === 'success') bucket.success += 1
+  else bucket.failed += 1
+  bucket.durationMs += numericDuration(entry)
+  if (typeof entry.at === 'string' && (bucket.lastAt === null || entry.at > bucket.lastAt)) bucket.lastAt = entry.at
+}
+
+/**
+ * Summarize the plugin's remote execution activity for one Session.
+ *
+ * @param {object[]} entries newest-first activity entries
+ * @param {{ sessionId?: string, candidates?: string[] }} options
+ * @returns {{
+ *   sessionId: string|null,
+ *   count: number,
+ *   success: number,
+ *   failed: number,
+ *   durationMs: number,
+ *   averageMs: number,
+ *   lastAt: string|null,
+ *   servers: Array<{name:string,count:number,success:number,failed:number,durationMs:number,averageMs:number,lastAt:string|null}>
+ * }}
+ */
+export function summarizeExecution(entries, { sessionId, candidates = [] } = {}) {
+  const wanted = typeof sessionId === 'string' && sessionId.length > 0 ? sessionId : null
+  const byServer = new Map()
+  const summary = {
+    sessionId: wanted,
+    count: 0,
+    success: 0,
+    failed: 0,
+    durationMs: 0,
+    averageMs: 0,
+    lastAt: null,
+    servers: [],
+  }
+
+  if (wanted !== null) {
+    for (const entry of Array.isArray(entries) ? entries : []) {
+      if (!entry || entry.kind !== 'exec' || entry.sessionId !== wanted) continue
+      summary.count += 1
+      if (entry.outcome === 'success') summary.success += 1
+      else summary.failed += 1
+      summary.durationMs += numericDuration(entry)
+      if (typeof entry.at === 'string' && (summary.lastAt === null || entry.at > summary.lastAt)) summary.lastAt = entry.at
+      const name = typeof entry.server === 'string' && entry.server.length > 0 ? entry.server : null
+      if (name === null) continue
+      if (!byServer.has(name)) byServer.set(name, emptyBucket(name))
+      addToBucket(byServer.get(name), entry)
+    }
+  }
+
+  summary.averageMs = summary.count > 0 ? Math.round(summary.durationMs / summary.count) : 0
+
+  // Keep the mentioned resources in mention order, then append any target that
+  // ran from an explicit remote_exec task without being a session candidate.
+  const names = []
+  for (const name of Array.isArray(candidates) ? candidates : []) {
+    const value = String(name)
+    if (value && !names.includes(value)) names.push(value)
+  }
+  for (const name of [...byServer.keys()].sort()) {
+    if (!names.includes(name)) names.push(name)
+  }
+  summary.servers = names.map((name) => {
+    const bucket = byServer.get(name) ?? emptyBucket(name)
+    return { ...bucket, averageMs: bucket.count > 0 ? Math.round(bucket.durationMs / bucket.count) : 0 }
+  })
+  return summary
+}

package/lib/core/gate-pwsh.js

@@ -58,7 +58,7 @@ const RULES = [
 ]
 
 /** Split one PowerShell command into independently-executed statements. */
-export function powerShellStatements(command) {
+function powerShellStatements(command) {
   return String(command ?? '')
     .split(/[;\r\n]|\|\||&&|\|/)
     .map((part) => part.trim())

package/lib/core/guard.js

@@ -1,25 +1,27 @@
 /**
- * Fallback blacklist for remote bash.
+ * Fallback blacklist for remote commands.
  *
  * Registered through `ctx.tools.guard()`: synchronous, monotonic, and checked
  * after DSH's own pre-execute policy and approval, so no later listener can
- * turn a denial back into a permission. It only inspects commands that will
- * actually run on a managed server (the session has an active target and the
- * tool is a POSIX remote shell: the native `bash` tool on POSIX Hosts, the
- * plugin-owned `remote_bash` tool on Windows Hosts); local bash, file tools and
- * every other tool are untouched.
+ * turn a denial back into a permission.
+ *
+ * There is no session-scoped target state: every remote tool names its own
+ * `server`, so the guard resolves that explicit reference. The native local
+ * `bash`/`pwsh` tools are never inspected — local work is outside this
+ * plugin's remote-command boundary.
  */
 import { classifyCommand } from './gate.js'
 import { classifyPowerShellCommand } from './gate-pwsh.js'
+import { findServerRef } from './server-ref.js'
 
-/** The plugin-owned POSIX shell tool (Windows Hosts have no native bash). */
-export const REMOTE_BASH_TOOL_NAME = 'remote_bash'
+/** The plugin-owned POSIX shell tool. */
+const REMOTE_BASH_TOOL_NAME = 'remote_bash'
 
 /** The plugin-owned PowerShell tool (Windows targets). */
-export const REMOTE_PWSH_TOOL_NAME = 'remote_pwsh'
+const REMOTE_PWSH_TOOL_NAME = 'remote_pwsh'
 
-/** Tools whose command argument runs in a POSIX shell on a managed target. */
-const POSIX_REMOTE_TOOL_NAMES = new Set(['bash', REMOTE_BASH_TOOL_NAME])
+/** Explicit-target batch tool: every task names its own server. */
+const REMOTE_EXEC_TOOL_NAME = 'remote_exec'
 
 export const BLOCK_REASON_PREFIX = 'dsh-ssh-workbench blocked this command: '
 
@@ -31,38 +33,88 @@ export function sessionKeyOf(exec) {
   return typeof id === 'string' && id.length > 0 ? id : undefined
 }
 
+/**
+ * Pick the gate for one explicit server. A record's `platform` is only a hint:
+ * the executor probes the real dialect before running. When facts are not
+ * collected yet, run both blacklists so a stale hint cannot hide a
+ * Windows-only destructive command (and vice versa).
+ */
+function classifyForServer(server, command) {
+  const dialect = server?.facts?.dialect
+  if (dialect === 'windows') return classifyPowerShellCommand(command)
+  if (dialect === 'posix') return classifyCommand(command)
+  const posix = classifyCommand(command)
+  if (posix.decision === 'deny') return posix
+  return classifyPowerShellCommand(command)
+}
+
+function summaryOf(prefix, command) {
+  const text = `${prefix}${command}`.slice(0, 200)
+  return text
+}
+
 /**
  * @param {object} deps
- * @param {object} deps.targets per-session target store
  * @param {(entry: object) => void} [deps.recordActivity]
+ * @param {() => object[]} [deps.loadInventory]
  * @returns {(exec: object) => string|undefined} a `ctx.tools.guard()` handler
  */
-export function createBlacklistGuard({ targets, recordActivity } = {}) {
+export function createBlacklistGuard({ recordActivity, loadInventory } = {}) {
+  function inventory() {
+    if (typeof loadInventory !== 'function') return undefined
+    try {
+      const servers = loadInventory()
+      return Array.isArray(servers) ? servers : undefined
+    } catch {
+      return undefined
+    }
+  }
+
+  function guardOne(exec, serverRef, command, label = '') {
+    const ref = typeof serverRef === 'string' ? serverRef.trim() : ''
+    if (!ref || ref.toLowerCase() === 'local') return undefined
+    if (!command.trim()) return undefined
+    const servers = inventory()
+    if (servers === undefined) return undefined
+    const server = findServerRef(servers, ref)
+    if (server === undefined) return undefined
+    const classification = classifyForServer(server, command)
+    if (classification.decision !== 'deny') return undefined
+    try {
+      recordActivity?.({
+        kind: 'exec',
+        server: server.name,
+        sessionId: sessionKeyOf(exec),
+        summary: summaryOf(label, command),
+        outcome: `blocked: ${classification.ruleId}`,
+      })
+    } catch {
+      // Activity recording is best effort and must never change the decision.
+    }
+    return `${BLOCK_REASON_PREFIX}${label}${classification.reason}`
+  }
+
+  /** Check every task independently; one denied task denies the whole batch. */
+  function guardBatch(exec) {
+    const tasks = exec.arguments?.tasks
+    if (!Array.isArray(tasks) || tasks.length === 0) return undefined
+    for (let index = 0; index < tasks.length; index += 1) {
+      const task = tasks[index]
+      if (!task || typeof task !== 'object') continue
+      const command = typeof task.command === 'string' ? task.command : ''
+      const denied = guardOne(exec, task.server, command, `task ${index + 1}: `)
+      if (denied !== undefined) return denied
+    }
+    return undefined
+  }
+
   return function blacklistGuard(exec) {
     try {
       if (!exec) return undefined
-      const isPosix = POSIX_REMOTE_TOOL_NAMES.has(exec.name)
-      const isPowerShell = exec.name === REMOTE_PWSH_TOOL_NAME
-      if (!isPosix && !isPowerShell) return undefined
-      const key = sessionKeyOf(exec)
-      if (key === undefined || !targets) return undefined
-      const binding = targets.get(key)
-      if (!binding || !binding.active) return undefined
+      if (exec.name === REMOTE_EXEC_TOOL_NAME) return guardBatch(exec)
+      if (exec.name !== REMOTE_BASH_TOOL_NAME && exec.name !== REMOTE_PWSH_TOOL_NAME) return undefined
       const command = typeof exec.arguments?.command === 'string' ? exec.arguments.command : ''
-      if (!command.trim()) return undefined
-      const classification = isPowerShell ? classifyPowerShellCommand(command) : classifyCommand(command)
-      if (classification.decision !== 'deny') return undefined
-      try {
-        recordActivity?.({
-          kind: 'exec',
-          server: binding.active,
-          summary: command.slice(0, 200),
-          outcome: `blocked: ${classification.ruleId}`,
-        })
-      } catch {
-        // Activity recording is best effort and must never change the decision.
-      }
-      return `${BLOCK_REASON_PREFIX}${classification.reason}`
+      return guardOne(exec, exec.arguments?.server, command)
     } catch {
       // A guard must never turn its own failure into a denial of unrelated tools.
       return undefined

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 }
+}