dsh-remote 0.5.8 → 0.5.10

package/lib/index.js

@@ -20,7 +20,6 @@ import { defineTool } from '@deepseek-ai/dsh-tools'
 import ssh2 from 'ssh2'
 import { readFileSync, mkdirSync, writeFileSync, existsSync, readdirSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { createHash } from 'node:crypto'
 import path from 'node:path'
 
 const { Client } = ssh2
@@ -42,7 +41,7 @@ export const Config = z.object({
   username: z.string().default(''),
   /** Password login (only when the remote has no key. Override the fallback below). */
   password: z.string().default(''),
-  /** Absolute private-key path; empty → ~/.ssh/id_rsa. */
+  /** Explicit SSH private-key path (optional; only used when supplied). Never auto-reads ~/.ssh. */
   privateKeyPath: z.string().default(''),
   /** Key passphrase when the key is encrypted. */
   passphrase: z.string().default(''),
@@ -107,11 +106,12 @@ function mirrorRootFor(host, user, port) {
   return path.join(homedir(), '.dsh', 'remote-workspaces', tag)
 }
 
-/** Local mirror dir for a specific remote path (idempotent → returns same dir). */
+/** Local mirror dir for a specific remote path (idempotent → returns same dir).
+ * Named after the remote directory's basename so the harness workspace label
+ * reads cleanly (e.g. .../project) instead of a concatenated hash string. */
 function mirrorDirFor(remotePath, host, user, port) {
   const base = remotePathBase(remotePath)
-  const h = createHash('sha1').update(`${host}:${port}:${remotePath}`).digest('hex').slice(0, 8)
-  return path.join(mirrorRootFor(host, user, port), `${base}-${h}`)
+  return path.join(mirrorRootFor(host, user, port), base)
 }
 
 /** Create the local mirror dir + a meta file describing its remote origin. */
@@ -236,7 +236,7 @@ class SshPool {
 
   resolveKeyPath() {
     const p = this.config.privateKeyPath
-    if (!p) return path.join(homedir(), '.ssh', 'id_rsa')
+    if (!p) return ''
     if (p.startsWith('~/') || p === '~') return path.join(homedir(), p.slice(1))
     return p
   }
@@ -296,13 +296,15 @@ class SshPool {
       if (this.config.password) {
         opts.password = this.config.password
       } else {
+        const keyPath = this.resolveKeyPath()
+        if (!keyPath) {
+          return fail(new Error('no credentials: set a password or a privateKeyPath to connect'))
+        }
         let key
         try {
-          key = readFileSync(this.resolveKeyPath())
+          key = readFileSync(keyPath)
         } catch (err) {
-          return fail(
-            new Error(`cannot read private key "${this.resolveKeyPath()}": ${err && err.message}`),
-          )
+          return fail(new Error(`cannot read private key "${keyPath}": ${err && err.message}`))
         }
         opts.privateKey = key
         opts.passphrase = this.config.passphrase || undefined
@@ -443,6 +445,31 @@ export async function apply(ctx, config) {
     return text
   }
 
+  /** Structured-listing of a remote dir: name + usable type. `dir` is decided by
+   * `[ -d ]`, which FOLLOWS symlinks — so a symlink to a directory is enterable
+   * (the picker can drill into it), while a file symlink stays a file. */
+  const listDirStructured = async (p, timeoutMs) => {
+    const target = p || '/'
+    const cmd =
+      `cd ${shq(target)} 2>/dev/null && for f in .[!.]* *; do ` +
+      `[ -e "$f" ] || [ -L "$f" ] || continue; ` +
+      `if [ -d "$f" ]; then printf 'd\\t%s\\n' "$f"; else printf 'f\\t%s\\n' "$f"; fi; done`
+    const res = await pool.exec(cmd, timeoutMs || config.commandTimeoutMs)
+    const items = []
+    if (res.code !== 0 && res.stderr) {
+      throw new Error('ls failed: ' + (res.stderr || '').trim())
+    }
+    for (const line of String(res.stdout || '').split('\n')) {
+      const idx = line.indexOf('\t')
+      if (idx < 0) continue
+      const type = line.slice(0, idx)
+      const name = line.slice(idx + 1)
+      if (name === '.' || name === '..' || !name) continue
+      items.push({ type: type === 'd' ? 'dir' : 'file', name })
+    }
+    return { path: target, items }
+  }
+
   // ── remote workspace state ────────────────────────────────────────────────
 
   const wsPath = () => (config.workspace || '').trim()
@@ -680,6 +707,63 @@ export async function apply(ctx, config) {
         return { text: await run(cmd, { timeoutMs: config.commandTimeoutMs }) }
       },
     }),
+
+    defineTool({
+      name: 'rw_write_file',
+      description:
+        'Write text to a file on the remote host (creating parent directories if needed). Path is absolute. Use this to create or overwrite a remote file directly, instead of round-tripping through a local mirror.',
+      parameters: {
+        path: { type: 'string', required: true, description: 'Absolute remote file path' },
+        content: { type: 'string', required: true, description: 'File content to write (overwrites existing file)' },
+        mkdir: { type: 'boolean', description: 'Create missing parent directories (default true)' },
+      },
+      output: {
+        schema: { type: 'object', additionalProperties: false, properties: { ok: { type: 'boolean', required: true }, bytes: { type: 'integer' }, text: { type: 'string' } } },
+        render: (_a, a) => [{ type: 'text', text: a.text || (a.ok ? 'written' : 'failed') }],
+      },
+      async execute(args) {
+        const p = normalizeRemotePath(String(args.path || ''))
+        if (!p || p === '/') throw new Error('rw_write_file: a file path is required')
+        const content = String(args.content == null ? '' : args.content)
+        let sftp
+        try {
+          sftp = await pool.sftp()
+        } catch (err) {
+          throw new Error('rw_write_file: sftp unavailable: ' + ((err && err.message) || err))
+        }
+        const mkdir = args.mkdir !== false
+        if (mkdir) {
+          const parent = remoteDirname(p)
+          // create each level from the root so mkdir -p semantics survive even
+          // when intermediate privileged-parent dirs don't allow create (best effort)
+          const segs = parent.split('/').filter(Boolean)
+          let cur = ''
+          for (const s of segs) {
+            cur += '/' + s
+            try { await sftp.mkdir(cur) } catch { /* exists or no perms */ }
+          }
+        }
+        const buf = Buffer.from(content, 'utf8')
+        await sftp.writeFile(p, buf)
+        const bytes = Buffer.byteLength(content, 'utf8')
+        return { ok: true, bytes, text: `wrote ${bytes} bytes to ${p}` }
+      },
+    }),
+
+    defineTool({
+      name: 'rw_disconnect',
+      description:
+        'Close the current SSH connection to the remote host, releasing the persistent pool. Useful to rotate connections or after a long idle.',
+      parameters: {},
+      output: {
+        schema: { type: 'object', additionalProperties: false, properties: { ok: { type: 'boolean', required: true }, text: { type: 'string' } } },
+        render: (_a, a) => [{ type: 'text', text: a.text }],
+      },
+      async execute() {
+        pool.close()
+        return { ok: true, text: 'disconnected' }
+      },
+    }),
   ]
 
   for (const t of tools) {
@@ -775,8 +859,8 @@ export async function apply(ctx, config) {
         try {
           const m = (req.url || '').match(/path=([^&]*)/)
           const p = m ? decodeURIComponent(m[1]) : wsPath()
-          const out = await run(`ls -la --color=never ${shq(p || '/')}`)
-          return sendJson(res, 200, { path: p, text: out })
+          const out = await listDirStructured(p || '/')
+          return sendJson(res, 200, { path: p, items: out.items })
         } catch (err) {
           return sendJson(res, 500, { error: String((err && err.message) || err) })
         }
@@ -893,6 +977,34 @@ export async function apply(ctx, config) {
         return sendJson(res, 405, { ok: false, error: 'method not allowed' })
       },
     },
+    {
+      kind: 'exact',
+      path: '/dsh-remote/test-connect',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: 'method not allowed' })
+        try {
+          const body = JSON.parse((await readBody(req)) || '{}')
+          const probe = new SshPool({
+            ...config,
+            host: String(body.host || config.host),
+            port: Number(body.port) || config.port,
+            username: String(body.username || config.username),
+            password: String(body.password || ''),
+            privateKeyPath: String(body.privateKeyPath || config.privateKeyPath),
+            passphrase: String(body.passphrase || ''),
+            connectTimeoutMs: Math.min(Math.max(Number(body.connectTimeoutMs) || config.connectTimeoutMs, 2000), 30000),
+            commandTimeoutMs: 10000,
+          })
+          const started = Date.now()
+          await probe.connect()
+          await probe.exec('true', 10000)
+          probe.close()
+          return sendJson(res, 200, { ok: true, host: probe.config.host, user: probe.config.username, latencyMs: Date.now() - started })
+        } catch (err) {
+          return sendJson(res, 200, { ok: false, error: String((err && err.message) || err) })
+        }
+      },
+    },
     {
       kind: 'exact',
       path: '/dsh-remote/current',

package/package.json

@@ -1,7 +1,17 @@
 {
   "name": "dsh-remote",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "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>",
+  "homepage": "https://github.com/flymysql/dsh-remote",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/flymysql/dsh-remote.git"
+  },
+  "bugs": {
+    "url": "https://github.com/flymysql/dsh-remote/issues"
+  },
   "keywords": [
     "deepseek-harness",
     "dsh",
@@ -23,7 +33,6 @@
     "lib",
     "cordis.patch.yml"
   ],
-  "license": "MIT",
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"