@goodandready/dsh-remote-workspace 0.1.1 → 0.3.0

package/lib/ssh-service.js

@@ -3,18 +3,39 @@ 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 '';
+  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();
+    this.getJumpProfile = null;
+  }
+
+  setVaultService(vault) {
+    this.vaultService = vault;
+  }
+
+  setJumpProfileResolver(resolver) {
+    this.getJumpProfile = resolver;
   }
 
-  /**
-   * Resolve private key content either from direct string or file path
-   */
   resolvePrivateKey(profile) {
     if (profile.privateKey && profile.privateKey.trim()) {
       return profile.privateKey;
@@ -34,15 +55,35 @@ export class SshService {
   }
 
   /**
-   * Connect to remote machine with pooling and keep-alive
+   * Connect to remote machine with pooling, keep-alive, auto-reconnect and ProxyJump
    */
-  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;
     }
 
+    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 = {
@@ -54,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') {
@@ -90,11 +135,7 @@ export class SshService {
     });
   }
 
-  /**
-   * Test connection and measure ping / detect OS
-   */
   async testConnection(profile) {
-    // Invalidate any existing connection for this profile id to ensure fresh credentials are used
     if (profile.id) {
       this.disconnect(profile.id);
     }
@@ -129,9 +170,6 @@ export class SshService {
     });
   }
 
-  /**
-   * Obtain active SFTP wrapper
-   */
   async getSftp(profile) {
     const connId = profile.id;
     if (this.sftpSessions.has(connId)) {
@@ -147,35 +185,180 @@ export class SshService {
     });
   }
 
-  /**
-   * Execute command on remote host
-   */
-  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
+          });
+        });
+      });
+    });
+  }
+
+  /**
+   * 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;
+    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);
   }
@@ -195,5 +378,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

@@ -1,4 +1,4 @@
-export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, getActiveProfile) {
+export function registerRemoteTools(ctx, sshService, remoteFs, mirrorSync, tunnelService, getActiveProfile, getProfileById, dockerService) {
   if (!ctx.tools || typeof ctx.tools.register !== 'function') {
     return;
   }
@@ -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' },
@@ -135,4 +149,102 @@ 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 {
+        // 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)}`;
+      }
+
+      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);
+    }
+  });
 }

package/lib/tunnel-service.js

@@ -6,75 +6,112 @@ export class TunnelService {
    */
   constructor(sshService) {
     this.sshService = sshService;
-    /** @type {Map<string, { server?: net.Server, profileId: string, localPort: number, targetHost: string, 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, localPort, remotePort: targetPort };
+      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) {
-              try { socket.destroy(); } catch (_) {}
+              tunnelMeta.activeConnections = Math.max(0, tunnelMeta.activeConnections - 1);
+              clientSocket.destroy();
               return;
             }
-            stream.on('error', () => {
-              try { socket.destroy(); } catch (_) {}
+
+            // Telemetry: measure bytes flowing through the tunnel
+            clientSocket.on('data', (d) => {
+              tunnelMeta.bytesRx += d.length;
             });
-            socket.on('error', () => {
-              try { stream.destroy(); } catch (_) {}
+            stream.on('data', (d) => {
+              tunnelMeta.bytesTx += d.length;
             });
-            socket.pipe(stream).pipe(socket);
+
+            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);
           }
         );
       });
 
+      tunnelMeta.server = server;
+
       server.on('error', (err) => {
         this.activeTunnels.delete(tunnelId);
         reject(err);
       });
 
       server.listen(localPort, '127.0.0.1', () => {
-        this.activeTunnels.set(tunnelId, {
-          server,
-          profileId: profile.id,
+        this.activeTunnels.set(tunnelId, tunnelMeta);
+        resolve({
+          success: true,
+          tunnelId,
           localPort,
           targetHost,
-          remotePort: targetPort
+          remotePort
         });
-        resolve({ success: true, tunnelId, localPort, targetHost, remotePort: targetPort });
       });
     });
   }
 
-  /**
-   * Stop active tunnel
-   */
   stopTunnel(tunnelId) {
     const tunnel = this.activeTunnels.get(tunnelId);
-    if (tunnel && tunnel.server) {
-      try {
-        tunnel.server.close();
-      } catch (_) {}
-      this.activeTunnels.delete(tunnelId);
-      return true;
-    }
-    return false;
+    if (!tunnel) return false;
+    try {
+      tunnel.server.close();
+    } catch (_) {}
+    this.activeTunnels.delete(tunnelId);
+    return true;
   }
 
   listActiveTunnels() {
@@ -82,16 +119,22 @@ export class TunnelService {
       id,
       profileId: t.profileId,
       localPort: t.localPort,
-      targetHost: t.targetHost || '127.0.0.1',
-      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();
   }