@goodandready/dsh-remote-workspace 0.2.0 → 0.3.1

package/lib/ssh-config-parser.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export class SshConfigParser {
+  /**
+   * Parse ssh config string into DSH remote profiles
+   * @param {string} text
+   * @returns {Array<any>}
+   */
+  static parse(text) {
+    if (!text || typeof text !== 'string') return [];
+
+    const lines = text.split('\n');
+    const profiles = [];
+    let current = null;
+
+    for (let rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith('#')) continue;
+
+      // Key Value pair (can be separated by whitespace or '=')
+      const match = line.match(/^(\w+)(?:\s+|=)(.+)$/);
+      if (!match) continue;
+
+      const key = match[1].toLowerCase();
+      const val = match[2].trim().replace(/^["']|["']$/g, '');
+
+      if (key === 'host') {
+        // Skip wildcards like Host *
+        if (val === '*' || val.includes('*') || val.includes('?')) {
+          current = null;
+          continue;
+        }
+
+        if (current && current.host) {
+          profiles.push(current);
+        }
+
+        current = {
+          id: `ssh-cfg-${val.toLowerCase().replace(/[^a-z0-9_-]/g, '-')}`,
+          name: val,
+          host: val,
+          port: 22,
+          username: os.userInfo().username || 'root',
+          authType: 'key',
+          privateKey: '~/.ssh/id_ed25519',
+          remoteProjectDir: '/root',
+          jumpHostId: ''
+        };
+      } else if (current) {
+        if (key === 'hostname') {
+          current.host = val;
+        } else if (key === 'user') {
+          current.username = val;
+        } else if (key === 'port') {
+          const p = parseInt(val, 10);
+          if (p > 0 && p < 65536) current.port = p;
+        } else if (key === 'identityfile') {
+          current.authType = 'key';
+          current.privateKey = val;
+        } else if (key === 'proxyjump') {
+          current.jumpHostId = val;
+        }
+      }
+    }
+
+    if (current && current.host) {
+      profiles.push(current);
+    }
+
+    return profiles;
+  }
+
+  /**
+   * Load local default ~/.ssh/config if exists
+   */
+  static readDefaultConfig() {
+    const configPath = path.join(os.homedir(), '.ssh', 'config');
+    if (fs.existsSync(configPath)) {
+      try {
+        return fs.readFileSync(configPath, 'utf8');
+      } catch {
+        return '';
+      }
+    }
+    return '';
+  }
+}

package/lib/ssh-service.js

@@ -8,7 +8,6 @@ import os from 'node:os';
  */
 export function stripAnsi(str) {
   if (!str) return '';
-  // Match standard ANSI escape codes, OSC sequences, and CSI codes
   return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
 }
 
@@ -26,15 +25,17 @@ export class SshService {
     this.sftpSessions = new Map();
     /** @type {Map<string, any>} */
     this.terminalSessions = new Map();
+    this.getJumpProfile = null;
   }
 
   setVaultService(vault) {
     this.vaultService = vault;
   }
 
-  /**
-   * Resolve private key content either from direct string or file path
-   */
+  setJumpProfileResolver(resolver) {
+    this.getJumpProfile = resolver;
+  }
+
   resolvePrivateKey(profile) {
     if (profile.privateKey && profile.privateKey.trim()) {
       return profile.privateKey;
@@ -54,7 +55,7 @@ export class SshService {
   }
 
   /**
-   * Connect to remote machine with pooling, keep-alive, and auto-reconnect
+   * Connect to remote machine with pooling, keep-alive, auto-reconnect and ProxyJump
    */
   async getConnection(rawProfile) {
     const profile = this.vaultService ? this.vaultService.hydrateProfile(rawProfile) : rawProfile;
@@ -65,10 +66,24 @@ export class SshService {
       return existing;
     }
 
-    // Clean any broken reference
     this.connections.delete(connId);
     this.sftpSessions.delete(connId);
 
+    // If jumpHost is configured, obtain socket through the jump host first
+    let sock = undefined;
+    if (profile.jumpHostId && this.getJumpProfile) {
+      const jumpProfile = this.getJumpProfile(profile.jumpHostId);
+      if (jumpProfile) {
+        const jumpConn = await this.getConnection(jumpProfile);
+        sock = await new Promise((resolve, reject) => {
+          jumpConn.forwardOut('127.0.0.1', 0, profile.host, profile.port || 22, (err, stream) => {
+            if (err) return reject(new Error(`ProxyJump via ${jumpProfile.host} failed: ${err.message}`));
+            resolve(stream);
+          });
+        });
+      }
+    }
+
     return new Promise((resolve, reject) => {
       const conn = new Client();
       const connConfig = {
@@ -80,6 +95,10 @@ export class SshService {
         readyTimeout: 20000
       };
 
+      if (sock) {
+        connConfig.sock = sock;
+      }
+
       if (profile.authType === 'password') {
         connConfig.password = profile.password || '';
       } else if (profile.authType === 'agent') {
@@ -116,9 +135,6 @@ export class SshService {
     });
   }
 
-  /**
-   * Test connection and measure ping / detect OS
-   */
   async testConnection(profile) {
     if (profile.id) {
       this.disconnect(profile.id);
@@ -154,9 +170,6 @@ export class SshService {
     });
   }
 
-  /**
-   * Obtain active SFTP wrapper with connection reuse
-   */
   async getSftp(profile) {
     const connId = profile.id;
     if (this.sftpSessions.has(connId)) {
@@ -172,13 +185,6 @@ export class SshService {
     });
   }
 
-  /**
-   * Execute command on remote host with PTY, streaming, timeout, and ANSI sanitization
-   * @param {any} profile
-   * @param {string} command
-   * @param {string|object} [optionsOrCwd] - cwd string or options object
-   * @param {function} [legacyOnData]
-   */
   async exec(profile, command, optionsOrCwd = null, legacyOnData = null) {
     let cwd = null;
     let onData = legacyOnData;
@@ -256,8 +262,41 @@ export class SshService {
   }
 
   /**
-   * Create an interactive PTY terminal session for Web UI
+   * Direct Server-to-Server file transfer streaming between two SSH hosts.
+   * Reads from srcProfile SFTP stream and pipes directly into destProfile SFTP stream.
+   * No intermediate files touch the local DSH disk!
    */
+  async transferFileBetweenHosts(srcProfile, srcPath, destProfile, destPath) {
+    const srcSftp = await this.getSftp(srcProfile);
+    const destSftp = await this.getSftp(destProfile);
+
+    return new Promise((resolve, reject) => {
+      const readStream = srcSftp.createReadStream(srcPath);
+      const writeStream = destSftp.createWriteStream(destPath);
+      let bytesTransferred = 0;
+
+      readStream.on('data', (chunk) => {
+        bytesTransferred += chunk.length;
+      });
+
+      writeStream.on('finish', () => {
+        resolve({
+          success: true,
+          bytesTransferred,
+          srcHost: srcProfile.host,
+          destHost: destProfile.host,
+          srcPath,
+          destPath
+        });
+      });
+
+      readStream.on('error', (err) => reject(new Error(`Read from ${srcProfile.host} failed: ${err.message}`)));
+      writeStream.on('error', (err) => reject(new Error(`Write to ${destProfile.host} failed: ${err.message}`)));
+
+      readStream.pipe(writeStream);
+    });
+  }
+
   async createTerminalSession(profile, options = {}) {
     const conn = await this.getConnection(profile);
     const cols = options.cols || 80;

package/lib/tar-sync-service.js

@@ -0,0 +1,85 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import fs from 'node:fs';
+
+export class TarSyncService {
+  /**
+   * @param {import('./ssh-service.js').SshService} sshService
+   */
+  constructor(sshService) {
+    this.sshService = sshService;
+  }
+
+  /**
+   * Stream tar archive from Remote to Local directory
+   * Remote runs: tar -czf - -C <remoteDir> .
+   * Local receives stream and runs: tar -xzf - -C <localDir>
+   */
+  async pullTar(profile, remoteDir, localDir) {
+    if (!profile) throw new Error('No profile provided');
+    fs.mkdirSync(localDir, { recursive: true });
+
+    const client = await this.sshService.getConnection(profile);
+    return new Promise((resolve, reject) => {
+      const remoteCmd = `tar --exclude='.git' --exclude='node_modules' -czf - -C "${remoteDir}" .`;
+      client.exec(remoteCmd, (err, stream) => {
+        if (err) return reject(err);
+
+        const localTar = spawn('tar', ['-xzf', '-', '-C', localDir]);
+        let stderr = '';
+        localTar.stderr.on('data', (d) => { stderr += d.toString(); });
+
+        stream.pipe(localTar.stdin);
+
+        localTar.on('close', (code) => {
+          if (code !== 0) {
+            reject(new Error(`Local tar extraction failed (code ${code}): ${stderr}`));
+          } else {
+            resolve({ ok: true, direction: 'pull', remoteDir, localDir });
+          }
+        });
+
+        stream.on('error', reject);
+        localTar.stdin.on('error', reject);
+      });
+    });
+  }
+
+  /**
+   * Stream tar archive from Local to Remote directory
+   * Local runs: tar -czf - -C <localDir> .
+   * Remote receives stream and runs: tar -xzf - -C <remoteDir>
+   */
+  async pushTar(profile, localDir, remoteDir) {
+    if (!profile) throw new Error('No profile provided');
+    if (!fs.existsSync(localDir)) throw new Error(`Local dir does not exist: ${localDir}`);
+
+    const client = await this.sshService.getConnection(profile);
+    // Ensure remoteDir exists
+    await this.sshService.exec(profile, `mkdir -p "${remoteDir}"`);
+
+    return new Promise((resolve, reject) => {
+      const remoteCmd = `tar -xzf - -C "${remoteDir}"`;
+      client.exec(remoteCmd, (err, stream) => {
+        if (err) return reject(err);
+
+        const localTar = spawn('tar', ['--exclude=.git', '--exclude=node_modules', '-czf', '-', '-C', localDir, '.']);
+        let remoteStderr = '';
+        stream.stderr.on('data', (d) => { remoteStderr += d.toString(); });
+
+        localTar.stdout.pipe(stream);
+
+        stream.on('close', (code) => {
+          if (code !== 0) {
+            reject(new Error(`Remote tar extraction failed (code ${code}): ${remoteStderr}`));
+          } else {
+            resolve({ ok: true, direction: 'push', localDir, remoteDir });
+          }
+        });
+
+        stream.on('error', reject);
+        localTar.on('error', reject);
+      });
+    });
+  }
+}

package/lib/tools.js

@@ -1,4 +1,4 @@
-export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, getActiveProfile) {
+export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, getActiveProfile, getProfileById, dockerService, diagnoseService, envService, tarSyncService) {
   if (!ctx.tools || typeof ctx.tools.register !== 'function') {
     return;
   }
@@ -96,9 +96,10 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
   // 3. remote_sync
   ctx.tools.register({
     name: 'remote_sync',
-    description: 'Perform fast 3-way delta synchronization between local mirror and remote server',
+    description: 'Perform 3-way delta or streaming tarball synchronization between local mirror and remote server',
     parameters: {
       direction: { type: 'string', required: true, description: 'pull (remote -> local) or push (local -> remote)' },
+      mode: { type: 'string', description: 'sync mode: delta (default) or tarball (fast batch stream)' },
       force: { type: 'boolean', description: 'Overwrite conflicts if true (use with caution)' },
       dryRun: { type: 'boolean', description: 'Simulate changes without writing files' }
     },
@@ -110,6 +111,14 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
         throw new Error('Both remoteWorkspace and localMirrorPath must be configured');
       }
 
+      if (args.mode === 'tarball' && tarSyncService) {
+        if (args.direction === 'pull') {
+          return await tarSyncService.pullTar(profile, profile.remoteWorkspace, profile.localMirrorPath);
+        } else {
+          return await tarSyncService.pushTar(profile, profile.localMirrorPath, profile.remoteWorkspace);
+        }
+      }
+
       if (args.direction === 'pull') {
         return await mirrorSync.pull(profile, profile.remoteWorkspace, profile.localMirrorPath, args.dryRun);
       } else {
@@ -149,4 +158,168 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
       }
     }
   });
+
+  // 5. remote_docker
+  if (dockerService) {
+    ctx.tools.register({
+      name: 'remote_docker',
+      description: 'Manage Docker/Podman containers and Docker Compose on remote host',
+      parameters: {
+        action: { type: 'string', required: true, description: 'list, logs, start, stop, restart, compose' },
+        containerId: { type: 'string', description: 'Container ID or name' },
+        tail: { type: 'number', description: 'Number of log lines to retrieve (default 50)' },
+        composeAction: { type: 'string', description: 'Compose action: up -d, down, ps, restart' },
+        composeCwd: { type: 'string', description: 'Directory containing docker-compose.yml' }
+      },
+      output: genericOutput,
+      async execute(args) {
+        const profile = getActiveProfile();
+        if (!profile) throw new Error('No active remote workspace profile selected');
+
+        switch (args.action) {
+          case 'list':
+            return await dockerService.listContainers(profile, true);
+          case 'logs':
+            if (!args.containerId) throw new Error('containerId required for logs');
+            return await dockerService.containerLogs(profile, args.containerId, args.tail || 50);
+          case 'start':
+          case 'stop':
+          case 'restart':
+            if (!args.containerId) throw new Error(`containerId required for ${args.action}`);
+            return await dockerService.containerAction(profile, args.containerId, args.action);
+          case 'compose':
+            const dir = args.composeCwd || profile.remoteWorkspace;
+            return await dockerService.composeAction(profile, dir, args.composeAction || 'ps');
+          default:
+            throw new Error(`Unknown docker action: ${args.action}`);
+        }
+      }
+    });
+  }
+
+  // 6. remote_service
+  ctx.tools.register({
+    name: 'remote_service',
+    description: 'Inspect and manage Linux systemd or PM2 services on the remote machine',
+    parameters: {
+      action: { type: 'string', required: true, description: 'status, start, stop, restart, logs' },
+      service: { type: 'string', required: true, description: 'Service name (e.g. nginx, redis, my-app)' },
+      manager: { type: 'string', description: 'systemd (default) or pm2' },
+      lines: { type: 'number', description: 'Number of log lines for logs action (default 40)' }
+    },
+    output: genericOutput,
+    async execute(args) {
+      const profile = getActiveProfile();
+      if (!profile) throw new Error('No active remote workspace profile selected');
+
+      const mgr = args.manager || 'systemd';
+      const svc = args.service;
+      const lines = args.lines || 40;
+
+      let cmd = '';
+      if (mgr === 'pm2') {
+        if (args.action === 'logs') cmd = `pm2 logs ${JSON.stringify(svc)} --lines ${lines} --nostream`;
+        else cmd = `pm2 ${args.action} ${JSON.stringify(svc)}`;
+      } else {
+        if (args.action === 'logs') cmd = `journalctl -u ${JSON.stringify(svc)} -n ${lines} --no-pager`;
+        else if (args.action === 'status') cmd = `systemctl status ${JSON.stringify(svc)} --no-pager`;
+        else cmd = `sudo systemctl ${args.action} ${JSON.stringify(svc)} || systemctl ${args.action} ${JSON.stringify(svc)}`;
+      }
+
+      const res = await sshService.exec(profile, cmd, { cleanAnsi: true });
+      return {
+        exitCode: res.code,
+        output: res.stdout || res.stderr
+      };
+    }
+  });
+
+  // 7. remote_transfer
+  ctx.tools.register({
+    name: 'remote_transfer',
+    description: 'Transfer a file directly between two configured remote servers via in-memory SFTP streams',
+    parameters: {
+      sourcePath: { type: 'string', required: true, description: 'File path on the source remote server' },
+      destPath: { type: 'string', required: true, description: 'File path on the destination remote server' },
+      destProfileId: { type: 'string', required: true, description: 'Target remote profile ID' },
+      sourceProfileId: { type: 'string', description: 'Source remote profile ID (defaults to active profile)' }
+    },
+    output: genericOutput,
+    async execute(args) {
+      const srcProfile = args.sourceProfileId && getProfileById ? getProfileById(args.sourceProfileId) : getActiveProfile();
+      if (!srcProfile) throw new Error('Source profile not found or no active profile');
+
+      const destProfile = getProfileById ? getProfileById(args.destProfileId) : null;
+      if (!destProfile) throw new Error(`Destination profile "${args.destProfileId}" not found`);
+
+      return await sshService.transferFileBetweenHosts(srcProfile, args.sourcePath, destProfile, args.destPath);
+    }
+  });
+
+  // 8. remote_diagnose (New in v0.3.1)
+  if (diagnoseService) {
+    ctx.tools.register({
+      name: 'remote_diagnose',
+      description: 'Run targeted system health diagnostics on remote host (ports, disk, memory, oom_killer, service_logs)',
+      parameters: {
+        category: {
+          type: 'string',
+          required: true,
+          description: 'Diagnostic aspect: ports, disk, memory, oom_killer, service_logs'
+        },
+        target: {
+          type: 'string',
+          description: 'Optional port number, directory path, or service name to inspect'
+        }
+      },
+      output: genericOutput,
+      async execute(args) {
+        const profile = getActiveProfile();
+        if (!profile) throw new Error('No active remote workspace profile selected');
+        return await diagnoseService.diagnose(profile, args.category, args.target);
+      }
+    });
+  }
+
+  // 9. remote_env (New in v0.3.1)
+  if (envService) {
+    ctx.tools.register({
+      name: 'remote_env',
+      description: 'Inspect and atomically update remote .env files preserving comments and structure',
+      parameters: {
+        action: {
+          type: 'string',
+          required: true,
+          description: 'Action to perform: read or set'
+        },
+        filePath: {
+          type: 'string',
+          required: true,
+          description: 'Path to the .env file on the remote server'
+        },
+        key: {
+          type: 'string',
+          description: 'Environment variable key (required for set)'
+        },
+        value: {
+          type: 'string',
+          description: 'Environment variable value (for set action)'
+        }
+      },
+      output: genericOutput,
+      async execute(args) {
+        const profile = getActiveProfile();
+        if (!profile) throw new Error('No active remote workspace profile selected');
+
+        if (args.action === 'read') {
+          return await envService.readEnv(profile, args.filePath);
+        } else if (args.action === 'set') {
+          if (!args.key) throw new Error('key is required for set action');
+          return await envService.setEnvVar(profile, args.filePath, args.key, args.value || '');
+        } else {
+          throw new Error(`Unknown env action: ${args.action}`);
+        }
+      }
+    });
+  }
 }

package/lib/watcher-service.js

@@ -0,0 +1,111 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class WatcherService {
+  constructor() {
+    /** @type {Map<string, { watcher: fs.FSWatcher, profile: any, running: boolean }>} */
+    this.watchers = new Map();
+    /** @type {Map<string, NodeJS.Timeout>} */
+    this.debounceTimers = new Map();
+    this.debounceMs = 350;
+    this.onSyncCallback = null;
+  }
+
+  setOnSync(cb) {
+    this.onSyncCallback = cb;
+  }
+
+  isIgnored(filename) {
+    if (!filename) return true;
+    const parts = filename.split(/[\\/]/);
+    const ignoreList = ['.git', 'node_modules', '.dsh-sync-snapshot.json', '.cache', 'dist', 'build', '.next'];
+    for (const part of parts) {
+      if (ignoreList.includes(part)) return true;
+      if (part.endsWith('.tmp') || part.endsWith('.swp') || part.endsWith('~')) return true;
+    }
+    return false;
+  }
+
+  start(profile, mirrorSync) {
+    if (!profile || !profile.id || !profile.localMirrorPath || !profile.remoteWorkspace) {
+      return { success: false, error: 'Both localMirrorPath and remoteWorkspace must be set' };
+    }
+
+    if (this.watchers.has(profile.id)) {
+      return { success: true, alreadyRunning: true };
+    }
+
+    if (!fs.existsSync(profile.localMirrorPath)) {
+      try {
+        fs.mkdirSync(profile.localMirrorPath, { recursive: true });
+      } catch (err) {
+        return { success: false, error: `Failed to create local mirror dir: ${err.message}` };
+      }
+    }
+
+    try {
+      const watcher = fs.watch(profile.localMirrorPath, { recursive: true }, (_eventType, filename) => {
+        if (!filename || this.isIgnored(filename)) return;
+
+        // Debounce sync triggers
+        if (this.debounceTimers.has(profile.id)) {
+          clearTimeout(this.debounceTimers.get(profile.id));
+        }
+
+        const timer = setTimeout(async () => {
+          this.debounceTimers.delete(profile.id);
+          try {
+            const syncRes = await mirrorSync.push(profile, profile.localMirrorPath, profile.remoteWorkspace);
+            if (this.onSyncCallback) {
+              this.onSyncCallback({ profileId: profile.id, syncRes });
+            }
+          } catch (_) {}
+        }, this.debounceMs);
+
+        this.debounceTimers.set(profile.id, timer);
+      });
+
+      this.watchers.set(profile.id, { watcher, profile, running: true });
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  }
+
+  stop(profileId) {
+    if (this.debounceTimers.has(profileId)) {
+      clearTimeout(this.debounceTimers.get(profileId));
+      this.debounceTimers.delete(profileId);
+    }
+    const item = this.watchers.get(profileId);
+    if (item) {
+      try {
+        item.watcher.close();
+      } catch (_) {}
+      this.watchers.delete(profileId);
+      return true;
+    }
+    return false;
+  }
+
+  getStatus(profileId) {
+    return this.watchers.has(profileId);
+  }
+
+  listActive() {
+    return Array.from(this.watchers.keys());
+  }
+
+  stopAll() {
+    for (const [id, item] of this.watchers.entries()) {
+      try {
+        item.watcher.close();
+      } catch (_) {}
+      if (this.debounceTimers.has(id)) {
+        clearTimeout(this.debounceTimers.get(id));
+      }
+    }
+    this.watchers.clear();
+    this.debounceTimers.clear();
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-remote-workspace",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "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",