dsh-remote 0.8.42 → 0.8.45

package/lib/web-attach.js

@@ -222,14 +222,30 @@ export class WebAttach {
    * @param {object} [opts.net] - a `node:net`-compatible module (tests).
    * @param {number} [opts.localPortStart] - first local port to try.
    * @param {number} [opts.localPortMax] - how many ports to try before failing.
+   * @param {boolean} [opts.trackPool] - follow the pool across reconnects so a
+   *   dropped SSH connection degrades to "disconnected" and then SELF-HEALS
+   *   instead of being a permanent dead end (issue #54). `true` in production.
    */
   constructor(opts = {}) {
     this.net = opts.net || net
     this.localPortStart = opts.localPortStart || 3088
     this.localPortMax = opts.localPortMax || 50
+    /** Whether the pool's lifecycle hooks are ours to install. */
+    this.trackPool = opts.trackPool !== false
     /** @type {import('node:net').Server|null} */ this.server = null
     /** @type {Set<import('node:net').Socket>} */ this.sockets = new Set()
     /** @type {object|null} */ this.client = null
+    /** The pool this session borrowed its connection from (may be null). */
+    this.pool = null
+    /** Pool hooks we installed, so close() can hand them back untouched. */
+    this.prevOnReady = null
+    this.prevOnCloseHook = null
+    this.hookedPool = null
+    this._installedOnReady = null
+    this._installedOnClose = null
+    this.attachedClient = null
+    /** Bound listener, kept so it can be removed from the client. */
+    this.onClientClose = null
     this.localPort = 0
     this.remotePort = 0
     this.token = ''
@@ -239,6 +255,28 @@ export class WebAttach {
     this.machineId = ''
     this.command = ''
     this.startedAt = 0
+    /** Launch knobs remembered so a restart after a drop uses the same ones. */
+    this.waitSeconds = 0
+    this.omittedNoOpen = false
+    /** True while a reconnect-triggered re-resolve is in flight. */
+    this._resolving = false
+    /** True once the borrowed connection has been lost (drives recovery). */
+    this.connectionLost = false
+    /** undefined = "not asked yet"; false = the remote process is provably gone. */
+    this._remoteAlive = undefined
+    /** Set by close(): nothing may re-arm the tunnel afterwards. */
+    this.closed = false
+    /** Set once the borrowed connection has gone away (see _clientLost). */
+    this.lastError = ''
+    /**
+     * A listener that throws EARNS an 'error' event on the emitting object, and
+     * an 'error' with no listener is itself fatal — the very crash this module
+     * exists to prevent. Nothing here is expected to throw, but a lifecycle
+     * callback running on someone else's event loop must never be the reason
+     * the host process dies, so both hooks are wrapped.
+     */
+    this._onReady = (client) => { try { this._attach(client) } catch { /* never fatal */ } }
+    this._onPoolClose = () => { try { this._clientLost('ssh connection closed') } catch { /* never fatal */ } }
   }
 
   /** Whether the tunnel is currently listening. */
@@ -268,11 +306,17 @@ export class WebAttach {
     if (!pool) throw new Error('web-attach: a machine pool is required')
     this.machineId = String(machineId || '')
     this.command = command
+    this.waitSeconds = Number(waitSeconds) || 45
 
     const exec = spec.exec || ((cmd, opts) => pool.exec(cmd, opts))
     // Connecting first also surfaces credential/host-key problems BEFORE we
-    // start a remote process we would then have to clean up.
-    this.client = await pool.connect()
+    // start a remote process we would then have to clean up. `_attach` (rather
+    // than a bare assignment) is what subscribes to the connection's 'close',
+    // so the loss is noticed the moment it happens instead of on the next
+    // request — which is when the old code let ssh2 throw 'Not connected' from
+    // inside a socket callback and take the host process with it (issue #54).
+    this._attach(await pool.connect())
+    this._followPool(pool)
 
     if (existingUrl) {
       const parsed = parseWebStart(`dsh web: ${existingUrl}`)
@@ -398,24 +442,334 @@ export class WebAttach {
     })
   }
 
+  /**
+   * Borrow the given connection AND subscribe to its lifecycle.
+   *
+   * Idempotent for the same client (open() calls it once, the pool's `onReady`
+   * calls it again on every reconnect), and it always drops the previous
+   * client's listener first, so one session never accumulates listeners.
+   *
+   * @param {object|null} client - the live ssh2 client / OpenSshConnection.
+   */
+  _attach(client) {
+    if (!client) return
+    if (this.attachedClient && this.attachedClient !== client && this.onClientClose) {
+      // A different client replaced the one we borrowed (pool reconnect). Stop
+      // listening to the old one; its own 'close' has either fired already or
+      // belongs to a connection nobody uses any more.
+      try { this.attachedClient.removeListener('close', this.onClientClose) } catch { /* already gone */ }
+    }
+    this.client = client
+    if (this.attachedClient === client) return
+    this.attachedClient = client
+    this.onClientClose = () => { this._clientLost('ssh connection closed') }
+    // Without this, the object keeps handing out a connection that is already
+    // closed, and `forwardOut` then throws SYNCHRONOUSLY (issue #54).
+    try { client.on('close', this.onClientClose) } catch { /* not an emitter: nothing to watch */ }
+  }
+
+  /** The borrowed connection is gone: keep the session, drop the dead handle. */
+  _clientLost(reason) {
+    this.client = null
+    this.connectionLost = true
+    this.lastError = String(reason || 'ssh connection closed')
+  }
+
+  /**
+   * Register lifecycle hooks on the chosen pool so this tunnel follows it.
+   *
+   * The pool is the one place that both NOTICES a dead connection and later
+   * obtains a fresh one, and it exposes exactly two hooks for that:
+   *   • `onCloseHook` — fires from `close()` and `invalidate()` (the latter is
+   *     the "channel open failed, the pooled connection died server-side"
+   *     self-heal path, which is the likeliest trigger);
+   *   • `onReady` — fires after a successful (re)connect.
+   *
+   * Both are SINGLE-SLOT properties that the plugin already uses for
+   * `ForwardManager` (index.js), so this session CHAINS them rather than
+   * clobbering the forwards manager, and `_detachPool()` restores exactly what
+   * was there — the plugin may legitimately have none, one, or both.
+   *
+   * A real reconnect is the only way the remote port can move, so once the pool
+   * reports a new connection we must re-resolve (token, port) from the remote
+   * log. `onReady` itself cannot await: the pool fires it with the client in
+   * hand, so the re-resolve is kicked off and its failure is recorded rather
+   * than thrown into the pool's callback.
+   *
+   * @param {object} pool - the pool this session attached through.
+   */
+  _followPool(pool) {
+    if (!this.trackPool || this.closed || !pool || this.hookedPool === pool) return
+    this._detachPool()
+    this.pool = pool
+    this.hookedPool = pool
+    const prevReady = typeof pool.onReady === 'function' ? pool.onReady : null
+    const prevClose = typeof pool.onCloseHook === 'function' ? pool.onCloseHook : null
+    this.prevOnReady = prevReady
+    this.prevOnCloseHook = prevClose
+    const installedReady = (client) => {
+      this._attach(client)
+      if (prevReady) { try { prevReady(client) } catch { /* the forwards manager's problem, not ours */ } }
+      // A reconnect lands on a NEW remote process only if the old one died with
+      // the machine; re-read the log to find out which. The re-resolve runs off
+      // the event loop because the pool cannot await it — a hook that throws
+      // would earn an 'error' event on the pool, and an unhandled rejection
+      // would be fatal.
+      if (!this.closed && this.remotePort && !this._resolving) {
+        this._resolving = true
+        Promise.resolve()
+          .then(() => this._refreshRemotePort())
+          .catch((err) => { this.lastError = String((err && err.message) || err) })
+          .then(() => { this._resolving = false })
+      }
+    }
+    const installedClose = () => {
+      this._clientLost('ssh connection closed')
+      if (prevClose) { try { prevClose() } catch { /* never mask our own report */ } }
+    }
+    this._installedOnReady = installedReady
+    this._installedOnClose = installedClose
+    pool.onReady = installedReady
+    pool.onCloseHook = installedClose
+  }
+
+  /**
+   * Hand the pool's hooks back.
+   *
+   * Each slot is restored ONLY when it still holds the wrapper this session
+   * installed. The pool's hooks are single-slot, so if something else has taken
+   * the slot over in the meantime, putting a stale callback back would be worse
+   * than leaving it alone — it would silently disconnect a newer owner.
+   */
+  _detachPool() {
+    const pool = this.hookedPool
+    const mineReady = this._installedOnReady
+    const mineClose = this._installedOnClose
+    this.hookedPool = null
+    this._installedOnReady = null
+    this._installedOnClose = null
+    if (!pool) return
+    if (mineReady && pool.onReady === mineReady) pool.onReady = this.prevOnReady
+    if (mineClose && pool.onCloseHook === mineClose) pool.onCloseHook = this.prevOnCloseHook
+    this.prevOnReady = null
+    this.prevOnCloseHook = null
+  }
+
+  /**
+   * True when the borrowed connection was LOST and this is a session we can
+   * recover: we launched the remote process ourselves (so we hold its PID and
+   * log) and the tunnel is listening (so clients can actually be served).
+   *
+   * The `connectionLost` flag is deliberately separate from `this.client`: the
+   * pool's `onReady` re-attaches the new client BEFORE the re-resolve runs, so a
+   * check on `!this.client` would be false by then and recovery would never
+   * happen.
+   */
+  get _needsReResolve() {
+    return !!(this.connectionLost && !this.closed && this.logPath && this.remotePid && this.localPort)
+  }
+
+  /**
+   * Re-resolve the remote port after a reconnect, restarting the remote `dsh web`
+   * when it did not survive.
+   *
+   * Reaching a remote process needs a live SSH connection, so this reconnects
+   * through the pool first — the pool reports `onReady` for that same client in
+   * production, and in a test double the callback simply never fires.
+   */
+  async _refreshRemotePort() {
+    if (!this._needsReResolve) return
+    const pool = this.pool
+    if (!pool || (typeof pool.connect !== 'function' && typeof pool.exec !== 'function')) return
+    const exec = (cmd, opts) => (typeof pool.exec === 'function'
+      ? pool.exec(cmd, opts)
+      : Promise.reject(new Error('web-attach: the pool cannot run commands')))
+    if (!this.client) await pool.connect()
+    const match = await this._resolveRemotePort(exec)
+    this.remotePort = match.port
+    if (match.token) this.token = match.token
+    this.connectionLost = false
+    this.lastError = ''
+  }
+
+  /**
+   * Read this session's remote log and decide which port is live.
+   *
+   * The startup line is the ONLY source of the port (the launch deliberately
+   * uses `--port 0`), so after the remote process died and was restarted the log
+   * holds BOTH lines — the dead one and the new one — and neither position
+   * identifies the live one. Evidence decides:
+   *   • a process that is still alive on the remote is probed first, and when
+   *     the port it is LISTENING on is one of the logged ports, that is the
+   *     answer (the `dsh web: …` line names its own port, so this is a
+   *     confirmation rather than a second guess);
+   *   • otherwise the newest logged port wins, which is right in every
+   *     single-process case and is the best available answer while the remote is
+   *     still booting (the next reconnect retries).
+   *
+   * @param {(cmd: string, opts?: object) => Promise<{stdout: string}>} exec - remote exec.
+   * @returns {Promise<{port: number, token: string, restarted: boolean}>}
+   */
+  async _resolveRemotePort(exec) {
+    this._remoteAlive = await this._remoteProcessAlive(exec)
+    if (!this._remoteAlive) return this._restartRemote(exec)
+
+    let out = ''
+    try {
+      const res = await exec(`cat "$HOME/${this.logPath}" 2>/dev/null`, { timeoutMs: 15000 })
+      out = String((res && res.stdout) || '')
+    } catch { /* an unreadable log: the listening probe below is the fallback */ }
+    const lines = [...out.matchAll(/dsh web:\s*(http:\/\/[^\s]+)/g)]
+      .map((m) => parseWebStart(`dsh web: ${m[1]}`))
+      .filter(Boolean)
+
+    // What the recorded process actually listens on beats any guess from the
+    // log, because a killed-and-restarted remote leaves BOTH startup lines in
+    // the log and neither position says which one is live.
+    const listening = await this._listeningRemotePort(exec)
+    if (listening) {
+      const match = lines.find((l) => l.port === listening)
+      return { port: listening, token: (match && match.token) || this.token, restarted: false }
+    }
+    if (lines.length) {
+      const newest = lines[lines.length - 1]
+      return { port: newest.port, token: newest.token, restarted: false }
+    }
+    // Alive but silent and not listening yet: the remote is booting. Keep the
+    // last known port and let the next reconnect re-resolve.
+    return { port: this.remotePort, token: this.token, restarted: false }
+  }
+
+  /**
+   * Whether the remote process THIS session started still exists.
+   *
+   * Verified through `/proc`, which is Linux-only; a host that cannot answer (or
+   * a failed probe) is treated as ALIVE on purpose. Restarting a server that was
+   * never dead would spawn a second one and leak a port, whereas assuming life
+   * merely retries a port that turns out to be stale.
+   *
+   * @param {(cmd: string, opts?: object) => Promise<{stdout: string}>} exec - remote exec.
+   * @returns {Promise<boolean>}
+   */
+  async _remoteProcessAlive(exec) {
+    const pid = Number(this.remotePid) || 0
+    if (pid < 1) return true
+    try {
+      const res = await exec(
+        `if [ -d /proc ]; then { [ -d /proc/${pid} ] && echo ALIVE; } || echo GONE; else echo ALIVE; fi`,
+        { timeoutMs: 15000 },
+      )
+      return !/GONE/.test(String((res && res.stdout) || ''))
+    } catch { return true }
+  }
+
+  /**
+   * Ask the remote which loopback port the recorded PID listens on (0 = none).
+   *
+   * Two `/proc` reads are needed because a TCP listener appears in a socket
+   * table (`/proc/net/tcp{,6}`), not in that process's link list: the fd
+   * symlinks give the socket INODE, and the table maps that inode to a port.
+   * Matching on the inode rather than the port is what makes this an
+   * observation instead of a second guess.
+   */
+  async _listeningRemotePort(exec) {
+    const pid = Number(this.remotePid) || 0
+    if (pid < 1) return 0
+    let inodes = ''
+    try {
+      // `ls -l` on a process's own fds needs no privileges for the same uid.
+      const res = await exec(
+        `ls -l /proc/${pid}/fd 2>/dev/null | sed -n 's/.*socket:\\[\\([0-9]*\\)\\].*/\\1/p' | sort -u | tr '\\n' ' '`,
+        { timeoutMs: 15000 },
+      )
+      inodes = String((res && res.stdout) || '').trim()
+    } catch { return 0 }
+    if (!inodes) return 0
+    const want = new Set(inodes.split(/\s+/).filter(Boolean))
+    // `/proc/net/tcp` addresses are little-endian hex, so loopback is
+    // `0100007F` (v4) and `00000000000000000000000001000000` (v6 `::1`).
+    const LOOPBACK = new Set(['0100007F', '00000000000000000000000001000000'])
+    for (const file of ['/proc/net/tcp', '/proc/net/tcp6']) {
+      let text = ''
+      try {
+        const res = await exec(`cat ${file} 2>/dev/null`, { timeoutMs: 15000 })
+        text = String((res && res.stdout) || '')
+      } catch { continue }
+      for (const line of text.split('\n').slice(1)) {
+        const cols = line.trim().split(/\s+/)
+        // sl local_address rem_address st tx:rx tr:tm->when retrnsmt uid timeout inode
+        if (cols.length < 10) continue
+        if (cols[3] !== '0A') continue // TCP_LISTEN
+        if (!want.has(cols[9])) continue
+        const [addr, portHex] = String(cols[1]).split(':')
+        if (!LOOPBACK.has(String(addr).toUpperCase())) continue
+        const port = parseInt(portHex, 16)
+        if (Number.isInteger(port) && port > 0 && port < 65536) return port
+      }
+    }
+    return 0
+  }
+
+  /**
+   * Relaunch the remote `dsh web` because the previous process is gone.
+   *
+   * A restart CANNOT change the listening port locally, and a caller holding a
+   * stale port silently talks to the wrong place at worst and hangs at best, so
+   * the two facts the caller needs are checked: this is a session that launched
+   * its own process (an attach onto someone else's DSH stays hands-off and can
+   * never restart it), and recovery is possible at all (`_refreshRemotePort`
+   * has already returned early when it is not).
+   */
+  async _restartRemote(exec) {
+    const command = this.command || 'dsh'
+    const waitSeconds = this.waitSeconds || 45
+    const timeoutMs = Math.max(30000, (waitSeconds + 20) * 1000)
+    let out = String(await this._launch(exec, { command, profile: 'web', logPath: this.logPath, waitSeconds, timeoutMs }, this.omittedNoOpen === true))
+    if (launchFailed(out) && /unknown option/i.test(out) && /--no-open/.test(out)) {
+      out = String(await this._launch(exec, { command, profile: 'web', logPath: this.logPath, waitSeconds, timeoutMs }, true))
+      this.omittedNoOpen = true
+    }
+    this.remotePid = parseRemotePid(out) || this.remotePid
+    const parsed = parseWebStart(out)
+    if (!parsed) {
+      const tail = out.split(TAIL_MARKER).slice(1).join(TAIL_MARKER).trim()
+      throw new Error('web-attach: the remote DSH could not be restarted after the SSH'
+        + ' connection dropped.' + explainLaunchFailure(tail || out) + (tail ? ` Remote output: ${tail}` : ''))
+    }
+    return { port: parsed.port, token: parsed.token, restarted: true }
+  }
+
   /** Carry one local socket to the remote web port over SSH. */
   _pipe(socket) {
     if (!this.client) { try { socket.destroy() } catch { /* already gone */ } return }
-    this.client.forwardOut('127.0.0.1', 0, '127.0.0.1', this.remotePort, (err, channel) => {
-      if (err) { try { socket.destroy() } catch { /* already gone */ } return }
-      this.sockets.add(socket)
-      socket.pipe(channel)
-      channel.pipe(socket)
-      const kill = () => {
-        try { socket.destroy() } catch { /* already gone */ }
-        try { channel.close() } catch { /* already closed */ }
-        this.sockets.delete(socket)
-      }
-      socket.on('error', kill)
-      channel.on('error', kill)
-      socket.on('close', kill)
-      channel.on('close', kill)
-    })
+    // ssh2's forwardOut does NOT report a dead connection through its callback:
+    // when the socket is gone it THROWS 'Not connected' synchronously
+    // (ssh2/lib/client.js: `if (!this._sock || !isWritable(this._sock)) throw`)
+    // and the callback below is never reached — so `if (err)` cannot guard this
+    // path. Uncaught, that throw travels net.Server → TCP.onconnection and kills
+    // the whole host process (issue #54: every page refresh after the pooled
+    // connection dropped took the session, the browser and the remote orphan
+    // down with it). A dead tunnel is a UI state, not a reason to exit.
+    try {
+      this.client.forwardOut('127.0.0.1', 0, '127.0.0.1', this.remotePort, (err, channel) => {
+        if (err) { try { socket.destroy() } catch { /* already gone */ } return }
+        this.sockets.add(socket)
+        socket.pipe(channel)
+        channel.pipe(socket)
+        const kill = () => {
+          try { socket.destroy() } catch { /* already gone */ }
+          try { channel.close() } catch { /* already closed */ }
+          this.sockets.delete(socket)
+        }
+        socket.on('error', kill)
+        channel.on('error', kill)
+        socket.on('close', kill)
+        channel.on('close', kill)
+      })
+    } catch (err) {
+      this._clientLost(String((err && err.message) || err))
+      try { socket.destroy() } catch { /* already gone */ }
+    }
   }
 
   /**
@@ -462,6 +816,15 @@ export class WebAttach {
    * @param {(cmd: string) => Promise<unknown>} [opts.exec] - remote exec.
    */
   async close({ stopRemote = false, exec } = {}) {
+    // Stop following the pool BEFORE any await: a reconnect landing mid-teardown
+    // must not re-arm the tunnel this call is in the middle of closing.
+    this._detachPool()
+    if (this.attachedClient && this.onClientClose) {
+      try { this.attachedClient.removeListener('close', this.onClientClose) } catch { /* already gone */ }
+    }
+    this.attachedClient = null
+    this.onClientClose = null
+    this.pool = null
     for (const socket of [...this.sockets]) {
       try { socket.destroy() } catch { /* already gone */ }
     }
@@ -475,5 +838,9 @@ export class WebAttach {
       await Promise.resolve(exec(buildStopCommand(this.remotePid, this.logPath))).catch(() => {})
     }
     this.client = null
+    // The recorded PID and log path are FACTS about this session (the UI shows
+    // them, and `stopRemote` addresses them), so they survive; `closed` is what
+    // stops recovery work from being re-armed after teardown.
+    this.closed = true
   }
 }

package/lib/web-deploy.js

@@ -351,6 +351,31 @@ export function versionAtLeast(a, b) {
 /** The first dsh release whose node-pty ships Linux prebuilds (measured). */
 export const PTY_FIXED_VERSION = '0.1.5-rc.2'
 
+/**
+ * Minimum Node the remote must run, and the reason it is exactly this number.
+ *
+ * DSH's boot path imports `parseEnv` from `node:util`, and that export only
+ * exists from **20.12.0** (Node 21.7.0 and later have it too). Measured on a
+ * real host with two nodes installed:
+ *
+ *   /usr/bin/node (v18.19.1)                          → parseEnv: undefined
+ *   ~/.nvm/versions/node/v24.22.0/bin/node (v24.22.0) → parseEnv: function
+ *
+ * The failure mode is what makes this worth a BLOCKER rather than a warning: npm
+ * only prints EBADENGINE (it does not refuse), so all ~535 packages install
+ * cleanly and the crash arrives afterwards as
+ *
+ *   SyntaxError: The requested module 'node:util' does not provide an export
+ *   named 'parseEnv'    at .../@deepseek-ai/dsh-app-boot/lib/index.js:4
+ *
+ * which does not read as "your node is too old". Checking the version BEFORE the
+ * install is the only way to turn that into an actionable message.
+ *
+ * Reference: Node.js 20.12.0 release notes, "Loading and parsing environment
+ * variables" — https://nodejs.org/en/blog/release/v20.12.0
+ */
+export const MIN_NODE_VERSION = '20.12.0'
+
 /**
  * Turn facts into a verdict: what is wrong, why, and what to do.
  *
@@ -394,6 +419,17 @@ export function judgeProbe(facts, opts = {}) {
     add('NO_NODE', 'blocker', '远端没有 node',
       '自动部署需要 node 与 npm。',
       '先在该机器安装 Node.js（nvm 或系统包管理器），再回来重试。')
+  } else if (f.nodeVersion && !versionAtLeast(f.nodeVersion, MIN_NODE_VERSION)) {
+    // The install itself SUCCEEDS on this node — npm only warns (EBADENGINE) —
+    // and the failure surfaces later as a parseEnv import error that does not
+    // read as a version problem. So the check has to happen before the install.
+    add('NODE_TOO_OLD', 'blocker',
+      `远端 node ${f.nodeVersion} 版本过低（需要 ≥ ${MIN_NODE_VERSION}）`,
+      `dsh 启动时要 import node:util 的 parseEnv，该导出从 Node ${MIN_NODE_VERSION} 起才有。`
+      + '在这个版本上 npm 只会给 EBADENGINE 警告、仍然把包装完，'
+      + '直到启动时才崩：SyntaxError: The requested module \'node:util\' does not provide an export named \'parseEnv\'。',
+      `升级该机器的 node 到 ${MIN_NODE_VERSION} 以上（例如 nvm install 22），`
+      + '并把 `webAttachCommand` 指向新 node 的绝对路径（如 ~/.nvm/versions/node/v22.x/bin/node <前缀>/node_modules/@deepseek-ai/dsh/lib/bin.js）。')
   }
   if (!f.npm) {
     add('NO_NPM', 'blocker', '远端没有 npm',
@@ -474,7 +510,13 @@ export function judgeProbe(facts, opts = {}) {
   const blockers = findings.filter((x) => x.severity === 'blocker')
   // A Windows remote with Git Bash can be installed into: pool.exec pipes every
   // command through `bash -s`, so the POSIX plan works there.
-  const canAutoInstall = !!f.node && !!f.npm && (!f.windows || !!f.gitBash)
+  //
+  // A node older than MIN_NODE_VERSION makes an install POINTLESS as well as
+  // failing: the packages land, then the binary cannot boot. Promising
+  // "can auto-install: yes" there is what sent the reporter of issue #54 through
+  // a 535-package install that ended in a parseEnv SyntaxError.
+  const nodeUsable = !!f.node && (!f.nodeVersion || versionAtLeast(f.nodeVersion, MIN_NODE_VERSION))
+  const canAutoInstall = nodeUsable && !!f.npm && (!f.windows || !!f.gitBash)
 
   // Which command should the attach flow use? A verified deployment wins, then a
   // usable dsh already on PATH.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote",
-  "version": "0.8.42",
+  "version": "0.8.45",
   "description": "Remote-work assistant for DeepSeek Harness: connect SSH (password/key/agent/keyboard-interactive/proxy jump), pick a remote workspace, operate on it with 22 rw_* tools (incl. rw_edit/rw_stat/rw_mkdir/rw_remove/rw_move/rw_forward), conflict-aware mirror sync, one-click remote dsh deploy + web UI attach, port forwarding, optional side-bar remote file editing, audit log, keychain passwords.",
   "license": "MIT",
   "author": "flymysql <flyphp@outlook.com>",
@@ -80,6 +80,7 @@
     "@deepseek-ai/dsh-session": "^0.1.0-rc.8",
     "@deepseek-ai/dsh-timeout": "^0.1.0-rc.8",
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "react": "^18.3.1",
     "semver": "^7.8.5"
   },
   "scripts": {