dsh-ssh-workbench 1.6.4 → 1.7.8

package/lib/core/{remote-bash-tool.js → remote-shell-tool.js}

@@ -1,13 +1,10 @@
 /**
- * Standalone remote shell tools (`remote_bash`, `remote_pwsh`).
+ * Explicit-target remote shell tools (`remote_bash`, `remote_pwsh`).
  *
- * The plugin normally routes DSH's native `bash` tool to the active target.
- * That only works on Hosts that ship `bash`: Windows Desktop builds ship
- * `pwsh` instead and disable `bash` by platform, so the interception handler is
- * never called there. A Windows target is also unreachable from any Host
- * through the POSIX shell. These tools are the portable entry points — they are
- * registered where the native shell cannot cover the target dialect, never
- * shadow a native tool, and keep the local shell strictly local.
+ * Every call names the managed
+ * resource it wants. That makes a follow-up without a new `@mention` safe
+ * (nothing switches behind the model's back), lets the model compare several
+ * resources directly, and keeps local and remote shells in separate worlds.
  *
  * The tools return rendered text instead of the native Bash value: the built-in
  * Bash renderer is reserved for the built-in tool and a remote result has no
@@ -18,9 +15,9 @@ import { defineTool } from '@deepseek-ai/dsh-tools'
 import { describeResultOutcome } from './activity.js'
 import { parseBackgroundStart, renderBackgroundStart } from './background.js'
 import { effectiveDialect, normalizeDialect } from './dialect.js'
-import { isTransportFailure } from './remote-bash.js'
+import { isTransportFailure } from './posix-shell.js'
 import { posixAdapter } from './shell-adapters.js'
-import { findTarget } from './targets.js'
+import { requireServerRef } from './server-ref.js'
 
 const textOut = {
   schema: { type: 'object', additionalProperties: false, properties: { text: { type: 'string', required: true } } },
@@ -41,9 +38,8 @@ export function sessionKeyOf(exec) {
 
 /**
  * Resolve the dialect a target actually runs. `facts.dialect` is a probe
- * result; when it is absent (fresh record, first selection) the runtime probe
- * runs once and is cached. The record's `platform` hint is only the last
- * fallback.
+ * result; when it is absent the runtime probe runs once and is cached. The
+ * record's `platform` hint is only the last fallback.
  */
 export async function resolveDialect(server, runtime) {
   const probed = server?.facts?.dialect
@@ -60,47 +56,29 @@ export async function resolveDialect(server, runtime) {
 }
 
 /**
- * Resolve the active target and the dialect for one call.
- * @returns {Promise<{ key: string, binding: object, server: object, dialect: string }>}
+ * Resolve the explicitly named server and its dialect for one call.
+ * @returns {Promise<{ key?: string, server: object, dialect: string }>}
  */
-export async function resolveRemoteTarget({ exec, targets, loadInventory, adapter, runtime, toolName = adapter?.toolName ?? 'remote shell' }) {
-  const key = sessionKeyOf(exec)
-  if (key === undefined) throw new Error(`${toolName} requires an agent session`)
-  const binding = typeof targets?.get === 'function' ? targets.get(key) : undefined
-  if (!binding || !binding.active) {
-    if (binding && Array.isArray(binding.candidates) && binding.candidates.length > 1) {
-      throw new Error(
-        `several servers were mentioned in this session (${binding.candidates.join(', ')}); ` +
-          `call ssh_workbench_target({ server: "<name>" }) before ${toolName}`,
-      )
-    }
-    throw new Error(
-      `no active target — call ssh_workbench_target({ server: "<name>" }) before ${toolName}, ` +
-        'or ssh_workbench_target({ server: "local" }) to stay on the local DSH host',
-    )
-  }
-
+export async function resolveExplicitTarget({
+  exec,
+  loadInventory,
+  adapter,
+  runtime,
+  serverRef,
+  toolName = adapter?.toolName ?? 'remote shell',
+}) {
   let servers
   try {
     servers = loadInventory()
   } catch (error) {
     throw new Error(`cannot read the managed server inventory: ${describeError(error)}`)
   }
-  const server = findTarget(servers, binding.active)
-  if (server === undefined) {
-    throw new Error(
-      `target "${binding.active}" is no longer in the managed inventory; ` +
-        'call ssh_workbench_target to pick another target or "local"',
-    )
-  }
-  if (server.enabled === false) {
-    throw new Error(`target "${server.name}" is disabled; call ssh_workbench_target to pick another target or "local"`)
-  }
+  const server = requireServerRef(servers, serverRef, { label: `${toolName} server` })
   const dialect = await resolveDialect(server, runtime)
   if (typeof adapter?.supportsDialect === 'function' && !adapter.supportsDialect(dialect)) {
     throw new Error(adapter.unsupportedMessage(server, dialect))
   }
-  return { key, binding, server, dialect }
+  return { key: sessionKeyOf(exec), server, dialect }
 }
 
 /** Render one remote result as model-facing text. */
@@ -137,11 +115,10 @@ function defaultCancelNotice(capability) {
 }
 
 /**
- * Create one remote shell tool definition.
+ * Create one explicit-target remote shell tool definition.
  *
  * @param {object} deps
  * @param {object} deps.runtime SSH runtime facade (`createSshRuntime`)
- * @param {object} deps.targets per-session target store
  * @param {object} deps.config resolved plugin config
  * @param {() => object[]} deps.loadInventory
  * @param {(entry: object) => void} [deps.recordActivity]
@@ -150,7 +127,6 @@ function defaultCancelNotice(capability) {
  */
 export function createRemoteShellTool({
   runtime,
-  targets,
   config,
   loadInventory,
   recordActivity,
@@ -158,18 +134,25 @@ export function createRemoteShellTool({
   localShellName = 'bash',
 } = {}) {
   const dialectName = normalizeDialect(adapter.platform) === 'windows' ? 'Windows/PowerShell' : 'POSIX shell'
+  const toolName = adapter.toolName
   return defineTool({
-    name: adapter.toolName,
+    name: toolName,
     description:
-      `Run a ${dialectName} command on the managed remote target selected with ssh_workbench_target. ` +
-      'This is the remote execution tool: the native ' +
-      `${localShellName} tool always runs on the local DSH host, so use this tool only for work that belongs on the target. ` +
+      `Run a ${dialectName} command on an explicitly named managed remote resource. ` +
+      `Pass server on every call (name or id). The native ${localShellName} tool always runs on the local DSH host, ` +
+      'so use this tool only for work that belongs on the remote resource. ' +
       'Pass workdir to change the working directory and timeoutMs for a foreground deadline. ' +
       'Set run_in_background to start a detached process: the result gives its pid and log files, ' +
       'which you can read with tail/Get-Content and stop with kill/Stop-Process. ' +
-      'If no target is active the tool fails; call ssh_workbench_target({ server: "<name>" }) first, ' +
-      'or ssh_workbench_target({ server: "local" }) to detach.',
+      (normalizeDialect(adapter.platform) === 'windows'
+        ? 'Use remote_bash for POSIX resources.'
+        : 'Use remote_pwsh for Windows resources.'),
     parameters: {
+      server: {
+        type: 'string',
+        required: true,
+        description: 'Managed remote resource name or id. Required; there is no remembered target.',
+      },
       command: { type: 'string', required: true, description: `Command to run on the remote ${dialectName} target.` },
       workdir: {
         type: 'string',
@@ -187,20 +170,28 @@ export function createRemoteShellTool({
     },
     output: textOut,
     async execute(args, exec) {
-      const { key, binding, server, dialect } = await resolveRemoteTarget({
+      const { server, dialect } = await resolveExplicitTarget({
         exec,
-        targets,
         loadInventory,
         runtime,
         adapter,
+        serverRef: args?.server,
+        toolName,
       })
 
       const command = typeof args?.command === 'string' ? args.command : ''
       if (!command.trim()) throw new Error('command must not be empty')
+      const sessionId = sessionKeyOf(exec)
+      const startedAt = Date.now()
+      const activityBase = {
+        kind: 'exec',
+        server: server.name,
+        sessionId,
+      }
 
       if (args?.run_in_background === true) {
         if (typeof adapter.buildBackgroundCommand !== 'function') {
-          throw new Error(`${adapter.toolName} does not support run_in_background`)
+          throw new Error(`${toolName} does not support run_in_background`)
         }
         const background = adapter.buildBackgroundCommand(command, args?.workdir, server, dialect)
         if (background.error !== undefined) throw new Error(background.error)
@@ -215,15 +206,15 @@ export function createRemoteShellTool({
             stderrCap: Number.isInteger(config?.maxStderrBytes) ? config.maxStderrBytes : undefined,
           })
         } catch (error) {
+          try {
+            recordActivity?.({ ...activityBase, summary: `[background] ${command.slice(0, 190)}`, outcome: 'failed', durationMs: Date.now() - startedAt })
+          } catch {
+            // Activity recording is best effort.
+          }
           throw new Error(`remote execution failed: ${describeError(error)}`)
         }
         try {
-          recordActivity?.({
-            kind: 'exec',
-            server: server.name,
-            summary: `[background] ${command.slice(0, 190)}`,
-            outcome: describeResultOutcome(start),
-          })
+          recordActivity?.({ ...activityBase, summary: `[background] ${command.slice(0, 190)}`, outcome: describeResultOutcome(start), durationMs: Date.now() - startedAt })
         } catch {
           // Activity recording is best effort.
         }
@@ -280,11 +271,16 @@ export function createRemoteShellTool({
           stderrCap: Number.isInteger(config?.maxStderrBytes) ? config.maxStderrBytes : undefined,
         })
       } catch (error) {
+        try {
+          recordActivity?.({ ...activityBase, summary: command.slice(0, 200), outcome: 'failed', durationMs: Date.now() - startedAt })
+        } catch {
+          // Activity recording is best effort.
+        }
         throw new Error(`remote execution failed: ${describeError(error)}`)
       }
 
       try {
-        recordActivity?.({ kind: 'exec', server: server.name, summary: command.slice(0, 200), outcome: describeResultOutcome(result) })
+        recordActivity?.({ ...activityBase, summary: command.slice(0, 200), outcome: describeResultOutcome(result), durationMs: Date.now() - startedAt })
       } catch {
         // Activity recording is best effort.
       }
@@ -297,12 +293,6 @@ export function createRemoteShellTool({
       }
 
       const notices = []
-      // One line after each target change: makes a plain-text result
-      // self-describing in multi-target sessions.
-      if (binding.notifiedVersion !== binding.version && typeof targets?.markNotified === 'function') {
-        notices.push(`[remote] target: ${server.name} (${server.username}@${server.host}:${server.port})`)
-        targets.markNotified(key, binding.version)
-      }
       if (result?.outcome === 'timeout') {
         notices.push(
           typeof adapter.timeoutNotice === 'function' ? adapter.timeoutNotice(capability) : defaultTimeoutNotice(capability),
@@ -318,4 +308,3 @@ export function createRemoteShellTool({
     },
   })
 }
-

package/lib/core/secrets.js

@@ -8,7 +8,6 @@
  * plaintext off disk without blocking the plugin.
  */
 import { createCipheriv, createDecipheriv, randomBytes } from 'node:crypto'
-import fs from 'node:fs'
 import { readTextFile, secretsKeyPath, secretsPath, writePrivateFile } from './paths.js'
 
 const ALGO = 'aes-256-gcm'

package/lib/core/server-ref.js

@@ -0,0 +1,61 @@
+/**
+ * Resolve one managed-resource reference (name or id) against the inventory.
+ *
+ * Every remote tool call carries its own `server`. Matching is
+ * case-insensitive so a hand-typed name still works, but the resolved record is
+ * always the inventory record the runtime uses.
+ */
+
+/** @param {object[]} servers @param {string} ref */
+export function findServerRef(servers, ref) {
+  const value = String(ref ?? '').trim()
+  if (!value) return undefined
+  const wanted = value.toLowerCase()
+  return (Array.isArray(servers) ? servers : []).find((server) => {
+    if (!server || typeof server !== 'object') return false
+    return (
+      String(server.id ?? '').toLowerCase() === wanted ||
+      String(server.name ?? '').toLowerCase() === wanted
+    )
+  })
+}
+
+/** Compact, model-facing list of enabled resource names. */
+function serverNameList(servers, limit = 20) {
+  return (Array.isArray(servers) ? servers : [])
+    .filter((server) => server && server.enabled !== false && server.name)
+    .slice(0, Math.max(1, limit))
+    .map((server) => String(server.name))
+}
+
+/**
+ * Resolve and validate a server reference for a tool call.
+ * Throws a model-readable error that lists the available resources.
+ *
+ * @param {object[]} servers
+ * @param {string} ref
+ * @param {{ label?: string, allowDisabled?: boolean }} [options]
+ */
+export function requireServerRef(servers, ref, options = {}) {
+  const label = options.label ?? 'server'
+  const value = String(ref ?? '').trim()
+  if (!value) {
+    throw new Error(`${label} is required; pass a managed resource name or id`)
+  }
+  if (value.toLowerCase() === 'local') {
+    throw new Error(
+      `${label} "${value}" is not a remote resource: the remote shell tools do not run on the local DSH host; use the native shell tool for local work`,
+    )
+  }
+  const server = findServerRef(servers, value)
+  if (server === undefined) {
+    const names = serverNameList(servers)
+    throw new Error(
+      `unknown ${label} "${value}". Available resources: ${names.length > 0 ? names.join(', ') : '(none)'}`,
+    )
+  }
+  if (server.enabled === false && options.allowDisabled !== true) {
+    throw new Error(`${label} "${server.name}" is disabled`)
+  }
+  return server
+}

package/lib/core/shell-adapters.js

@@ -11,7 +11,7 @@
  */
 import { buildPosixBackgroundCommand } from './background.js'
 import { normalizeDialect } from './dialect.js'
-import { applyWorkdir, resolveTimeoutMs, wrapRemoteTimeout } from './remote-bash.js'
+import { applyWorkdir, resolveTimeoutMs, wrapRemoteTimeout } from './posix-shell.js'
 import { win32Adapter } from './win32-adapter.js'
 
 /** Normalize the Host process platform to the two worlds the plugin cares about. */

package/lib/core/ssh.js

@@ -269,6 +269,26 @@ export function createSshRuntime({ getSecret, knownHosts, config = {}, log = ()
     }))
   }
 
+  /**
+   * `stat` follows symlinks; `lstat` reports the link itself. Atomic writes use
+   * this to avoid replacing a symlink with a regular file.
+   */
+  async function sftpLstat(server, remotePath) {
+    return await withSftp(server, (sftp) => new Promise((resolve, reject) => {
+      sftp.lstat(remotePath, (error, attrs) => {
+        if (error) return reject(toSftpError(error))
+        const type = typeof attrs?.isSymbolicLink === 'function' && attrs.isSymbolicLink() ? 'link' : undefined
+        resolve({ path: remotePath, ...statOf(attrs), ...(type ? { type } : {}) })
+      })
+    }))
+  }
+
+  async function sftpChmod(server, remotePath, mode) {
+    return await withSftp(server, (sftp) => new Promise((resolve, reject) => {
+      sftp.chmod(remotePath, mode, (error) => (error ? reject(toSftpError(error)) : resolve({ path: remotePath, mode })))
+    }))
+  }
+
   function clampReadBytes(value, fallback) {
     const hardCap = 64 * 1024 * 1024
     return Number.isInteger(value) ? Math.max(1024, Math.min(value, hardCap)) : fallback
@@ -707,6 +727,8 @@ export function createSshRuntime({ getSecret, knownHosts, config = {}, log = ()
     withSftp,
     sftpList,
     sftpStat,
+    sftpLstat,
+    sftpChmod,
     sftpHome,
     sftpRead,
     sftpReadBuffer,

package/lib/core/win32-adapter.js

@@ -14,7 +14,7 @@
  */
 import { BG_ERR_MARKER, BG_LOG_MARKER, BG_PID_MARKER } from './background.js'
 import { normalizeDialect } from './dialect.js'
-import { resolveTimeoutMs } from './remote-bash.js'
+import { resolveTimeoutMs } from './posix-shell.js'
 
 const POWERSHELL_UTF8 = [
   "$ErrorActionPreference = 'Continue'",