dsh-remote 0.7.2 → 0.7.4

package/lib/client.js

@@ -140,6 +140,13 @@ window.__ModuleLoader__.load({
           ),
         ),
         err ? React.createElement('div', { style: { color: T.danger, fontSize: 13 } }, err) : null,
+        React.createElement('div', { style: { display: 'flex', gap: 12, alignItems: 'center', flexWrap: 'wrap', fontSize: 11, opacity: 0.65, borderTop: '1px solid ' + T.border, paddingTop: 10, marginTop: 4 } },
+          React.createElement('span', {}, '觉得好用？'),
+          React.createElement('a', { href: 'https://github.com/flymysql/dsh-remote', target: '_blank', rel: 'noopener noreferrer', style: { color: 'inherit' } }, '⭐ 去 GitHub 点个 Star'),
+          React.createElement('span', {}, '·'),
+          React.createElement('a', { href: 'https://github.com/flymysql/dsh-remote/issues/new', target: '_blank', rel: 'noopener noreferrer', style: { color: 'inherit' } }, '💬 反馈建议 / 提 issue'),
+          React.createElement('span', { style: { marginLeft: 'auto', opacity: 0.5 } }, 'dsh-remote v0.7.4'),
+        ),
       )
     }
 
@@ -451,6 +458,11 @@ window.__ModuleLoader__.load({
               ),
             ),
         (tab === 'local') ? React.createElement('div', { style: { display: 'flex', gap: 8, justifyContent: 'flex-end' } }, React.createElement('button', { style: { background: 'transparent' }, onClick: onCancel }, '取消')) : null,
+        React.createElement('div', { style: { display: 'flex', gap: 10, justifyContent: 'center', alignItems: 'center', paddingTop: 6, fontSize: 10, opacity: 0.5 } },
+          React.createElement('a', { href: 'https://github.com/flymysql/dsh-remote', target: '_blank', rel: 'noopener noreferrer', style: { color: 'inherit' } }, '⭐ Star dsh-remote'),
+          React.createElement('span', {}, '·'),
+          React.createElement('a', { href: 'https://github.com/flymysql/dsh-remote/issues/new', target: '_blank', rel: 'noopener noreferrer', style: { color: 'inherit' } }, '提建议 / 报问题'),
+        ),
         ),
       )
     }

package/lib/index.js

