@goodandready/dsh-remote-workspace 0.3.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/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, getProfileById, dockerService) {
+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 {
@@ -212,7 +221,6 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
         if (args.action === 'logs') cmd = `pm2 logs ${JSON.stringify(svc)} --lines ${lines} --nostream`;
         else cmd = `pm2 ${args.action} ${JSON.stringify(svc)}`;
       } else {
-        // systemd
         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)}`;
@@ -247,4 +255,71 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
       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/package.json

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