@goodandready/dsh-remote-workspace 0.1.0 → 0.2.0

package/lib/ssh-service.js

@@ -3,13 +3,33 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 
+/**
+ * Utility to strip ANSI escape sequences from terminal output for clean LLM ingestion
+ */
+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, '');
+}
+
 export class SshService {
-  constructor(ctx) {
+  /**
+   * @param {any} ctx
+   * @param {import('./vault-service.js').VaultService} [vaultService]
+   */
+  constructor(ctx, vaultService = null) {
     this.ctx = ctx;
+    this.vaultService = vaultService;
     /** @type {Map<string, Client>} */
     this.connections = new Map();
     /** @type {Map<string, any>} */
     this.sftpSessions = new Map();
+    /** @type {Map<string, any>} */
+    this.terminalSessions = new Map();
+  }
+
+  setVaultService(vault) {
+    this.vaultService = vault;
   }
 
   /**
@@ -20,27 +40,35 @@ export class SshService {
       return profile.privateKey;
     }
     if (profile.privateKeyPath) {
-      let resolvedPath = profile.privateKeyPath;
+      let resolvedPath = profile.privateKeyPath.trim();
       if (resolvedPath.startsWith('~')) {
         resolvedPath = path.join(os.homedir(), resolvedPath.slice(1));
       }
-      if (fs.existsSync(resolvedPath)) {
-        return fs.readFileSync(resolvedPath, 'utf8');
-      }
+      try {
+        if (fs.existsSync(resolvedPath)) {
+          return fs.readFileSync(resolvedPath, 'utf8');
+        }
+      } catch (_) {}
     }
     return undefined;
   }
 
   /**
-   * Connect to remote machine with pooling and keep-alive
+   * Connect to remote machine with pooling, keep-alive, and auto-reconnect
    */
-  async getConnection(profile) {
+  async getConnection(rawProfile) {
+    const profile = this.vaultService ? this.vaultService.hydrateProfile(rawProfile) : rawProfile;
     const connId = profile.id;
+
     const existing = this.connections.get(connId);
     if (existing && existing._sock && !existing._sock.destroyed) {
       return existing;
     }
 
+    // Clean any broken reference
+    this.connections.delete(connId);
+    this.sftpSessions.delete(connId);
+
     return new Promise((resolve, reject) => {
       const conn = new Client();
       const connConfig = {
@@ -53,7 +81,7 @@ export class SshService {
       };
 
       if (profile.authType === 'password') {
-        connConfig.password = profile.password;
+        connConfig.password = profile.password || '';
       } else if (profile.authType === 'agent') {
         connConfig.agent = process.env.SSH_AUTH_SOCK;
       } else {
@@ -92,6 +120,9 @@ export class SshService {
    * Test connection and measure ping / detect OS
    */
   async testConnection(profile) {
+    if (profile.id) {
+      this.disconnect(profile.id);
+    }
     const start = Date.now();
     const conn = await this.getConnection(profile);
     const latency = Date.now() - start;
@@ -99,19 +130,32 @@ export class SshService {
     return new Promise((resolve) => {
       conn.exec('uname -s -r -m || ver', (err, stream) => {
         if (err) {
-          return resolve({ success: true, latency, os: 'Unknown' });
+          return resolve({
+            success: true,
+            latency,
+            latencyMs: latency,
+            os: 'Unknown',
+            remoteOs: 'Unknown'
+          });
         }
         let output = '';
         stream.on('data', (d) => { output += d.toString(); });
         stream.on('close', () => {
-          resolve({ success: true, latency, os: output.trim() });
+          const osStr = output.trim() || 'Unknown';
+          resolve({
+            success: true,
+            latency,
+            latencyMs: latency,
+            os: osStr,
+            remoteOs: osStr
+          });
         });
       });
     });
   }
 
   /**
-   * Obtain active SFTP wrapper
+   * Obtain active SFTP wrapper with connection reuse
    */
   async getSftp(profile) {
     const connId = profile.id;
@@ -129,38 +173,161 @@ export class SshService {
   }
 
   /**
-   * Execute command on remote host
+   * 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, cwd, onData) {
+  async exec(profile, command, optionsOrCwd = null, legacyOnData = null) {
+    let cwd = null;
+    let onData = legacyOnData;
+    let pty = false;
+    let timeoutMs = 0;
+    let cleanAnsi = false;
+
+    if (typeof optionsOrCwd === 'string') {
+      cwd = optionsOrCwd;
+    } else if (optionsOrCwd && typeof optionsOrCwd === 'object') {
+      cwd = optionsOrCwd.cwd || null;
+      onData = optionsOrCwd.onData || legacyOnData;
+      pty = Boolean(optionsOrCwd.pty);
+      timeoutMs = optionsOrCwd.timeout ? optionsOrCwd.timeout * 1000 : 0;
+      cleanAnsi = Boolean(optionsOrCwd.cleanAnsi);
+    }
+
     const conn = await this.getConnection(profile);
     const shellCmd = cwd ? `cd ${JSON.stringify(cwd)} && ${command}` : command;
 
+    const execOptions = {};
+    if (pty) {
+      execOptions.pty = {
+        rows: typeof pty === 'object' ? (pty.rows || 24) : 24,
+        cols: typeof pty === 'object' ? (pty.cols || 80) : 80,
+        term: typeof pty === 'object' ? (pty.term || 'xterm-256color') : 'xterm-256color'
+      };
+    }
+
     return new Promise((resolve, reject) => {
-      conn.exec(shellCmd, (err, stream) => {
+      let timer = null;
+
+      conn.exec(shellCmd, execOptions, (err, stream) => {
         if (err) return reject(err);
         let stdout = '';
         let stderr = '';
+
+        if (timeoutMs > 0) {
+          timer = setTimeout(() => {
+            try {
+              stream.signal('SIGTERM');
+              stream.close();
+            } catch (_) {}
+            const errTimeout = new Error(`Command timed out after ${timeoutMs / 1000}s: ${command}`);
+            errTimeout.code = 'ETIMEDOUT';
+            errTimeout.stdout = cleanAnsi ? stripAnsi(stdout) : stdout;
+            errTimeout.stderr = cleanAnsi ? stripAnsi(stderr) : stderr;
+            reject(errTimeout);
+          }, timeoutMs);
+        }
+
         stream.on('data', (data) => {
           const str = data.toString();
           stdout += str;
           if (onData) onData({ type: 'stdout', data: str });
         });
-        stream.stderr.on('data', (data) => {
+
+        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 });
+          if (timer) clearTimeout(timer);
+          resolve({
+            code: code ?? 0,
+            signal,
+            stdout: cleanAnsi ? stripAnsi(stdout) : stdout,
+            stderr: cleanAnsi ? stripAnsi(stderr) : stderr
+          });
+        });
+      });
+    });
+  }
+
+  /**
+   * Create an interactive PTY terminal session for Web UI
+   */
+  async createTerminalSession(profile, options = {}) {
+    const conn = await this.getConnection(profile);
+    const cols = options.cols || 80;
+    const rows = options.rows || 24;
+    const term = options.term || 'xterm-256color';
+    const sessionId = `term_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+    return new Promise((resolve, reject) => {
+      conn.shell({ term, cols, rows }, (err, stream) => {
+        if (err) return reject(err);
+
+        const session = {
+          id: sessionId,
+          profileId: profile.id,
+          stream,
+          createdAt: Date.now(),
+          buffer: [],
+          subscribers: new Set(),
+          write(data) {
+            try { stream.write(data); } catch (_) {}
+          },
+          resize(c, r) {
+            try { stream.setWindow(r, c, 0, 0); } catch (_) {}
+          },
+          close() {
+            try { stream.end(); } catch (_) {}
+          }
+        };
+
+        stream.on('data', (d) => {
+          const chunk = d.toString('utf8');
+          session.buffer.push(chunk);
+          if (session.buffer.length > 500) session.buffer.shift();
+          for (const sub of session.subscribers) {
+            try { sub(chunk); } catch (_) {}
+          }
         });
+
+        stream.on('close', () => {
+          this.terminalSessions.delete(sessionId);
+        });
+
+        this.terminalSessions.set(sessionId, session);
+        resolve(session);
       });
     });
   }
 
+  getTerminalSession(sessionId) {
+    return this.terminalSessions.get(sessionId);
+  }
+
+  closeTerminalSession(sessionId) {
+    const session = this.terminalSessions.get(sessionId);
+    if (session) {
+      session.close();
+      this.terminalSessions.delete(sessionId);
+      return true;
+    }
+    return false;
+  }
+
+  invalidate(profileId) {
+    this.disconnect(profileId);
+  }
+
   disconnect(profileId) {
     const conn = this.connections.get(profileId);
     if (conn) {
-      conn.end();
+      try { conn.end(); } catch (_) {}
       this.connections.delete(profileId);
       this.sftpSessions.delete(profileId);
     }
@@ -172,5 +339,9 @@ export class SshService {
     }
     this.connections.clear();
     this.sftpSessions.clear();
+    for (const [id, term] of this.terminalSessions.entries()) {
+      try { term.close(); } catch (_) {}
+    }
+    this.terminalSessions.clear();
   }
 }

package/lib/tools.js

@@ -11,21 +11,34 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
   // 1. remote_exec
   ctx.tools.register({
     name: 'remote_exec',
-    description: 'Execute bash/shell command on the active remote workspace host',
+    description: 'Execute bash/shell command on the active remote workspace host with timeout and ANSI cleaning',
     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)' }
+      cwd: { type: 'string', description: 'Working directory on remote server (defaults to remote workspace)' },
+      timeout: { type: 'number', description: 'Execution timeout in seconds (default 60s, 0 to disable)' },
+      pty: { type: 'boolean', description: 'Allocate pseudo-terminal for colored or interactive outputs' },
+      cleanAnsi: { type: 'boolean', description: 'Strip ANSI escape codes from output for clean LLM context (default true)' }
     },
     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);
+      const timeout = args.timeout !== undefined ? args.timeout : 60;
+      const cleanAnsi = args.cleanAnsi !== undefined ? args.cleanAnsi : true;
+
+      const res = await sshService.exec(profile, args.command, {
+        cwd: dir,
+        timeout,
+        pty: Boolean(args.pty),
+        cleanAnsi
+      });
+
       return {
         exitCode: res.code,
         stdout: res.stdout,
-        stderr: res.stderr
+        stderr: res.stderr,
+        signal: res.signal
       };
     }
   });
@@ -33,7 +46,7 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
   // 2. remote_fs
   ctx.tools.register({
     name: 'remote_fs',
-    description: 'Perform file operations (read, write, stat, list, mkdir, remove) on remote workspace',
+    description: 'Perform file operations (read, write, stat, list, mkdir, remove) on remote workspace with caching',
     parameters: {
       action: {
         type: 'string',
@@ -42,13 +55,14 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
       },
       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' }
+      recursive: { type: 'boolean', description: 'Recursive flag for remove action' },
+      bypassCache: { type: 'boolean', description: 'Bypass in-memory cache for fresh results' }
     },
     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;
+      const { action, path: targetPath, content, recursive, bypassCache } = args;
 
       switch (action) {
         case 'read': {
@@ -61,10 +75,10 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
           return res;
         }
         case 'stat': {
-          return await remoteFs.stat(profile, targetPath);
+          return await remoteFs.stat(profile, targetPath, Boolean(bypassCache));
         }
         case 'list': {
-          const entries = await remoteFs.listDir(profile, targetPath);
+          const entries = await remoteFs.listDir(profile, targetPath, Boolean(bypassCache));
           return { entries };
         }
         case 'mkdir': {
@@ -82,7 +96,7 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
   // 3. remote_sync
   ctx.tools.register({
     name: 'remote_sync',
-    description: 'Perform 3-way conflict-aware synchronization between local mirror and remote server',
+    description: 'Perform fast 3-way delta 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)' },
@@ -107,7 +121,7 @@ export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunne
   // 4. remote_tunnel
   ctx.tools.register({
     name: 'remote_tunnel',
-    description: 'Manage SSH port forwarding tunnels (start, stop, list)',
+    description: 'Manage SSH port forwarding tunnels (start, stop, list) with telemetry metrics',
     parameters: {
       action: { type: 'string', required: true, description: 'start, stop, or list' },
       localPort: { type: 'number', description: 'Local listening port' },

package/lib/tunnel-service.js

@@ -6,66 +6,112 @@ export class TunnelService {
    */
   constructor(sshService) {
     this.sshService = sshService;
-    /** @type {Map<string, { server?: net.Server, profileId: string, localPort: number, remotePort: number }>} */
+    /** @type {Map<string, {
+     *   server: net.Server,
+     *   profileId: string,
+     *   localPort: number,
+     *   targetHost: string,
+     *   remotePort: number,
+     *   createdAt: number,
+     *   bytesRx: number,
+     *   bytesTx: number,
+     *   totalConnections: number,
+     *   activeConnections: number
+     * }>} */
     this.activeTunnels = new Map();
   }
 
   /**
-   * Start Local Port Forwarding: 127.0.0.1:localPort -> Remote:targetHost:targetPort
+   * Start local port forwarding tunnel: LocalPort -> RemoteHost:RemotePort with live telemetry
    */
-  async startLocalTunnel(profile, localPort, targetHost = '127.0.0.1', targetPort) {
-    const tunnelId = `${profile.id}:${localPort}->${targetPort}`;
+  async startLocalTunnel(profile, localPort, targetHost, remotePort) {
+    const tunnelId = `${profile.id}:${localPort}->${targetHost}:${remotePort}`;
     if (this.activeTunnels.has(tunnelId)) {
-      return { success: true, message: 'Tunnel already active', tunnelId };
+      return { success: true, tunnelId, alreadyRunning: true };
     }
 
     const conn = await this.sshService.getConnection(profile);
 
     return new Promise((resolve, reject) => {
-      const server = net.createServer((socket) => {
+      const tunnelMeta = {
+        server: null,
+        profileId: profile.id,
+        localPort,
+        targetHost,
+        remotePort,
+        createdAt: Date.now(),
+        bytesRx: 0,
+        bytesTx: 0,
+        totalConnections: 0,
+        activeConnections: 0
+      };
+
+      const server = net.createServer((clientSocket) => {
+        tunnelMeta.totalConnections++;
+        tunnelMeta.activeConnections++;
+
         conn.forwardOut(
           '127.0.0.1',
-          socket.remotePort || 0,
+          clientSocket.remotePort || 0,
           targetHost,
-          targetPort,
+          remotePort,
           (err, stream) => {
             if (err) {
-              socket.destroy();
+              tunnelMeta.activeConnections = Math.max(0, tunnelMeta.activeConnections - 1);
+              clientSocket.destroy();
               return;
             }
-            socket.pipe(stream).pipe(socket);
+
+            // Telemetry: measure bytes flowing through the tunnel
+            clientSocket.on('data', (d) => {
+              tunnelMeta.bytesRx += d.length;
+            });
+            stream.on('data', (d) => {
+              tunnelMeta.bytesTx += d.length;
+            });
+
+            clientSocket.pipe(stream);
+            stream.pipe(clientSocket);
+
+            const cleanup = () => {
+              tunnelMeta.activeConnections = Math.max(0, tunnelMeta.activeConnections - 1);
+            };
+            clientSocket.on('close', cleanup);
+            clientSocket.on('error', cleanup);
+            stream.on('close', cleanup);
+            stream.on('error', cleanup);
           }
         );
       });
 
-      server.listen(localPort, '127.0.0.1', () => {
-        this.activeTunnels.set(tunnelId, {
-          server,
-          profileId: profile.id,
-          localPort,
-          remotePort: targetPort
-        });
-        resolve({ success: true, tunnelId, localPort, targetPort });
-      });
+      tunnelMeta.server = server;
 
       server.on('error', (err) => {
         this.activeTunnels.delete(tunnelId);
         reject(err);
       });
+
+      server.listen(localPort, '127.0.0.1', () => {
+        this.activeTunnels.set(tunnelId, tunnelMeta);
+        resolve({
+          success: true,
+          tunnelId,
+          localPort,
+          targetHost,
+          remotePort
+        });
+      });
     });
   }
 
-  /**
-   * Stop active tunnel
-   */
   stopTunnel(tunnelId) {
     const tunnel = this.activeTunnels.get(tunnelId);
-    if (tunnel && tunnel.server) {
+    if (!tunnel) return false;
+    try {
       tunnel.server.close();
-      this.activeTunnels.delete(tunnelId);
-      return true;
-    }
-    return false;
+    } catch (_) {}
+    this.activeTunnels.delete(tunnelId);
+    return true;
   }
 
   listActiveTunnels() {
@@ -73,15 +119,22 @@ export class TunnelService {
       id,
       profileId: t.profileId,
       localPort: t.localPort,
-      remotePort: t.remotePort
+      targetHost: t.targetHost,
+      remotePort: t.remotePort,
+      createdAt: t.createdAt,
+      uptimeSeconds: Math.floor((Date.now() - t.createdAt) / 1000),
+      bytesRx: t.bytesRx,
+      bytesTx: t.bytesTx,
+      totalConnections: t.totalConnections,
+      activeConnections: t.activeConnections
     }));
   }
 
   stopAll() {
-    for (const [id, t] of this.activeTunnels.entries()) {
-      if (t.server) {
-        try { t.server.close(); } catch (_) {}
-      }
+    for (const [id, tunnel] of this.activeTunnels.entries()) {
+      try {
+        tunnel.server.close();
+      } catch (_) {}
     }
     this.activeTunnels.clear();
   }