@@ -545,6 +545,96 @@ function isHostKeyKnown(host, port) {
 
 // ── SSH pool (key OR password) ──────────────────────────────────────────────
 
+/**
+ * Wrap a raw ssh2 SFTP handle so a stuck server can never hang a tool call:
+ * every method is bounded by the configured command timeout, and path args
+ * are normalized via toSftpPath() so Windows remotes (drive-letter paths)
+ * work too.
+ */
+function wrapSftp(client, sftp, config) {
+  const withTimeout = (fn) => (...args) =>
+    new Promise((r2, j2) => {
+      const timer = setTimeout(() => j2(new Error('sftp operation timed out')), config.commandTimeoutMs)
+      const done = (e, v) => {
+        clearTimeout(timer)
+        e ? j2(e) : r2(v)
+      }
+      try { fn(...args, done) } catch (e) { clearTimeout(timer); j2(e) }
+    })
+  const P = (p) => toSftpPath(p)
+  return {
+    readdir: (dir) => withTimeout((d, cb) => sftp.readdir(d, cb))(P(dir)),
+    stat: (p) => withTimeout((d, cb) => sftp.stat(d, cb))(P(p)),
+    lstat: (p) => withTimeout((d, cb) => sftp.lstat(d, cb))(P(p)),
+    mkdir: (dir) => withTimeout((d, cb) => sftp.mkdir(d, cb))(P(dir)),
+    readFile: (p) => withTimeout((d, cb) => sftp.readFile(d, cb))(P(p)),
+    writeFile: (p, data) => withTimeout((d, data2, cb) => sftp.writeFile(d, data2, cb))(P(p), data),
+  }
+}
+
+/**
+ * Run one exec stream to completion: collects stdout/stderr (bounded), settles
+ * on channel close or the configured command timeout. On timeout the remote
+ * command gets SIGTERM and the channel is hard-closed so a runaway process
+ * cannot keep holding the SSH connection.
+ */
+function runStream(client, stream, config, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+    let exitCode = null
+    let exitSignal = null
+    const hardCap = Math.max(config.maxOutputChars * 4, 1024 * 1024)
+    const settle = () => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      resolve({
+        code: exitCode,
+        signal: exitSignal,
+        stdout: truncate(stdout, config.maxOutputChars),
+        stderr: truncate(stderr, config.maxOutputChars),
+      })
+    }
+    const timer = setTimeout(() => {
+      if (settled) return
+      exitCode = -1
+      exitSignal = 'TIMEOUT'
+      // Kill the remote command (SIGTERM) rather than just dropping the
+      // channel, so a runaway process cannot keep running and holding
+      // the SSH connection after we've given up on its output. The hard
+      // close below frees the channel even if the process ignores it.
+      try {
+        if (typeof stream.signal === 'function') stream.signal('SIGTERM')
+      } catch {}
+      const hardClose = setTimeout(() => {
+        try { stream.close() } catch {}
+      }, 800)
+      if (typeof hardClose.unref === 'function') hardClose.unref()
+      settle()
+    }, timeoutMs || config.commandTimeoutMs)
+    stream.on('close', (code, signal) => {
+      if (settled) return
+      exitCode = code
+      exitSignal = signal
+      settle()
+    })
+    stream.on('data', (d) => {
+      if (stdout.length < hardCap) stdout += d
+    })
+    stream.stderr.on('data', (d) => {
+      if (stderr.length < hardCap) stderr += d
+    })
+    stream.on('error', (e) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      reject(new Error('ssh stream error: ' + ((e && e.message) || e)))
+    })
+  })
+}
+
 class SshPool {
   constructor(config) {
     this.config = config
@@ -590,6 +680,28 @@ class SshPool {
     return pending
   }
 
+  /**
+   * Drop the cached client and force a fresh connection on the next call.
+   * Called when a channel open fails (e.g. "Channel open failure: open
+   * failed") — the pooled SSH connection is usually dead server-side while
+   * keepalive has not yet noticed, and reusing it keeps failing. The epoch
+   * bump orphans any in-flight connect; the client is ended so ssh2 frees
+   * its sockets.
+   */
+  invalidate() {
+    this.epoch++
+    const client = this.client
+    this.client = null
+    const pending = this.connecting
+    this.connecting = null
+    if (pending && typeof pending.catch === 'function') {
+      try { pending.catch(() => {}) } catch {}
+    }
+    if (client) {
+      try { client.end() } catch {}
+    }
+  }
+
   _doConnect(epoch) {
     return new Promise((resolve, reject) => {
       const client = new Client()
@@ -657,59 +769,23 @@ class SshPool {
       (client) =>
         new Promise((resolve, reject) => {
           client.exec(command, (err, stream) => {
-            if (err) return reject(new Error('ssh exec failed: ' + ((err && err.message) || err)))
-            let stdout = ''
-            let stderr = ''
-            let settled = false
-            let exitCode = null
-            let exitSignal = null
-            const hardCap = Math.max(this.config.maxOutputChars * 4, 1024 * 1024)
-            const settle = () => {
-              if (settled) return
-              settled = true
-              clearTimeout(timer)
-              resolve({
-                code: exitCode,
-                signal: exitSignal,
-                stdout: truncate(stdout, this.config.maxOutputChars),
-                stderr: truncate(stderr, this.config.maxOutputChars),
-              })
+            if (err) {
+              // Same dead-connection recovery as sftp(): a channel open
+              // failure means the pooled connection is stale — drop it and
+              // retry ONCE on a fresh connection.
+              if (/channel open failure|open failed/i.test(String((err && err.message) || err))) {
+                this.invalidate()
+                return this.connect().then(
+                  (fresh) => fresh.exec(command, (err2, stream2) => {
+                    if (err2) return reject(new Error('ssh exec failed: ' + ((err2 && err2.message) || err2)))
+                    resolve(runStream(fresh, stream2, this.config, timeoutMs))
+                  }),
+                  (e2) => reject(new Error('ssh exec failed (reconnect): ' + ((e2 && e2.message) || e2))),
+                )
+              }
+              return reject(new Error('ssh exec failed: ' + ((err && err.message) || err)))
             }
-            const timer = setTimeout(() => {
-              if (settled) return
-              exitCode = -1
-              exitSignal = 'TIMEOUT'
-              // Kill the remote command (SIGTERM) rather than just dropping the
-              // channel, so a runaway process cannot keep running and holding
-              // the SSH connection after we've given up on its output. The hard
-              // close below frees the channel even if the process ignores it.
-              try {
-                if (typeof stream.signal === 'function') stream.signal('SIGTERM')
-              } catch {}
-              const hardClose = setTimeout(() => {
-                try { stream.close() } catch {}
-              }, 800)
-              if (typeof hardClose.unref === 'function') hardClose.unref()
-              settle()
-            }, timeoutMs || this.config.commandTimeoutMs)
-            stream.on('close', (code, signal) => {
-              if (settled) return
-              exitCode = code
-              exitSignal = signal
-              settle()
-            })
-            stream.on('data', (d) => {
-              if (stdout.length < hardCap) stdout += d
-            })
-            stream.stderr.on('data', (d) => {
-              if (stderr.length < hardCap) stderr += d
-            })
-            stream.on('error', (e) => {
-              if (settled) return
-              settled = true
-              clearTimeout(timer)
-              reject(new Error('ssh stream error: ' + ((e && e.message) || e)))
-            })
+            resolve(runStream(client, stream, this.config, timeoutMs))
           })
         }),
     )
@@ -723,26 +799,24 @@ class SshPool {
       (client) =>
         new Promise((resolve, reject) => {
           client.sftp((err, sftp) => {
-            if (err) return reject(new Error('ssh sftp failed: ' + ((err && err.message) || err)))
-            // Wrap a raw SFTP method so a stuck server can never hang a tool call.
-            const withTimeout = (fn) => (...args) =>
-              new Promise((r2, j2) => {
-                const timer = setTimeout(() => j2(new Error('sftp operation timed out')), this.config.commandTimeoutMs)
-                const done = (e, v) => {
-                  clearTimeout(timer)
-                  e ? j2(e) : r2(v)
-                }
-                try { fn(...args, done) } catch (e) { clearTimeout(timer); j2(e) }
-              })
-            const P = (p) => toSftpPath(p)
-            resolve({
-              readdir: (dir) => withTimeout((d, cb) => sftp.readdir(d, cb))(P(dir)),
-              stat: (p) => withTimeout((d, cb) => sftp.stat(d, cb))(P(p)),
-              lstat: (p) => withTimeout((d, cb) => sftp.lstat(d, cb))(P(p)),
-              mkdir: (dir) => withTimeout((d, cb) => sftp.mkdir(d, cb))(P(dir)),
-              readFile: (p) => withTimeout((d, cb) => sftp.readFile(d, cb))(P(p)),
-              writeFile: (p, data) => withTimeout((d, data2, cb) => sftp.writeFile(d, data2, cb))(P(p), data),
-            })
+            if (err) {
+              // Channel open failure usually means the pooled connection is
+              // dead server-side (idle timeout / network reset) while
+              // keepalive hasn't noticed yet. Drop it and retry ONCE on a
+              // fresh connection; a persistent error still rejects.
+              if (/channel open failure|open failed/i.test(String((err && err.message) || err))) {
+                this.invalidate()
+                return this.connect().then(
+                  (fresh) => fresh.sftp((err2, sftp2) => {
+                    if (err2) return reject(new Error('ssh sftp failed: ' + ((err2 && err2.message) || err2)))
+                    resolve(wrapSftp(fresh, sftp2, this.config))
+                  }),
+                  (e2) => reject(new Error('ssh sftp failed (reconnect): ' + ((e2 && e2.message) || e2))),
+                )
+              }
+              return reject(new Error('ssh sftp failed: ' + ((err && err.message) || err)))
+            }
+            resolve(wrapSftp(client, sftp, this.config))
           })
         }),
     )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Remote-work assistant for DeepSeek Harness: connect SSH (password or key), pick a remote workspace, operate on it with rw_pick_workspace / rw_list_dir / rw_read_file / rw_exec / rw_sync tools, and mirror it to a real local directory (SFTP) so the DSH native workspace can adopt it.",
   "license": "MIT",
   "author": "flymysql <flyphp@outlook.com>",