@goodandready/dsh-remote-workspace 0.1.0

package/lib/ssh-service.js

@@ -0,0 +1,176 @@
+import { Client } from 'ssh2';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export class SshService {
+  constructor(ctx) {
+    this.ctx = ctx;
+    /** @type {Map<string, Client>} */
+    this.connections = new Map();
+    /** @type {Map<string, any>} */
+    this.sftpSessions = new Map();
+  }
+
+  /**
+   * Resolve private key content either from direct string or file path
+   */
+  resolvePrivateKey(profile) {
+    if (profile.privateKey && profile.privateKey.trim()) {
+      return profile.privateKey;
+    }
+    if (profile.privateKeyPath) {
+      let resolvedPath = profile.privateKeyPath;
+      if (resolvedPath.startsWith('~')) {
+        resolvedPath = path.join(os.homedir(), resolvedPath.slice(1));
+      }
+      if (fs.existsSync(resolvedPath)) {
+        return fs.readFileSync(resolvedPath, 'utf8');
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * Connect to remote machine with pooling and keep-alive
+   */
+  async getConnection(profile) {
+    const connId = profile.id;
+    const existing = this.connections.get(connId);
+    if (existing && existing._sock && !existing._sock.destroyed) {
+      return existing;
+    }
+
+    return new Promise((resolve, reject) => {
+      const conn = new Client();
+      const connConfig = {
+        host: profile.host,
+        port: profile.port || 22,
+        username: profile.username || 'root',
+        keepaliveInterval: 15000,
+        keepaliveCountMax: 3,
+        readyTimeout: 20000
+      };
+
+      if (profile.authType === 'password') {
+        connConfig.password = profile.password;
+      } else if (profile.authType === 'agent') {
+        connConfig.agent = process.env.SSH_AUTH_SOCK;
+      } else {
+        const privateKey = this.resolvePrivateKey(profile);
+        if (privateKey) {
+          connConfig.privateKey = privateKey;
+          if (profile.passphrase) {
+            connConfig.passphrase = profile.passphrase;
+          }
+        } else if (profile.password) {
+          connConfig.password = profile.password;
+        }
+      }
+
+      conn.on('ready', () => {
+        this.connections.set(connId, conn);
+        resolve(conn);
+      });
+
+      conn.on('error', (err) => {
+        this.connections.delete(connId);
+        this.sftpSessions.delete(connId);
+        reject(err);
+      });
+
+      conn.on('close', () => {
+        this.connections.delete(connId);
+        this.sftpSessions.delete(connId);
+      });
+
+      conn.connect(connConfig);
+    });
+  }
+
+  /**
+   * Test connection and measure ping / detect OS
+   */
+  async testConnection(profile) {
+    const start = Date.now();
+    const conn = await this.getConnection(profile);
+    const latency = Date.now() - start;
+
+    return new Promise((resolve) => {
+      conn.exec('uname -s -r -m || ver', (err, stream) => {
+        if (err) {
+          return resolve({ success: true, latency, os: 'Unknown' });
+        }
+        let output = '';
+        stream.on('data', (d) => { output += d.toString(); });
+        stream.on('close', () => {
+          resolve({ success: true, latency, os: output.trim() });
+        });
+      });
+    });
+  }
+
+  /**
+   * Obtain active SFTP wrapper
+   */
+  async getSftp(profile) {
+    const connId = profile.id;
+    if (this.sftpSessions.has(connId)) {
+      return this.sftpSessions.get(connId);
+    }
+    const conn = await this.getConnection(profile);
+    return new Promise((resolve, reject) => {
+      conn.sftp((err, sftp) => {
+        if (err) return reject(err);
+        this.sftpSessions.set(connId, sftp);
+        resolve(sftp);
+      });
+    });
+  }
+
+  /**
+   * Execute command on remote host
+   */
+  async exec(profile, command, cwd, onData) {
+    const conn = await this.getConnection(profile);
+    const shellCmd = cwd ? `cd ${JSON.stringify(cwd)} && ${command}` : command;
+
+    return new Promise((resolve, reject) => {
+      conn.exec(shellCmd, (err, stream) => {
+        if (err) return reject(err);
+        let stdout = '';
+        let stderr = '';
+        stream.on('data', (data) => {
+          const str = data.toString();
+          stdout += str;
+          if (onData) onData({ type: 'stdout', data: str });
+        });
+        stream.stderr.on('data', (data) => {
+          const str = data.toString();
+          stderr += str;
+          if (onData) onData({ type: 'stderr', data: str });
+        });
+        stream.on('close', (code, signal) => {
+          resolve({ code: code ?? 0, signal, stdout, stderr });
+        });
+      });
+    });
+  }
+
+  disconnect(profileId) {
+    const conn = this.connections.get(profileId);
+    if (conn) {
+      conn.end();
+      this.connections.delete(profileId);
+      this.sftpSessions.delete(profileId);
+    }
+  }
+
+  disconnectAll() {
+    for (const [id, conn] of this.connections.entries()) {
+      try { conn.end(); } catch (_) {}
+    }
+    this.connections.clear();
+    this.sftpSessions.clear();
+  }
+}

package/lib/tools.js

@@ -0,0 +1,138 @@
+export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, getActiveProfile) {
+  if (!ctx.tools || typeof ctx.tools.register !== 'function') {
+    return;
+  }
+
+  const genericOutput = {
+    schema: { type: 'object' },
+    render: (_args, value) => ({ type: 'text', content: typeof value === 'string' ? value : JSON.stringify(value, null, 2) })
+  };
+
+  // 1. remote_exec
+  ctx.tools.register({
+    name: 'remote_exec',
+    description: 'Execute bash/shell command on the active remote workspace host',
+    parameters: {
+      command: { type: 'string', required: true, description: 'Command line to execute on remote server' },
+      cwd: { type: 'string', description: 'Working directory on remote server (defaults to remote workspace)' }
+    },
+    output: genericOutput,
+    async execute(args) {
+      const profile = getActiveProfile();
+      if (!profile) throw new Error('No active remote workspace profile selected');
+      const dir = args.cwd || profile.remoteWorkspace;
+      const res = await sshService.exec(profile, args.command, dir);
+      return {
+        exitCode: res.code,
+        stdout: res.stdout,
+        stderr: res.stderr
+      };
+    }
+  });
+
+  // 2. remote_fs
+  ctx.tools.register({
+    name: 'remote_fs',
+    description: 'Perform file operations (read, write, stat, list, mkdir, remove) on remote workspace',
+    parameters: {
+      action: {
+        type: 'string',
+        required: true,
+        description: 'Filesystem operation: read, write, stat, list, mkdir, remove'
+      },
+      path: { type: 'string', required: true, description: 'Absolute or workspace-relative remote path' },
+      content: { type: 'string', description: 'Content for write action' },
+      recursive: { type: 'boolean', description: 'Recursive flag for remove action' }
+    },
+    output: genericOutput,
+    async execute(args) {
+      const profile = getActiveProfile();
+      if (!profile) throw new Error('No active remote workspace profile selected');
+      const { action, path: targetPath, content, recursive } = args;
+
+      switch (action) {
+        case 'read': {
+          const data = await remoteFs.readFile(profile, targetPath, 'utf8');
+          return { content: data };
+        }
+        case 'write': {
+          if (content === undefined) throw new Error('Content is required for write action');
+          const res = await remoteFs.writeFile(profile, targetPath, content, 'utf8');
+          return res;
+        }
+        case 'stat': {
+          return await remoteFs.stat(profile, targetPath);
+        }
+        case 'list': {
+          const entries = await remoteFs.listDir(profile, targetPath);
+          return { entries };
+        }
+        case 'mkdir': {
+          return await remoteFs.mkdir(profile, targetPath);
+        }
+        case 'remove': {
+          return await remoteFs.remove(profile, targetPath, recursive);
+        }
+        default:
+          throw new Error(`Unknown action: ${action}`);
+      }
+    }
+  });
+
+  // 3. remote_sync
+  ctx.tools.register({
+    name: 'remote_sync',
+    description: 'Perform 3-way conflict-aware synchronization between local mirror and remote server',
+    parameters: {
+      direction: { type: 'string', required: true, description: 'pull (remote -> local) or push (local -> remote)' },
+      force: { type: 'boolean', description: 'Overwrite conflicts if true (use with caution)' },
+      dryRun: { type: 'boolean', description: 'Simulate changes without writing files' }
+    },
+    output: genericOutput,
+    async execute(args) {
+      const profile = getActiveProfile();
+      if (!profile) throw new Error('No active remote workspace profile selected');
+      if (!profile.remoteWorkspace || !profile.localMirrorPath) {
+        throw new Error('Both remoteWorkspace and localMirrorPath must be configured');
+      }
+
+      if (args.direction === 'pull') {
+        return await mirrorSync.pull(profile, profile.remoteWorkspace, profile.localMirrorPath, args.dryRun);
+      } else {
+        return await mirrorSync.push(profile, profile.localMirrorPath, profile.remoteWorkspace, args.force, args.dryRun);
+      }
+    }
+  });
+
+  // 4. remote_tunnel
+  ctx.tools.register({
+    name: 'remote_tunnel',
+    description: 'Manage SSH port forwarding tunnels (start, stop, list)',
+    parameters: {
+      action: { type: 'string', required: true, description: 'start, stop, or list' },
+      localPort: { type: 'number', description: 'Local listening port' },
+      remotePort: { type: 'number', description: 'Remote destination port' },
+      tunnelId: { type: 'string', description: 'Tunnel ID to stop' }
+    },
+    output: genericOutput,
+    async execute(args) {
+      const profile = getActiveProfile();
+      if (!profile && args.action !== 'list' && args.action !== 'stop') {
+        throw new Error('No active remote workspace profile selected');
+      }
+
+      if (args.action === 'list') {
+        return { tunnels: tunnelService.listActiveTunnels() };
+      }
+      if (args.action === 'start') {
+        if (!args.localPort || !args.remotePort) throw new Error('localPort and remotePort required to start tunnel');
+        return await tunnelService.startLocalTunnel(profile, args.localPort, '127.0.0.1', args.remotePort);
+      }
+      if (args.action === 'stop') {
+        if (!args.tunnelId) throw new Error('tunnelId required to stop tunnel');
+        const ok = tunnelService.stopTunnel(args.tunnelId);
+        return { success: ok };
+      }
+    }
+  });
+}

package/lib/tunnel-service.js

@@ -0,0 +1,88 @@
+import net from 'node:net';
+
+export class TunnelService {
+  /**
+   * @param {import('./ssh-service.js').SshService} sshService
+   */
+  constructor(sshService) {
+    this.sshService = sshService;
+    /** @type {Map<string, { server?: net.Server, profileId: string, localPort: number, remotePort: number }>} */
+    this.activeTunnels = new Map();
+  }
+
+  /**
+   * Start Local Port Forwarding: 127.0.0.1:localPort -> Remote:targetHost:targetPort
+   */
+  async startLocalTunnel(profile, localPort, targetHost = '127.0.0.1', targetPort) {
+    const tunnelId = `${profile.id}:${localPort}->${targetPort}`;
+    if (this.activeTunnels.has(tunnelId)) {
+      return { success: true, message: 'Tunnel already active', tunnelId };
+    }
+
+    const conn = await this.sshService.getConnection(profile);
+
+    return new Promise((resolve, reject) => {
+      const server = net.createServer((socket) => {
+        conn.forwardOut(
+          '127.0.0.1',
+          socket.remotePort || 0,
+          targetHost,
+          targetPort,
+          (err, stream) => {
+            if (err) {
+              socket.destroy();
+              return;
+            }
+            socket.pipe(stream).pipe(socket);
+          }
+        );
+      });
+
+      server.listen(localPort, '127.0.0.1', () => {
+        this.activeTunnels.set(tunnelId, {
+          server,
+          profileId: profile.id,
+          localPort,
+          remotePort: targetPort
+        });
+        resolve({ success: true, tunnelId, localPort, targetPort });
+      });
+
+      server.on('error', (err) => {
+        this.activeTunnels.delete(tunnelId);
+        reject(err);
+      });
+    });
+  }
+
+  /**
+   * Stop active tunnel
+   */
+  stopTunnel(tunnelId) {
+    const tunnel = this.activeTunnels.get(tunnelId);
+    if (tunnel && tunnel.server) {
+      tunnel.server.close();
+      this.activeTunnels.delete(tunnelId);
+      return true;
+    }
+    return false;
+  }
+
+  listActiveTunnels() {
+    return Array.from(this.activeTunnels.entries()).map(([id, t]) => ({
+      id,
+      profileId: t.profileId,
+      localPort: t.localPort,
+      remotePort: t.remotePort
+    }));
+  }
+
+  stopAll() {
+    for (const [id, t] of this.activeTunnels.entries()) {
+      if (t.server) {
+        try { t.server.close(); } catch (_) {}
+      }
+    }
+    this.activeTunnels.clear();
+  }
+}

package/lib/types.js

@@ -0,0 +1,29 @@
+/**
+ * @typedef {Object} MachineProfile
+ * @property {string} id
+ * @property {string} name
+ * @property {string} host
+ * @property {number} port
+ * @property {string} username
+ * @property {'key'|'password'|'agent'} authType
+ * @property {string} [privateKeyPath]
+ * @property {string} [privateKey]
+ * @property {string} [passphrase]
+ * @property {string} [password]
+ * @property {string} [jumpHost]
+ * @property {string} [remoteWorkspace]
+ * @property {string} [localMirrorPath]
+ * @property {number} [lastPingMs]
+ * @property {string} [remoteOs]
+ */
+
+/**
+ * @typedef {Object} TunnelConfig
+ * @property {string} id
+ * @property {string} machineId
+ * @property {'local'|'reverse'} direction
+ * @property {number} localPort
+ * @property {string} remoteHost
+ * @property {number} remotePort
+ * @property {boolean} active
+ */

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@goodandready/dsh-remote-workspace",
+  "version": "0.1.0",
+  "description": "Enterprise Remote Workspace Plugin for DeepSeek Harness: SSH2 connection pool, SFTP operations, 3-way conflict-aware mirror sync, port forwarding, and native DSH UI.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/",
+    "cordis.patch.yml",
+    "README.md",
+    "README.ru.md",
+    "README.zh.md",
+    "docs/",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "node --test test/*.test.mjs"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "remote",
+    "ssh",
+    "sftp",
+    "workspace",
+    "tunnel",
+    "sync"
+  ],
+  "homepage": "https://github.com/GooDAnDReaDY/dsh-remote-workspace#readme",
+  "bugs": {
+    "url": "https://github.com/GooDAnDReaDY/dsh-remote-workspace/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GooDAnDReaDY/dsh-remote-workspace.git"
+  },
+  "license": "MIT",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": []
+    }
+  },
+  "dependencies": {
+    "ssh2": "^1.17.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ssh2": "^1.15.4",
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}