dsh-remote 0.8.6 → 0.8.8

package/lib/index.js

@@ -42,6 +42,7 @@ import { searchTree } from './search.js'
 import { TaskManager } from './tasks.js'
 import { ForwardManager } from './forwards.js'
 import { selfDir, readVersion, gtVersion, fetchLatestVersion, applyUpdate, persistUpdateMode, readUpdateMode } from './update.js'
+import { loadMachines as _loadMachines, saveMachines as _saveMachines, sanitizeMachine as _sanitizeMachine, applyMachine as _applyMachine, machineId as _machineId } from './registry.js'
 
 const { Client } = ssh2
 
@@ -220,6 +221,9 @@ function migrateLegacyData() {
 }
 
 // ── persistent multi-machine registry ─────────────────────────────────────
+// Pure registry logic lives in lib/registry.js (unit-tested): saved machines
+// are STANDBY connections; only an explicit "set current" activates one.
+// (issue #13 — Saved Connections != Active Remote Context)
 const MACHINES_FILE = 'machines.json'
 const machinesFile = () => path.join(remoteWorkspacesRoot(), MACHINES_FILE)
 const secretsDir = () => path.join(remoteWorkspacesRoot(), '.secrets')
@@ -227,40 +231,11 @@ const forwardsFile = () => path.join(remoteWorkspacesRoot(), 'forwards.json')
 const auditFile = () => path.join(remoteWorkspacesRoot(), 'audit.log')
 const ignoreFile = () => path.join(remoteWorkspacesRoot(), '.dsh-remote-ignore')
 
