dsh-remote 0.8.34 → 0.8.35

package/lib/pool.js

@@ -332,10 +332,16 @@ export class SshPool {
    * the remote process stdin (used by the Git Bash `-s` mode). */
   _execRaw(command, opts, stdinWriter) {
     const timeoutMs = (opts && opts.timeoutMs) || this.config.commandTimeoutMs
+    const signal = opts && opts.signal
     return this.connect().then(
       (client) =>
         new Promise((resolve, reject) => {
           let retried = false
+          // Caller cancellation (issue #44): a tool that hands us exec.signal
+          // expects the remote command to stop when the turn is cancelled.
+          // Resolve the same shape as a timeout so callers need no new branch.
+          let onAbort = null
+          const cleanupAbort = () => { if (signal && onAbort) signal.removeEventListener('abort', onAbort) }
           const runOn = (c) => {
             const execOpts = {}
             if (opts && opts.pty) execOpts.pty = true
@@ -366,6 +372,7 @@ export class SshPool {
                 if (settled) return
                 settled = true
                 clearTimeout(timer)
+                cleanupAbort()
                 resolve({
                   code: exitCode,
                   signal: exitSignal,
@@ -389,10 +396,33 @@ export class SshPool {
                 if (typeof hardClose.unref === 'function') hardClose.unref()
                 settle()
               }, timeoutMs)
-              stream.on('close', (code, signal) => {
+              if (signal) {
+                if (signal.aborted) {
+                  try { if (typeof stream.signal === 'function') stream.signal('SIGTERM') } catch {}
+                  try { stream.close() } catch {}
+                  exitCode = -1
+                  exitSignal = 'ABORTED'
+                  return settle()
+                }
+                onAbort = () => {
+                  if (settled) return
+                  exitCode = -1
+                  exitSignal = 'ABORTED'
+                  try { if (typeof stream.signal === 'function') stream.signal('SIGTERM') } catch {}
+                  const hardClose = setTimeout(() => { try { stream.close() } catch {} }, 500)
+                  if (typeof hardClose.unref === 'function') hardClose.unref()
+                  settle()
+                }
+                signal.addEventListener('abort', onAbort, { once: true })
+              }
+              stream.on('close', (code, sigName) => {
                 if (settled) return
                 exitCode = code
-                exitSignal = signal
+                // `sigName` is the signal NAME that killed the remote process
+                // (e.g. 'SIGTERM'), not the caller's AbortSignal. The rename
+                // matters: `signal` in this scope is the AbortSignal, and
+                // assigning it here would leak an object into the result.
+                exitSignal = sigName
                 settle()
               })
               stream.on('data', (d) => {
@@ -405,6 +435,7 @@ export class SshPool {
                 if (settled) return
                 settled = true
                 clearTimeout(timer)
+                cleanupAbort()
                 reject(new Error('ssh stream error: ' + ((e && e.message) || e)))
               })
               if (stdinWriter) {
@@ -424,60 +455,100 @@ export class SshPool {
         new Promise((resolve, reject) => {
           let retried = false
           const runOn = (c) => {
-            c.sftp((err, sftp) => {
-              if (err) {
-                // Same dead-connection recovery as exec(): a channel open
-                // failure — or a session termination (remote closed the
-                // SFTP subchannel, e.g. transient network blip / sshd idle
-                // drop) — means the pooled connection is stale: drop it and
-                // retry ONCE on a fresh connection.
-                if (!retried && /channel open failure|open failed|unexpected sftp session termination|session termination|disconnect/i.test(String((err && err.message) || err))) {
-                  retried = true
-                  this.invalidate()
-                  return this.connect().then(
-                    (fresh) => runOn(fresh),
-                    (e2) => reject(new Error('ssh sftp failed (reconnect): ' + ((e2 && e2.message) || e2))),
-                  )
-                }
-                return reject(new Error('ssh sftp failed: ' + ((err && err.message) || err)))
-              }
-              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)
+            // Bound the subchannel open itself, per attempt. Without this, a
+            // remote whose sftp subsystem is unresponsive (overloaded sshd,
+            // exceeded MaxSessions, half-open TCP) leaves `c.sftp(cb)` parked
+            // forever with no callback — issue #44 point 3. ssh2 only calls back
+            // on success or on a channel error, and a wedged peer produces
+            // neither.
+            //
+            // The timer must be created per attempt, not once outside: the
+            // callback clears it, so a single outer timer would leave the retry
+            // (below) with no timeout at all.
+            let timedOut = false
+            const attemptTimer = setTimeout(() => {
+              timedOut = true
+              reject(new Error(`ssh sftp open timed out after ${this.config.commandTimeoutMs}ms`))
+            }, this.config.commandTimeoutMs)
+            if (typeof attemptTimer.unref === 'function') attemptTimer.unref()
+            const clearAttempt = () => { clearTimeout(attemptTimer) }
+            try {
+              c.sftp((err, sftp) => {
+                clearAttempt()
+                if (timedOut) return
+                if (err) {
+                  // Same dead-connection recovery as exec(): a channel open
+                  // failure — or a session termination (remote closed the
+                  // SFTP subchannel, e.g. transient network blip / sshd idle
+                  // drop) — means the pooled connection is stale: drop it and
+                  // retry ONCE on a fresh connection.
+                  if (!retried && /channel open failure|open failed|unexpected sftp session termination|session termination|disconnect/i.test(String((err && err.message) || err))) {
+                    retried = true
+                    this.invalidate()
+                    return this.connect().then(
+                      (fresh) => runOn(fresh),
+                      (e2) => reject(new Error('ssh sftp failed (reconnect): ' + ((e2 && e2.message) || e2))),
+                    )
                   }
-                  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)),
-                rmdir: (dir) => withTimeout((d, cb) => sftp.rmdir(d, cb))(P(dir)),
-                unlink: (p) => withTimeout((d, cb) => sftp.unlink(d, cb))(P(p)),
-                rename: (p, d) => withTimeout((a, b, cb) => sftp.rename(a, b, cb))(P(p), P(d)),
-                realpath: (p) => withTimeout((d, cb) => sftp.realpath(d, cb))(P(p)),
-                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),
-                fastGet: (p, lp) => withTimeout((d, l, cb) => sftp.fastGet(d, l, cb))(P(p), lp),
-                fastPut: (lp, p) => withTimeout((l, d, cb) => sftp.fastPut(l, d, cb))(lp, P(p)),
-                // Range read for oversized previews: never downloads the whole file.
-                readPartial: (p, offset, length) => withTimeout((d, off, len, cb) => {
-                  sftp.open(d, 'r', (e, handle) => {
-                    if (e) return cb(e)
-                    const buf = Buffer.alloc(len)
-                    sftp.read(handle, buf, 0, len, off, (e2, bytesRead, data) => {
-                      sftp.close(handle, () => {})
-                      if (e2) return cb(e2)
-                      cb(null, Buffer.isBuffer(data) ? data.subarray(0, bytesRead) : buf.subarray(0, bytesRead))
-                    })
+                  return reject(new Error('ssh sftp failed: ' + ((err && err.message) || err)))
+                }
+                // A dead channel must fail fast. ssh2's own EOF handling only
+                // rejects the requests that were pending at that moment
+                // (SFTP.js cleanupRequests); every request issued afterwards is
+                // registered in `_requests` and never answered. Without the flag
+                // below each such call waits out the full commandTimeoutMs — so a
+                // tree walk over N entries costs N × 2 × timeout, i.e. days on a
+                // large directory (issue #44). Mark the channel dead on EOF/close
+                // and reject immediately from then on.
+                let dead = false
+                const markDead = () => { dead = true }
+                if (typeof sftp.on === 'function') {
+                  sftp.on('end', markDead)
+                  sftp.on('close', markDead)
+                  sftp.on('error', markDead)
+                }
+                const withTimeout = (fn) => (...args) =>
+                  new Promise((r2, j2) => {
+                    if (dead) return j2(new Error('sftp channel closed'))
+                    const timer = setTimeout(() => j2(new Error('sftp operation timed out')), this.config.commandTimeoutMs)
+                    const finish = (e, v) => {
+                      clearTimeout(timer)
+                      e ? j2(e) : r2(v)
+                    }
+                    try { fn(...args, finish) } catch (e) { clearTimeout(timer); j2(e) }
                   })
-                })(P(p), offset, length),
+                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)),
+                  rmdir: (dir) => withTimeout((d, cb) => sftp.rmdir(d, cb))(P(dir)),
+                  unlink: (p) => withTimeout((d, cb) => sftp.unlink(d, cb))(P(p)),
+                  rename: (p, d) => withTimeout((a, b, cb) => sftp.rename(a, b, cb))(P(p), P(d)),
+                  realpath: (p) => withTimeout((d, cb) => sftp.realpath(d, cb))(P(p)),
+                  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),
+                  fastGet: (p, lp) => withTimeout((d, l, cb) => sftp.fastGet(d, l, cb))(P(p), lp),
+                  fastPut: (lp, p) => withTimeout((l, d, cb) => sftp.fastPut(l, d, cb))(lp, P(p)),
+                  // Range read for oversized previews: never downloads the whole file.
+                  readPartial: (p, offset, length) => withTimeout((d, off, len, cb) => {
+                    sftp.open(d, 'r', (e, handle) => {
+                      if (e) return cb(e)
+                      const buf = Buffer.alloc(len)
+                      sftp.read(handle, buf, 0, len, off, (e2, bytesRead, data) => {
+                        sftp.close(handle, () => {})
+                        if (e2) return cb(e2)
+                        cb(null, Buffer.isBuffer(data) ? data.subarray(0, bytesRead) : buf.subarray(0, bytesRead))
+                      })
+                    })
+                  })(P(p), offset, length),
+                })
               })
-            })
+            } catch (e) {
+              clearAttempt()
+              reject(new Error('ssh sftp failed: ' + ((e && e.message) || e)))
+            }
           }
           runOn(client)
         }),

package/lib/search.js

@@ -46,7 +46,20 @@ function looksBinary(buf) {
 
 /**
  * Recursively search a remote directory.
- * @returns {Promise<{matches: Array<{path, line, text}>, scanned: number, truncated: boolean}>}
+ *
+ * Cancellation (issue #44): the walk takes an AbortSignal and checks it at every
+ * directory and every entry. Before this it was completely uninterruptible —
+ * no signal was accepted and no flag was consulted — so a large-tree search
+ * could never be stopped: DSH tool cancellation is *cooperative*
+ * (@deepseek-ai/dsh-tool-call-timeout-policy can only ask a tool to stop), which
+ * meant `session/cancel`, steering, and the tool timeout policy all had no
+ * effect and the turn stayed `running` forever. On abort we return the partial
+ * result instead of throwing, so the model still gets whatever was found.
+ *
+ * @param {object} sftp - pooled SFTP client
+ * @param {string} rootDir
+ * @param {object} opts - `signal` (AbortSignal), `maxDurationMs`, plus the caps below
+ * @returns {Promise<{matches: Array<{path, line, text}>, scanned: number, truncated: boolean, cancelled?: boolean}>}
  */
 export async function searchTree(sftp, rootDir, opts = {}) {
   const {
@@ -57,15 +70,27 @@ export async function searchTree(sftp, rootDir, opts = {}) {
     maxDepth = 12,
     maxFiles = 20000,
     maxScanBytes = 1024 * 1024,
+    maxDurationMs = 0, // 0 = no wall-clock budget
     isIgnored = () => false,
+    signal,
   } = opts
 
   const matches = []
   let scanned = 0
   let truncated = false
+  let cancelled = false
+  const startedAt = Date.now()
+
+  /** True when the caller asked us to stop (abort, or the time budget is spent). */
+  const shouldStop = () => {
+    if (cancelled || truncated) return true
+    if (signal && signal.aborted) { cancelled = true; return true }
+    if (maxDurationMs > 0 && Date.now() - startedAt >= maxDurationMs) { truncated = true; return true }
+    return false
+  }
 
   const walk = async (dir, depth) => {
-    if (truncated || scanned >= maxFiles) return
+    if (shouldStop() || scanned >= maxFiles) return
     let entries = []
     try { entries = (await sftp.readdir(dir)) || [] } catch { return }
     const dirs = []
@@ -77,29 +102,32 @@ export async function searchTree(sftp, rootDir, opts = {}) {
     }
     // Depth-first, dirs first, but stop as soon as we hit caps.
     for (const name of dirs) {
-      if (truncated || scanned >= maxFiles) return
+      if (shouldStop() || scanned >= maxFiles) return
       if (depth <= 0) continue
       const sub = joinRemotePath(dir, name)
       if (isIgnored(name, true)) continue
       await walk(sub, depth - 1)
     }
-    if (truncated || scanned >= maxFiles) return
+    if (shouldStop() || scanned >= maxFiles) return
 
     const fileNames = entries
       .filter((e) => !(e.attrs && e.attrs.isDirectory && e.attrs.isDirectory()))
       .map((e) => String(e.filename))
       .filter((n) => n !== '.' && n !== '..')
     await mapLimit(fileNames, 4, async (name) => {
-      if (truncated || scanned >= maxFiles || matches.length >= maxMatches) return
+      // Checked per entry: this is the loop that used to run for hours.
+      if (shouldStop() || scanned >= maxFiles || matches.length >= maxMatches) return
       if (glob && !matchGlob(name, glob)) return
       if (isIgnored(name, false)) return
       const fp = joinRemotePath(dir, name)
       scanned++
       let st
       try { st = await sftp.stat(fp) } catch { return }
+      if (shouldStop()) return
       if (st.size > maxScanBytes) return
       let buf
       try { buf = await sftp.readFile(fp) } catch { return }
+      if (shouldStop()) return
       if (looksBinary(buf)) return
       const content = buf.toString('utf8').replace(/\r\n/g, '\n')
       const lines = content.split('\n')
@@ -124,7 +152,7 @@ export async function searchTree(sftp, rootDir, opts = {}) {
 
   await walk(rootDir, maxDepth)
   if (scanned >= maxFiles) truncated = true
-  return { matches, scanned, truncated }
+  return { matches, scanned, truncated, cancelled }
 }
 
 function parseGrepLines(stdout, maxMatches) {
@@ -151,7 +179,12 @@ export async function searchViaShell(pool, rootDir, opts = {}) {
     glob,
     contextLines = 0,
     maxMatches = 500,
+    signal,
   } = opts
+  // Honour an already-aborted signal before spawning a remote grep on a huge tree.
+  if (signal && signal.aborted) {
+    return { matches: [], scanned: 0, truncated: false, cancelled: true, via: 'none' }
+  }
   const ic = ignoreCase ? ' -i' : ''
   const globFlag = glob ? ` --glob ${shq(glob)}` : ''
   const ctx = contextLines > 0 ? ` -C ${Number(contextLines)}` : ''
@@ -159,7 +192,14 @@ export async function searchViaShell(pool, rootDir, opts = {}) {
   const grepGlob = glob ? ` --include=${shq(glob)}` : ''
   const grep = `grep -R -n -I -E${ic}${grepGlob}${ctx} -- ${shq(pattern)} ${shq(rootDir)}`
   const script = `if command -v rg >/dev/null 2>&1; then ${rg}; elif command -v grep >/dev/null 2>&1; then ${grep}; else exit 127; fi`
-  const res = await pool.exec(script, { timeoutMs: opts.timeoutMs })
+  const res = await pool.exec(script, { timeoutMs: opts.timeoutMs, signal })
+  // A cancelled call must return as cancelled (with whatever partial output the
+  // remote produced), NOT throw: throwing would make searchRemote fall through
+  // to the slower SFTP walk, i.e. keep running after the caller said stop.
+  if (res.signal === 'ABORTED') {
+    const partial = parseGrepLines(res.stdout, maxMatches)
+    return { matches: partial.matches, scanned: partial.matches.length, truncated: false, cancelled: true, via: 'none' }
+  }
   // 0 = hits, 1 = no hits; other codes mean the tools are missing / failed.
   if (res.signal === 'TIMEOUT') throw new Error('search timed out')
   if (res.code !== 0 && res.code !== 1) throw new Error(res.stderr || `search exit ${res.code}`)
@@ -178,7 +218,12 @@ export async function searchRemote(pool, rootDir, opts = {}) {
     try {
       const fast = await searchViaShell(pool, rootDir, opts)
       if (fast && Array.isArray(fast.matches)) return fast
-    } catch { /* missing rg/grep or Windows-like remote → SFTP walk */ }
+    } catch (e) {
+      // An abort is terminal, not a "try the slower fallback" signal.
+      if (opts.signal && opts.signal.aborted) {
+        return { matches: [], scanned: 0, truncated: false, cancelled: true, via: 'none' }
+      }
+    }
   }
   const sftp = await pool.sftp()
   return searchTree(sftp, rootDir, opts)

package/lib/update.js

@@ -96,7 +96,18 @@ export function gtVersion(a, b) {
   return false
 }
 
-/** Query the npm registry for the latest release; resolves null on any failure. */
+/**
+ * 查询 npm registry 的最新版本。
+ *
+ * 返回 `{ version }` 或 `{ error }`（**不再把一切失败压成 null**）。
+ *
+ * 为什么要区分失败原因：原先任何失败都返回 `null`，调用方只能笼统报
+ * "无法连接 npm registry"。实测踩过：本机被 npm 限流（`/latest` 返回 **429**，
+ * 而同一时刻 registry 根路径是 200、CI 从另一个出口 IP 也能正常取到），
+ * 却被显示成"连不上"——把"等一下就好"误导成"网络坏了"。429/超时/离线
+ * 三者的处置完全不同，必须让用户看到真实原因。
+ * @param timeoutMs - 超时（看门狗只负责中止，不影响进程存活）。
+ */
 export async function fetchLatestVersion(timeoutMs = 8000) {
   try {
     const controller = new AbortController()
@@ -104,16 +115,28 @@ export async function fetchLatestVersion(timeoutMs = 8000) {
     // 纯看门狗：调用方并不 await 它，所以必须 unref，否则这一段超时窗口
     // 会拖住事件循环、让本该退出的短命进程（脚本、测试）多挂数秒。
     if (typeof timer.unref === 'function') timer.unref()
+    let res
     try {
-      const res = await fetch(REGISTRY_URL, { signal: controller.signal, headers: { accept: 'application/json' } })
-      if (!res.ok) return null
-      const data = await res.json()
-      return typeof data?.version === 'string' && data.version ? data.version : null
+      res = await fetch(REGISTRY_URL, { signal: controller.signal, headers: { accept: 'application/json' } })
     } finally {
       clearTimeout(timer)
     }
-  } catch {
-    return null
+    if (res.status === 429) {
+      return { error: 'npm registry 限流（HTTP 429）——请求过于频繁，稍后会自动恢复', reason: 'rate-limited', status: 429 }
+    }
+    if (!res.ok) {
+      return { error: `npm registry 返回 HTTP ${res.status}`, reason: 'http', status: res.status }
+    }
+    const data = await res.json().catch(() => null)
+    const version = typeof data?.version === 'string' && data.version ? data.version : null
+    if (!version) return { error: 'npm registry 响应里没有可用的版本号', reason: 'malformed' }
+    return { version }
+  } catch (err) {
+    const aborted = err?.name === 'AbortError'
+    return {
+      error: aborted ? `连接 npm registry 超时（${timeoutMs}ms）` : '无法连接 npm registry',
+      reason: aborted ? 'timeout' : 'network',
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-remote",
-  "version": "0.8.34",
+  "version": "0.8.35",
   "description": "Remote-work assistant for DeepSeek Harness: connect SSH (password/key/agent/keyboard-interactive/proxy jump), pick a remote workspace, operate on it with 20 rw_* tools (incl. rw_edit/rw_stat/rw_mkdir/rw_remove/rw_move/rw_forward), conflict-aware mirror sync, port forwarding, optional side-bar remote file editing, audit log, keychain passwords.",
   "license": "MIT",
   "author": "flymysql <flyphp@outlook.com>",