-function loadMachines() {
-  try {
-    const j = JSON.parse(readFileSync(machinesFile(), 'utf8'))
-    if (Array.isArray(j.list)) return { list: j.list, currentId: j.currentId || (j.list[0] && j.list[0].id) || null }
-  } catch {}
-  return { list: [], currentId: null }
-}
-function saveMachines(list, currentId) {
-  try { mkdirSync(path.dirname(machinesFile()), { recursive: true }) } catch {}
-  writeFileSync(machinesFile(), JSON.stringify({ list, currentId }, null, 2))
-}
-function sanitizeMachine(m) {
-  if (!m) return m
-  const { password, proxy, ...rest } = m
-  const out = { ...rest, passwordSet: !!(m.password && m.password.length) }
-  if (proxy) out.proxy = { ...proxy, password: proxy.password ? '' : undefined, passwordSet: !!(proxy.password && proxy.password.length) }
-  return out
-}
-/** Apply a machine's fields onto the live config object (pool + tools read it). */
-function applyMachine(config, m) {
-  if (!m) return
-  config.host = m.host
-  config.port = Number(m.port) || 22
-  config.username = m.username || ''
-  config.password = m.password || ''
-  config.privateKeyPath = m.privateKeyPath || ''
-  config.passphrase = m.passphrase || ''
-  config.workspace = m.workspace || (config.workspace || '')
-  if (m.hostKeyMode) config.hostKeyMode = m.hostKeyMode
-  if (typeof m.useAgent === 'boolean') config.useAgent = m.useAgent
-  if (typeof m.keyboardInteractive === 'boolean') config.keyboardInteractive = m.keyboardInteractive
-  config.proxy = m.proxy && m.proxy.host ? m.proxy : undefined
-}
-function machineId() { return 'm-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 6) }
+const loadMachines = () => _loadMachines(machinesFile())
+const saveMachines = (list, currentId, keepCurrentKey) => _saveMachines(machinesFile(), list, currentId, keepCurrentKey)
+const sanitizeMachine = _sanitizeMachine
+const applyMachine = _applyMachine
+const machineId = _machineId
 
 // ── host-key registry (TOFU) ──────────────────────────────────────────────
 const KNOWN_HOSTS_FILE = 'known_hosts.json'
@@ -753,6 +728,15 @@ export async function apply(ctx, config) {
   }
 
   const setCurrent = async (id) => {
+    if (!id) {
+      // Explicit "active remote = none": saved machines stay in the registry
+      // (issue #13) but nothing is bound to the pool anymore.
+      store.currentId = null
+      ephemeral = null
+      saveMachines(machines, null)
+      await clearActiveMachine()
+      return true
+    }
     const i = machineIndex(id)
     if (i < 0) return false
     store.currentId = id
@@ -762,10 +746,41 @@ export async function apply(ctx, config) {
     return true
   }
 
-  // If no stored current, adopt a CLI-provided default as the active machine.
+  /** Unbind the pool + live config from any machine: the plugin starts in a
+   * pure "no remote context" state (issue #13). The host stays configured for
+   * tool fallback, but no machine workspace leaks into this session. */
+  const clearActiveMachine = async () => {
+    ephemeral = null
+    if (!config.host) return
+    // Clear host + workspace directly (applyMachine keeps the old workspace
+    // when the incoming value is empty — it must not be used for a full reset).
+    config.host = ''
+    config.port = 22
+    config.username = ''
+    config.password = ''
+    config.workspace = ''
+    pool.setTarget({ host: '', port: 22, username: '', workspace: '' })
+    // Also stop any auto-push watcher bound to the old machine workspace.
+    // (autoPushWatchers is declared later; read it lazily to avoid TDZ.)
+    if (typeof autoPushWatchers !== 'undefined' && autoPushWatchers) {
+      for (const [, entry] of autoPushWatchers) {
+        if (!entry) continue
+        try { entry.watcher && entry.watcher.close() } catch {}
+        if (entry.timer) clearTimeout(entry.timer)
+      }
+      autoPushWatchers.clear()
+    }
+  }
+
+  // If no stored current, adopt a CLI-provided default as the active machine —
+  // UNLESS the user explicitly cleared the current machine (currentId: null in
+  // the registry = "active remote = none", issue #13). A registry that exists
+  // with currentId null must stay inert; only a fresh/absent registry lets the
+  // config host serve as the bootstrap default.
   {
     const cur = currentMachine()
-    if (cur && cur.host && !store.currentId) applyMachine(config, cur)
+    const registryExplicitNone = store.explicitNone
+    if (cur && cur.host && !store.currentId && !registryExplicitNone) applyMachine(config, cur)
   }
 
   /** Persist the active workspace on the machine the pool is actually bound to
@@ -980,9 +995,61 @@ export async function apply(ctx, config) {
 
   // ── remote workspace state ────────────────────────────────────────────────
   const wsPath = () => (config.workspace || '').trim()
+  /** Map a LOCAL path to the remote path its mirror represents ('' when the
+   *  path is not inside any dsh-remote mirror). Shared by the resolve-mirror
+   *  route, the session-aware system-prompt injection, and status(). */
+  const resolveMirrorForLocal = (local) => {
+    const root = remoteWorkspacesRoot()
+    const norm = (p) => path.resolve(String(p || '')).replace(/[\\/]+$/, '') || ''
+    let matched = ''
+    let matchedRemote = ''
+    if (local && existsSync(root)) {
+      const base = norm(local)
+      for (const hostDir of readdirSync(root)) {
+        const hostPath = path.join(root, hostDir)
+        if (!statSync(hostPath, { throwIfNoEntry: false })?.isDirectory?.()) continue
+        for (const mirrorDir of readdirSync(hostPath)) {
+          const metaPath = path.join(hostPath, mirrorDir, '.dsh-remote-meta.json')
+          if (!existsSync(metaPath)) continue
+          try {
+            const meta = JSON.parse(readFileSync(metaPath, 'utf8'))
+            const mirrorAbs = norm(path.join(hostPath, mirrorDir))
+            if (mirrorAbs === base || base.startsWith(mirrorAbs + path.sep) || base.startsWith(mirrorAbs + '/')) {
+              if (mirrorAbs.length > matched.length) {
+                matched = mirrorAbs
+                matchedRemote = String(meta.remotePath || '')
+              }
+            }
+          } catch { /* skip unparsable meta */ }
+        }
+      }
+    }
+    return { mirrorDir: matched || null, remotePath: matchedRemote || '' }
+  }
   if (config.autoPush && wsPath()) {
     startAutoPush(mirrorDirFor(wsPath(), config.host, config.username, config.port))
   }
+  /** The remote path the CURRENT agent session is really bound to, or '' when
+   *  the session is a plain local one. Walks the mirror registry (host side
+   *  copy of the resolve-mirror logic) so status / prompt / sidebar agree.
+   *  `sessionId` narrows to one session; without it the first live session's
+   *  cwd is used (best effort — status is informational, the per-session
+   *  resolve-mirror endpoint is authoritative). */
+  const sessionRemotePath = (sessionId) => {
+    let cwd = ''
+    try {
+      const sessions = ctx && typeof ctx.get === 'function' ? ctx.get('sessions') : null
+      if (sessions && typeof sessions.get === 'function' && sessionId) {
+        const s = sessions.get(sessionId)
+        if (s && s.header && s.header.cwd) cwd = String(s.header.cwd)
+      } else if (sessions && typeof sessions.list === 'function') {
+        const s = sessions.list()[0]
+        if (s && s.header && s.header.cwd) cwd = String(s.header.cwd)
+      }
+    } catch { /* sessions service unavailable */ }
+    if (!cwd) return ''
+    return resolveMirrorForLocal(cwd).remotePath
+  }
   const status = () => ({
     host: config.host,
     port: config.port,
@@ -992,6 +1059,11 @@ export async function apply(ctx, config) {
     localMirror: wsPath() ? mirrorDirFor(wsPath(), config.host, config.username, config.port) : '',
     currentId: store.currentId || null,
     activeSource: ephemeral ? 'ephemeral' : (store.currentId ? 'machine' : (config.host ? 'config' : 'none')),
+    // Issue #13: whether THIS session is in remote mode (cwd inside a mirror).
+    // `none`/`local` means the plugin is present but no remote context is
+    // active — saved machines stay standby-only.
+    sessionMode: sessionRemotePath() ? 'remote' : (store.currentId ? 'standby' : 'local'),
+    sessionRemotePath: sessionRemotePath(),
     machines: machines.map(sanitizeMachine),
     hostKeyMode: config.hostKeyMode === 'verify' || config.hostKeyMode === 'off' ? config.hostKeyMode : 'accept-new',
     hostKeyKnown: config.host ? isHostKeyKnown(config.host, config.port) : false,
@@ -1015,15 +1087,16 @@ export async function apply(ctx, config) {
     defineTool({
       name: 'rw_info',
       description:
-        'Show the remote environment: host/user/port, connection health, current remote workspace path, active port forwards. Call this first to orient, or when an rw_* call fails to check connectivity.',
+        'Show the remote environment: host/user/port, connection health, current remote workspace path, active port forwards. Call this first to orient, or when an rw_* call fails to check connectivity. Note: remote context is session-scoped — a saved machine only becomes active when you explicitly rw_connect to it (issue #13).',
       parameters: {},
       output: textOut,
       async execute() {
         const s = status()
         const lines = [
           `Remote host: ${s.username || '<user>'}@${s.host || '<host>'}:${s.port}${s.activeSource !== 'machine' ? ` (source: ${s.activeSource})` : ''}`,
-          `Current remote workspace: ${s.workspace || '(none — call rw_pick_workspace to set one)'}`,
+          `Current remote workspace: ${s.workspace || '(none — call rw_connect then rw_pick_workspace to set one)'}`,
           `Local mirror: ${s.localMirror || '(none)'}`,
+          `Session remote context: ${s.sessionRemotePath ? s.sessionRemotePath : '(this session is LOCAL — no remote workspace bound)'}`,
           `Connected: ${s.connected ? 'yes' : 'no'}`,
           `Active forwards: ${s.forwards.filter((f) => f.active).length} / ${s.forwards.length}`,
           `Host key: ${s.hostKeyKnown ? 'trusted' : 'not yet trusted'} (mode=${s.hostKeyMode})`,
@@ -1689,19 +1762,30 @@ export async function apply(ctx, config) {
     ctx.tools.register(t)
   }
 
-  // ── system-prompt injection: the current remote workspace ─────────────────
+  // ── system-prompt injection: session-aware remote workspace ──────────────
+  // Issue #13: remote context must be SESSION-scoped, not machine-global.
+  // The section text is evaluated per assembly with the current agent's
+  // session; it is injected ONLY when that session's cwd actually maps to a
+  // dsh-remote mirror (i.e. the user picked a remote workspace as the session
+  // workspace). A plain local session gets no remote section — saved machines
+  // never leak their workspace into an unrelated local session's prompt.
+  // (resolveMirrorForLocal is defined above, next to wsPath.)
   ctx.systemPrompt.section({
     name: 'dsh-remote',
     order: 88,
-    text: () => {
-      const w = wsPath()
-      if (!w || !config.host) return ''
+    text: (promptContext) => {
+      const agent = promptContext && promptContext.agent
+      const session = agent && agent.session
+      const cwd = session && session.header && session.header.cwd
+      if (!cwd) return '' // no session cwd → nothing to map → stay quiet
+      const { remotePath } = resolveMirrorForLocal(cwd)
+      if (!remotePath) return '' // this session is NOT a remote session (issue #13)
       const fwd = forwards.list().filter((f) => f.active).map((f) => `${f.direction}:127.0.0.1:${f.listenPort}→${f.targetHost}:${f.targetPort}`)
       let extra = ''
       if (fwd.length) extra = `\nActive port forwards: ${fwd.join(', ')}`
       return (
         '## Remote workspace\n' +
-        `Current remote workspace: ${config.username}@${config.host}:${w}\n` +
+        `Current remote workspace: ${config.username || 'user'}@${config.host}:${remotePath}\n` +
         'Use the rw_* tools (rw_list_dir / rw_read_file / rw_write_file / rw_edit / rw_exec / rw_search / rw_sync / rw_push) to inspect and act on files on the remote host. Treat this directory as the working root for this task.' +
         extra
       )
@@ -1818,21 +1902,57 @@ export async function apply(ctx, config) {
     throw new Error('当前系统不支持自动打开目录选择器，请在输入框直接填本地路径')
   }
 
+  /** The ctx.directoryPicker capability object, or null when the service is
+   * absent/unusable. Never throws — callers fall through to pickLocalNative. */
+  const localPickCapability = async () => {
+    const dp = (ctx && typeof ctx.get === 'function') ? (ctx.get('directoryPicker') || null) : null
+    if (!dp || typeof dp.capability !== 'function') return null
+    try {
+      return await Promise.resolve(dp.capability())
+    } catch {
+      return null
+    }
+  }
+
+  /** Windows has no single filesystem root — enumerate fixed/mapped drive
+   * letters so the in-app browser can switch between them (the browse
+   * backend's crumbs stop at the current drive's root). Empty on POSIX. */
+  const listLocalDrives = () => {
+    if (process.platform !== 'win32') return []
+    const out = []
+    for (let i = 67; i <= 90; i++) { // C..Z (A/B are legacy floppy — skip)
+      const root = String.fromCharCode(i) + ':\\'
+      try {
+        statSync(root)
+        out.push({ name: root.slice(0, -1), path: root })
+      } catch {}
+    }
+    return out
+  }
+
   // ── route helpers ─────────────────────────────────────────────────────────
   const routes = [
     {
       kind: 'exact',
       path: '/dsh-remote/status',
       handler: async (req, res) => {
-        if (req.method === 'GET') return sendJson(res, 200, status())
+        if (req.method === 'GET') {
+          const q = new URL(req.url, 'http://localhost').searchParams
+          const sessionId = q.get('sessionId') ? decodeURIComponent(q.get('sessionId')) : ''
+          // Per-session remote context (issue #13): when a sessionId is given,
+          // sessionMode reflects THAT session's cwd, not the machine default.
+          return sendJson(res, 200, sessionId ? { ...status(), sessionMode: sessionRemotePath(sessionId) ? 'remote' : 'local', sessionRemotePath: sessionRemotePath(sessionId) } : status())
+        }
         sendJson(res, 405, { error: 'method not allowed' })
       },
     },
     {
       // Map a LOCAL path (typically a session cwd that sits inside a remote
       // mirror dir) to the remote path it mirrors, by reading each mirror
-      // dir's .dsh-remote-meta.json. Falls back to the machine workspace so
-      // the sidebar still shows something sensible for non-mirror cwds.
+      // dir's .dsh-remote-meta.json. NO machine-workspace fallback (issue #13):
+      // a session whose cwd is not inside any mirror is a pure LOCAL session —
+      // the sidebar must show "no remote workspace", never another machine's
+      // remembered default.
       // Accepts either ?local=<abs path> or ?sessionId=<id> (resolved via
       // the host sessions service header.cwd).
       kind: 'exact',
@@ -1881,7 +2001,6 @@ export async function apply(ctx, config) {
               } catch { /* session log scan failed */ }
             }
           }
-          const remote = status().workspace || ''
           const root = remoteWorkspacesRoot()
           const norm = (p) => path.resolve(String(p || '')).replace(/[\\/]+$/, '') || ''
           let matched = ''
@@ -1908,8 +2027,16 @@ export async function apply(ctx, config) {
               }
             }
           }
-          const remotePath = matchedRemote || remote
-          return sendJson(res, 200, { local, remotePath, mirrorDir: matched || null, fallback: !matchedRemote, resolvedVia })
+          // Issue #13: a non-mirror session is LOCAL — remotePath stays empty.
+          const remotePath = matchedRemote || ''
+          return sendJson(res, 200, {
+            local, remotePath, mirrorDir: matched || null,
+            // `fallback:true` now means "this session is NOT a remote session"
+            // (used to mean "fell back to machine workspace").
+            fallback: !matchedRemote,
+            mode: matchedRemote ? 'remote' : 'local',
+            resolvedVia,
+          })
         } catch (err) {
           return sendJson(res, 500, { error: String((err && err.message) || err) })
         }
@@ -2180,25 +2307,35 @@ export async function apply(ctx, config) {
         try {
           let outcome = null
           let via = 'service'
-          const dp = (ctx && typeof ctx.get === 'function') ? (ctx.get('directoryPicker') || null) : null
-          if (dp && typeof dp.capability === 'function') {
+          const cap = await localPickCapability()
+          if (cap && cap.kind === 'native' && typeof cap.pick === 'function') {
             try {
-              const cap = await Promise.resolve(dp.capability())
-              if (cap && cap.kind === 'native' && typeof cap.pick === 'function') {
-                const pickAbort = new AbortController()
-                const p = await Promise.resolve(cap.pick(pickAbort.signal || null))
-                pickAbort.abort()
-                outcome = (typeof p === 'string' && p) ? { path: p } : { cancelled: true }
-              }
+              const pickAbort = new AbortController()
+              const p = await Promise.resolve(cap.pick(pickAbort.signal || null))
+              pickAbort.abort()
+              outcome = (typeof p === 'string' && p) ? { path: p } : { cancelled: true }
             } catch (err) {
               outcome = null
             }
           }
+          // Prefer a REAL OS dialog over the browse backend: operators expect
+          // an Explorer-style chooser, and the own spawn (PowerShell
+          // FolderBrowserDialog / osascript / zenity-kdialog) works even where
+          // the host mounted browse — DSH Desktop (Electron) deliberately
+          // mounts browse on win32 because the native backend's koffi dialog
+          // worker cannot run under Electron, but a plain child process can.
           if (!outcome) {
             via = 'own'
             try {
               outcome = await pickLocalNative()
             } catch (err) {
+              // No usable OS dialog (headless host, missing chooser binary):
+              // fall back to the host's browse capability — fs-only, works
+              // display-less — served as an in-app browser by the client
+              // (backed by /dsh-remote/local-list + /dsh-remote/local-mkdir).
+              if (cap && cap.kind === 'browse' && typeof cap.list === 'function') {
+                return sendJson(res, 200, { ok: true, kind: 'browse', via: 'browse' })
+              }
               return sendJson(res, 500, { ok: false, error: String((err && err.message) || err) + ' — 可直接在输入框填本地路径' })
             }
           }
@@ -2209,6 +2346,51 @@ export async function apply(ctx, config) {
         }
       },
     },
+    {
+      kind: 'exact',
+      path: '/dsh-remote/local-list',
+      handler: async (req, res) => {
+        if (req.method !== 'GET') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
+        try {
+          const cap = await localPickCapability()
+          if (!cap || cap.kind !== 'browse' || typeof cap.list !== 'function') return sendJson(res, 400, { ok: false, error: '当前目录选择器不是浏览后端，无法列出本机目录' })
+          const m = (req.url || '').match(/path=([^&]*)/)
+          const raw = m ? decodeURIComponent(m[1]) : ''
+          // No path → the browse backend lists the host home directory.
+          try {
+            const out = await Promise.resolve(cap.list(raw ? raw : undefined))
+            return sendJson(res, 200, { ok: true, ...out, drives: listLocalDrives() })
+          } catch (listErr) {
+            return sendJson(res, 400, { ok: false, error: String((listErr && listErr.message) || listErr), code: (listErr && listErr.code) || 'directory-unreadable' })
+          }
+        } catch (err) {
+          return sendJson(res, 500, { ok: false, error: String((err && err.message) || err) })
+        }
+      },
+    },
+    {
+      kind: 'exact',
+      path: '/dsh-remote/local-mkdir',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
+        try {
+          const cap = await localPickCapability()
+          if (!cap || cap.kind !== 'browse' || typeof cap.createDirectory !== 'function') return sendJson(res, 400, { ok: false, error: '当前目录选择器不是浏览后端，无法新建文件夹' })
+          const payload = JSON.parse((await readBody(req)) || '{}')
+          const p = String(payload.path || '')
+          const name = String(payload.name || '')
+          if (!p.trim() || !name.trim()) return sendJson(res, 400, { ok: false, error: 'path and name required' })
+          try {
+            const created = await Promise.resolve(cap.createDirectory(p, name))
+            return sendJson(res, 200, { ok: true, path: created })
+          } catch (mkErr) {
+            return sendJson(res, 400, { ok: false, error: String((mkErr && mkErr.message) || mkErr), code: (mkErr && mkErr.code) || 'directory-create-failed' })
+          }
+        } catch (err) {
+          return sendJson(res, 500, { ok: false, error: String((err && err.message) || err) })
+        }
+      },
+    },
     {
       kind: 'exact',
       path: '/dsh-remote/machines',
@@ -2264,9 +2446,13 @@ export async function apply(ctx, config) {
                 rec.password = prev.password
               }
               if (i >= 0) machines[i] = rec; else machines.push(rec)
-              if (!store.currentId) store.currentId = id
-              saveMachines(machines, store.currentId)
-              if (store.currentId === id) await applyActiveMachine()
+              // Issue #13: saving a machine must NOT make it the active
+              // remote context. `currentId` stays untouched on add/update —
+              // only an explicit "设为当前" (or rw_connect) activates one.
+              // keepCurrentKey:false leaves the stored `currentId` byte-for-byte
+              // alone, so a fresh registry stays "no choice yet" (not an
+              // explicit none) and a previously-cleared registry stays cleared.
+              saveMachines(machines, store.currentId, false)
               return sendJson(res, 200, { ok: true, machine: sanitizeMachine(rec), machines: machines.map(sanitizeMachine), currentId: store.currentId })
             }
             if (action === 'delete') {
@@ -2277,9 +2463,17 @@ export async function apply(ctx, config) {
                 await deleteSecret(m.id, secretsDir()).catch(() => {})
               }
               machines.splice(i, 1)
-              if (store.currentId === body.id) store.currentId = machines[0] ? machines[0].id : null
-              saveMachines(machines, store.currentId)
-              if (store.currentId) await applyActiveMachine()
+              const wasCurrent = store.currentId === m.id
+              if (wasCurrent) {
+                // Issue #13: deleting the current machine leaves NO active
+                // remote context (never auto-promote a sibling — that would
+                // make an unrelated machine leak into the session again).
+                store.currentId = null
+                saveMachines(machines, null)
+                await clearActiveMachine()
+              } else {
+                saveMachines(machines, store.currentId)
+              }
               return sendJson(res, 200, { ok: true, machines: machines.map(sanitizeMachine), currentId: store.currentId })
             }
             return sendJson(res, 400, { ok: false, error: 'unknown action' })
@@ -2339,7 +2533,14 @@ export async function apply(ctx, config) {
         if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
         try {
           const body = JSON.parse((await readBody(req)) || '{}')
-          const okSet = await setCurrent(String(body.id || ''))
+          const id = String(body.id || '').trim()
+          // Issue #13: an empty id is an explicit "active remote = none" —
+          // saved machines stay in the registry but nothing is current.
+          if (!id) {
+            await setCurrent('')
+            return sendJson(res, 200, { ok: true, currentId: null, ...status() })
+          }
+          const okSet = await setCurrent(id)
           if (!okSet) return sendJson(res, 404, { ok: false, error: 'machine not found' })
           return sendJson(res, 200, { ok: true, ...status() })
         } catch (err) {