@akms/mcp-ssh 0.0.3 → 0.1.1

package/lib/index.cjs

@@ -1,10 +1,12 @@
 'use strict';
 
 var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
+var fs2 = require('fs');
 var os = require('os');
 var path2 = require('path');
-var fs2 = require('fs');
+var child_process = require('child_process');
 var crypto = require('crypto');
+var stream = require('stream');
 var string_decoder = require('string_decoder');
 var ssh2 = require('ssh2');
 var timers = require('timers');
@@ -12,9 +14,9 @@ var zod = require('zod');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
 var os__default = /*#__PURE__*/_interopDefault(os);
 var path2__default = /*#__PURE__*/_interopDefault(path2);
-var fs2__default = /*#__PURE__*/_interopDefault(fs2);
 var ssh2__default = /*#__PURE__*/_interopDefault(ssh2);
 
 // src/server.ts
@@ -32,7 +34,7 @@ var SESSION_SWEEP_INTERVAL_MS = 6e4;
 var CWD_MARKER = "__AKMS_SSH_CWD__";
 var MAX_DIRECTORY_ENTRIES = 1e3;
 var SERVER_NAME = "akms-mcp-ssh";
-var SERVER_VERSION = "0.0.3";
+var SERVER_VERSION = "0.1.1";
 
 // src/_defs/command-rules.ts
 var CRITICAL_PATH_PATTERN = new RegExp(
@@ -454,6 +456,22 @@ var SINGLE_HOST_ENV = {
   DESCRIPTION: "SSH_DESCRIPTION",
   /** Directory new sessions start in. */
   CWD: "SSH_CWD",
+  /**
+   * Command whose stdin/stdout carry the SSH stream, like OpenSSH's `ProxyCommand`.
+   * `%h` / `%p` / `%r` expand to the first hop's host, port and user.
+   */
+  PROXY_COMMAND: "SSH_PROXY_COMMAND",
+  /** Presence of this variable routes the connection through a jump host. */
+  JUMP_HOST: "SSH_JUMP_HOST",
+  JUMP_PORT: "SSH_JUMP_PORT",
+  /** Defaults to `SSH_USER`. */
+  JUMP_USER: "SSH_JUMP_USER",
+  /** Path to the jump host's private key file; defaults to `SSH_KEY`. */
+  JUMP_KEY: "SSH_JUMP_KEY",
+  JUMP_PASSPHRASE: "SSH_JUMP_PASSPHRASE",
+  JUMP_PASSWORD: "SSH_JUMP_PASSWORD",
+  /** Pinned jump host key, `SHA256:…`. */
+  JUMP_HOST_KEY: "SSH_JUMP_HOST_KEY",
   READONLY: "SSH_READONLY",
   ALLOW_SUDO: "SSH_ALLOW_SUDO",
   /** Comma-separated binary names. */
@@ -606,8 +624,8 @@ function isRemotePathWithin(candidate, allowedPrefix) {
   }
   return normalizedCandidate.startsWith(`${normalizedPrefix}/`);
 }
-function readEnv(name) {
-  const value = process.env[name];
+function readEnv(env, name) {
+  const value = env[name];
   if (value == null) {
     return void 0;
   }
@@ -617,8 +635,8 @@ function readEnv(name) {
   }
   return trimmed;
 }
-function readBooleanEnv(name) {
-  const value = readEnv(name);
+function readBooleanEnv(env, name) {
+  const value = readEnv(env, name);
   if (value == null) {
     return void 0;
   }
@@ -631,8 +649,8 @@ function readBooleanEnv(name) {
   }
   return false;
 }
-function readIntegerEnv(name) {
-  const value = readEnv(name);
+function readIntegerEnv(env, name) {
+  const value = readEnv(env, name);
   if (value == null) {
     return void 0;
   }
@@ -642,8 +660,8 @@ function readIntegerEnv(name) {
   }
   return parsed;
 }
-function readListEnv(name) {
-  const value = readEnv(name);
+function readListEnv(env, name) {
+  const value = readEnv(env, name);
   if (value == null) {
     return void 0;
   }
@@ -668,8 +686,8 @@ function compileDenyPatterns(sources) {
     }
   });
 }
-function loadHostProfile() {
-  const host = readEnv(SINGLE_HOST_ENV.HOST);
+function loadHostProfile(env = process.env) {
+  const host = readEnv(env, SINGLE_HOST_ENV.HOST);
   if (host == null) {
     const _startupLogger = $logger.child({ context: "loadHostProfile" });
     _startupLogger.warn("no host is registered; set the connection variables and restart", {
@@ -677,40 +695,40 @@ function loadHostProfile() {
     });
     return null;
   }
-  const username = readEnv(SINGLE_HOST_ENV.USER);
+  const username = readEnv(env, SINGLE_HOST_ENV.USER);
   if (username == null) {
     throw new Error(`${SINGLE_HOST_ENV.HOST} is set, so ${SINGLE_HOST_ENV.USER} is required`);
   }
-  const name = readEnv(SINGLE_HOST_ENV.NAME) ?? host;
+  const name = readEnv(env, SINGLE_HOST_ENV.NAME) ?? host;
   const _logger = $logger.child({ context: "loadHostProfile", profile: name });
-  const allowCommands = readListEnv(SINGLE_HOST_ENV.ALLOW_COMMANDS) ?? [];
+  const allowCommands = readListEnv(env, SINGLE_HOST_ENV.ALLOW_COMMANDS) ?? [];
   if (allowCommands.length > 0 && allowCommands.includes("pwd") == false) {
     allowCommands.push("pwd");
   }
   const policy = {
-    readonly: readBooleanEnv(SINGLE_HOST_ENV.READONLY) ?? false,
-    allowSudo: readBooleanEnv(SINGLE_HOST_ENV.ALLOW_SUDO) ?? true,
-    execTimeoutMs: readIntegerEnv(SINGLE_HOST_ENV.EXEC_TIMEOUT_MS) ?? DEFAULT_EXEC_TIMEOUT_MS,
-    connectTimeoutMs: readIntegerEnv(SINGLE_HOST_ENV.CONNECT_TIMEOUT_MS) ?? DEFAULT_CONNECT_TIMEOUT_MS,
-    maxOutputCharacters: readIntegerEnv(SINGLE_HOST_ENV.MAX_OUTPUT_CHARACTERS) ?? DEFAULT_MAX_OUTPUT_CHARACTERS,
-    maxReadFileBytes: readIntegerEnv(SINGLE_HOST_ENV.MAX_READ_FILE_BYTES) ?? DEFAULT_MAX_READ_FILE_BYTES,
+    readonly: readBooleanEnv(env, SINGLE_HOST_ENV.READONLY) ?? false,
+    allowSudo: readBooleanEnv(env, SINGLE_HOST_ENV.ALLOW_SUDO) ?? true,
+    execTimeoutMs: readIntegerEnv(env, SINGLE_HOST_ENV.EXEC_TIMEOUT_MS) ?? DEFAULT_EXEC_TIMEOUT_MS,
+    connectTimeoutMs: readIntegerEnv(env, SINGLE_HOST_ENV.CONNECT_TIMEOUT_MS) ?? DEFAULT_CONNECT_TIMEOUT_MS,
+    maxOutputCharacters: readIntegerEnv(env, SINGLE_HOST_ENV.MAX_OUTPUT_CHARACTERS) ?? DEFAULT_MAX_OUTPUT_CHARACTERS,
+    maxReadFileBytes: readIntegerEnv(env, SINGLE_HOST_ENV.MAX_READ_FILE_BYTES) ?? DEFAULT_MAX_READ_FILE_BYTES,
     allowCommands,
-    denyPatterns: compileDenyPatterns(readListEnv(SINGLE_HOST_ENV.DENY_PATTERNS) ?? []),
-    allowedPaths: readListEnv(SINGLE_HOST_ENV.ALLOWED_PATHS) ?? []
+    denyPatterns: compileDenyPatterns(readListEnv(env, SINGLE_HOST_ENV.DENY_PATTERNS) ?? []),
+    allowedPaths: readListEnv(env, SINGLE_HOST_ENV.ALLOWED_PATHS) ?? []
   };
   const profile = {
     name,
     host,
-    port: readIntegerEnv(SINGLE_HOST_ENV.PORT) ?? DEFAULT_SSH_PORT,
+    port: readIntegerEnv(env, SINGLE_HOST_ENV.PORT) ?? DEFAULT_SSH_PORT,
     username,
-    description: readEnv(SINGLE_HOST_ENV.DESCRIPTION),
-    passphrase: readEnv(SINGLE_HOST_ENV.PASSPHRASE),
-    password: readEnv(SINGLE_HOST_ENV.PASSWORD),
-    hostKeyFingerprint: readEnv(SINGLE_HOST_ENV.HOST_KEY),
-    defaultCwd: readEnv(SINGLE_HOST_ENV.CWD),
+    description: readEnv(env, SINGLE_HOST_ENV.DESCRIPTION),
+    passphrase: readEnv(env, SINGLE_HOST_ENV.PASSPHRASE),
+    password: readEnv(env, SINGLE_HOST_ENV.PASSWORD),
+    hostKeyFingerprint: readEnv(env, SINGLE_HOST_ENV.HOST_KEY),
+    defaultCwd: readEnv(env, SINGLE_HOST_ENV.CWD),
     policy
   };
-  const keyPath = readEnv(SINGLE_HOST_ENV.KEY);
+  const keyPath = readEnv(env, SINGLE_HOST_ENV.KEY);
   if (keyPath != null) {
     const expandedKeyPath = expandHomePath(keyPath);
     profile.privateKeyPath = expandedKeyPath;
@@ -720,11 +738,49 @@ function loadHostProfile() {
       });
     }
   }
+  profile.proxyCommand = readEnv(env, SINGLE_HOST_ENV.PROXY_COMMAND);
+  const jumpHost = readEnv(env, SINGLE_HOST_ENV.JUMP_HOST);
+  if (jumpHost == null) {
+    const strayJumpVariables = [
+      SINGLE_HOST_ENV.JUMP_PORT,
+      SINGLE_HOST_ENV.JUMP_USER,
+      SINGLE_HOST_ENV.JUMP_KEY,
+      SINGLE_HOST_ENV.JUMP_PASSPHRASE,
+      SINGLE_HOST_ENV.JUMP_PASSWORD,
+      SINGLE_HOST_ENV.JUMP_HOST_KEY
+    ].filter((variable) => readEnv(env, variable) != null);
+    if (strayJumpVariables.length > 0) {
+      throw new Error(`${strayJumpVariables.join(", ")} is set, so ${SINGLE_HOST_ENV.JUMP_HOST} is required`);
+    }
+  } else {
+    profile.jump = {
+      host: jumpHost,
+      port: readIntegerEnv(env, SINGLE_HOST_ENV.JUMP_PORT) ?? DEFAULT_SSH_PORT,
+      username: readEnv(env, SINGLE_HOST_ENV.JUMP_USER) ?? username,
+      password: readEnv(env, SINGLE_HOST_ENV.JUMP_PASSWORD),
+      hostKeyFingerprint: readEnv(env, SINGLE_HOST_ENV.JUMP_HOST_KEY)
+    };
+    const jumpKeyPath = readEnv(env, SINGLE_HOST_ENV.JUMP_KEY);
+    if (jumpKeyPath != null) {
+      profile.jump.privateKeyPath = expandHomePath(jumpKeyPath);
+      profile.jump.passphrase = readEnv(env, SINGLE_HOST_ENV.JUMP_PASSPHRASE);
+      if (fs2__default.default.existsSync(profile.jump.privateKeyPath) == false) {
+        _logger.warn(`${SINGLE_HOST_ENV.JUMP_KEY} does not exist; connections will fail`, {
+          private_key_path: profile.jump.privateKeyPath
+        });
+      }
+    } else {
+      profile.jump.privateKeyPath = profile.privateKeyPath;
+      profile.jump.passphrase = readEnv(env, SINGLE_HOST_ENV.JUMP_PASSPHRASE) ?? profile.passphrase;
+    }
+  }
   _logger.info("host profile loaded", {
     host,
     port: profile.port,
     username,
-    readonly: policy.readonly
+    readonly: policy.readonly,
+    jump_host: profile.jump?.host,
+    via_proxy_command: profile.proxyCommand != null
   });
   return profile;
 }
@@ -735,18 +791,27 @@ function toHostSummary(profile) {
   } else if (profile.password != null) {
     authMethod = "password";
   }
-  return {
+  const summary = {
     name: profile.name,
     host: profile.host,
     port: profile.port,
     username: profile.username,
     description: profile.description,
     authMethod,
+    viaProxyCommand: profile.proxyCommand != null,
     readonly: profile.policy.readonly,
     allowSudo: profile.policy.allowSudo,
     allowedPaths: profile.policy.allowedPaths,
     allowCommands: profile.policy.allowCommands
   };
+  if (profile.jump != null) {
+    summary.jump = {
+      host: profile.jump.host,
+      port: profile.jump.port,
+      username: profile.jump.username
+    };
+  }
+  return summary;
 }
 
 // src/modules/guard/command-guard.ts
@@ -1278,7 +1343,7 @@ function resolveAgentPath() {
   }
   return void 0;
 }
-function readPrivateKey(profile, keyPath) {
+function readPrivateKey(label, keyPath) {
   const cached = PRIVATE_KEY_CACHE.get(keyPath);
   if (cached != null) {
     return cached;
@@ -1288,32 +1353,46 @@ function readPrivateKey(profile, keyPath) {
     PRIVATE_KEY_CACHE.set(keyPath, contents);
     return contents;
   } catch (ex) {
-    const _logger = $logger.child({ context: "readPrivateKey", profile: profile.name });
-    _logger.error(ex, "cannot read the profile's private key file");
-    throw new Error(`cannot read the private key configured for profile '${profile.name}' (see the server log for the path)`);
+    const _logger = $logger.child({ context: "readPrivateKey", profile: label });
+    _logger.error(ex, "cannot read the private key file");
+    throw new Error(`cannot read the private key configured for '${label}' (see the server log for the path)`);
+  }
+}
+function applyAuth(connectConfig, credentials, label) {
+  if (credentials.privateKeyPath != null) {
+    connectConfig.privateKey = readPrivateKey(label, credentials.privateKeyPath);
+  }
+  if (credentials.passphrase != null) {
+    connectConfig.passphrase = credentials.passphrase;
+  }
+  if (credentials.password != null) {
+    connectConfig.password = credentials.password;
+  }
+  if (connectConfig.privateKey == null && connectConfig.password == null) {
+    connectConfig.agent = resolveAgentPath();
   }
 }
 function toHostKeyFingerprint(hostKey) {
   const digest = crypto.createHash("sha256").update(hostKey).digest("base64").replace(/=+$/, "");
   return `SHA256:${digest}`;
 }
-function buildHostVerifier(profile, onHostKeySeen) {
+function buildHostVerifier(hop, onHostKeySeen) {
   return (hostKey) => {
     const fingerprint = toHostKeyFingerprint(hostKey);
     onHostKeySeen(fingerprint);
-    const _logger = $logger.child({ context: "hostVerifier", profile: profile.name, host: profile.host });
-    if (profile.hostKeyFingerprint == null) {
-      _logger.info("host key accepted unpinned; add hostKeyFingerprint to the profile to pin it", {
+    const _logger = $logger.child({ context: "hostVerifier", profile: hop.label, host: hop.host });
+    if (hop.pinnedFingerprint == null) {
+      _logger.info("host key accepted unpinned; pin the fingerprint in the profile to detect a changed key", {
         host_key_fingerprint: fingerprint
       });
       return true;
     }
-    if (profile.hostKeyFingerprint === fingerprint) {
+    if (hop.pinnedFingerprint === fingerprint) {
       _logger.debug("host key matches the pinned fingerprint");
       return true;
     }
     _logger.error(null, "host key does not match the pinned fingerprint", {
-      expected: profile.hostKeyFingerprint,
+      expected: hop.pinnedFingerprint,
       actual: fingerprint
     });
     return false;
@@ -1326,21 +1405,152 @@ function buildConnectConfig(profile, onHostKeySeen) {
     username: profile.username,
     readyTimeout: profile.policy.connectTimeoutMs,
     keepaliveInterval: KEEPALIVE_INTERVAL_MS,
-    hostVerifier: buildHostVerifier(profile, onHostKeySeen)
+    hostVerifier: buildHostVerifier(
+      { label: profile.name, host: profile.host, pinnedFingerprint: profile.hostKeyFingerprint },
+      onHostKeySeen
+    )
   };
-  if (profile.privateKeyPath != null) {
-    connectConfig.privateKey = readPrivateKey(profile, profile.privateKeyPath);
-  }
-  if (profile.passphrase != null) {
-    connectConfig.passphrase = profile.passphrase;
+  applyAuth(connectConfig, profile, profile.name);
+  return connectConfig;
+}
+function expandProxyCommand(template, hop) {
+  return template.replace(/%[hpr%]/g, (token) => {
+    if (token === "%h") {
+      return hop.host;
+    }
+    if (token === "%p") {
+      return String(hop.port);
+    }
+    if (token === "%r") {
+      return hop.username;
+    }
+    return "%";
+  });
+}
+function openProxyCommand(profile, hop) {
+  const command = expandProxyCommand(profile.proxyCommand ?? "", hop);
+  const _logger = $logger.child({ context: "openProxyCommand", profile: profile.name });
+  _logger.debug("starting the proxy command", { command });
+  const child = child_process.spawn(command, { shell: true, stdio: ["pipe", "pipe", "pipe"], windowsHide: true });
+  const stderrDecoder = new string_decoder.StringDecoder("utf8");
+  child.stderr.on("data", (chunk) => {
+    const text = stderrDecoder.write(chunk).trim();
+    if (text !== "") {
+      _logger.warn("proxy command stderr", { text });
+    }
+  });
+  child.on("exit", (code, signal) => {
+    _logger.debug("proxy command exited", { exit_code: code, signal });
+  });
+  const sock = stream.Duplex.from({ readable: child.stdout, writable: child.stdin });
+  sock.on("error", (error) => {
+    _logger.debug("proxy command stream error", { error_message: error.message });
+  });
+  child.on("error", (error) => {
+    sock.destroy(error);
+  });
+  let closed = false;
+  return {
+    sock,
+    close: () => {
+      if (closed == true) {
+        return;
+      }
+      closed = true;
+      if (child.exitCode != null || child.signalCode != null) {
+        return;
+      }
+      if (process.platform === "win32" && child.pid != null) {
+        const killer = child_process.spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+        killer.on("error", (error) => {
+          _logger.error(error, "failed to kill the proxy command's process tree");
+        });
+        return;
+      }
+      child.kill();
+    }
+  };
+}
+function openJumpTransport(profile, jump, proxy, onHostKeySeen) {
+  const label = `${profile.name} jump host`;
+  const endpoint = `${jump.username}@${jump.host}:${jump.port}`;
+  const _logger = $logger.child({ context: "openJumpTransport", profile: profile.name, jump_host: jump.host });
+  const jumpConfig = {
+    host: jump.host,
+    port: jump.port,
+    username: jump.username,
+    readyTimeout: profile.policy.connectTimeoutMs,
+    keepaliveInterval: KEEPALIVE_INTERVAL_MS,
+    hostVerifier: buildHostVerifier(
+      { label, host: jump.host, pinnedFingerprint: jump.hostKeyFingerprint },
+      onHostKeySeen
+    )
+  };
+  applyAuth(jumpConfig, jump, label);
+  if (proxy != null) {
+    jumpConfig.sock = proxy.sock;
+  }
+  return new Promise((resolve, reject) => {
+    const jumpClient = new Client();
+    let settled = false;
+    jumpClient.on("error", (error) => {
+      if (settled == false) {
+        settled = true;
+        jumpClient.destroy();
+        reject(new Error(`jump host ${endpoint}: ${error.message}`));
+        return;
+      }
+      _logger.error(error, "jump host connection error after ready");
+    });
+    jumpClient.on("close", () => {
+      _logger.debug("jump host connection closed");
+      proxy?.close();
+      if (settled == false) {
+        settled = true;
+        reject(new Error(`jump host ${endpoint}: connection closed before the handshake completed`));
+      }
+    });
+    jumpClient.once("ready", () => {
+      if (settled == true) {
+        return;
+      }
+      jumpClient.forwardOut("127.0.0.1", 0, profile.host, profile.port, (error, stream) => {
+        if (settled == true) {
+          return;
+        }
+        settled = true;
+        if (error != null) {
+          jumpClient.end();
+          reject(new Error(`jump host ${endpoint} refused the forward to ${profile.host}:${profile.port}: ${error.message}`));
+          return;
+        }
+        _logger.info("jump host connected, target channel forwarded");
+        resolve({
+          sock: stream,
+          close: () => {
+            jumpClient.end();
+          }
+        });
+      });
+    });
+    jumpClient.connect(jumpConfig);
+  });
+}
+async function openTransport(profile, onJumpHostKeySeen) {
+  let proxy = null;
+  if (profile.proxyCommand != null) {
+    proxy = openProxyCommand(profile, profile.jump ?? profile);
   }
-  if (profile.password != null) {
-    connectConfig.password = profile.password;
+  if (profile.jump == null) {
+    return proxy;
   }
-  if (connectConfig.privateKey == null && connectConfig.password == null) {
-    connectConfig.agent = resolveAgentPath();
+  try {
+    const jumpTransport = await openJumpTransport(profile, profile.jump, proxy, onJumpHostKeySeen);
+    return jumpTransport;
+  } catch (ex) {
+    proxy?.close();
+    throw ex;
   }
-  return connectConfig;
 }
 function buildRemoteCommand(command, cwd, trackCwd) {
   const lines = [];
@@ -1382,6 +1592,7 @@ var SshConnection = class {
     /** Set when the peer closed a previously established connection. */
     this.droppedAfterReady = false;
     this.observedFingerprint = null;
+    this.observedJumpFingerprint = null;
   }
   get isConnected() {
     return this.client != null;
@@ -1390,6 +1601,10 @@ var SshConnection = class {
   get hostKeyFingerprint() {
     return this.observedFingerprint;
   }
+  /** Host key the jump host presented; null without a jump host or before its handshake. */
+  get jumpHostKeyFingerprint() {
+    return this.observedJumpFingerprint;
+  }
   /** True when a connection was established and then lost, so shell state is gone. */
   get wasDropped() {
     return this.droppedAfterReady;
@@ -1397,8 +1612,11 @@ var SshConnection = class {
   /**
    * Opens the connection, or joins the in-flight attempt when one is already running.
    *
+   * With a proxy command or a jump host the carrier is opened first and handed to ssh2
+   * as the socket; it is torn down with the target connection, whichever side closes.
+   *
    * @throws {Error} If the connection was closed, authentication fails, the host is
-   *                 unreachable, or the handshake times out.
+   *                 unreachable, the handshake times out, or the carrier cannot be opened.
    */
   async connect() {
     if (this.disposed == true) {
@@ -1421,43 +1639,66 @@ var SshConnection = class {
     const connectConfig = buildConnectConfig(this.profile, (fingerprint) => {
       this.observedFingerprint = fingerprint;
     });
-    this.connecting = new Promise((resolve, reject) => {
-      const client = new Client();
-      this.pendingClient = client;
-      let settled = false;
-      client.on("error", (error) => {
-        if (settled == false) {
+    this.connecting = (async () => {
+      const transport = await openTransport(this.profile, (fingerprint) => {
+        this.observedJumpFingerprint = fingerprint;
+      });
+      if (this.disposed == true) {
+        transport?.close();
+        throw new Error(`ssh connection for '${this.profile.name}' was closed during the handshake`);
+      }
+      if (transport != null) {
+        connectConfig.sock = transport.sock;
+      }
+      await new Promise((resolve, reject) => {
+        const client = new Client();
+        this.pendingClient = client;
+        let settled = false;
+        client.on("error", (error) => {
+          if (settled == false) {
+            settled = true;
+            this.pendingClient = null;
+            client.destroy();
+            reject(error);
+            return;
+          }
+          if (this.client !== client) {
+            _logger.debug("ssh connection error during teardown", { error_message: error.message });
+            return;
+          }
+          _logger.error(error, "ssh connection error after ready");
+        });
+        client.on("close", () => {
+          transport?.close();
+          if (this.client === client) {
+            _logger.debug("ssh connection closed by the peer");
+            this.client = null;
+            this.droppedAfterReady = true;
+            return;
+          }
+          if (settled == false) {
+            settled = true;
+            this.pendingClient = null;
+            reject(new Error("connection closed before the handshake completed"));
+          }
+        });
+        client.once("ready", () => {
+          if (settled == true) {
+            return;
+          }
           settled = true;
           this.pendingClient = null;
-          client.destroy();
-          reject(error);
-          return;
-        }
-        _logger.error(error, "ssh connection error after ready");
-      });
-      client.on("close", () => {
-        if (this.client === client) {
-          _logger.debug("ssh connection closed by the peer");
-          this.client = null;
-          this.droppedAfterReady = true;
-        }
-      });
-      client.once("ready", () => {
-        if (settled == true) {
-          return;
-        }
-        settled = true;
-        this.pendingClient = null;
-        if (this.disposed == true) {
-          client.destroy();
-          reject(new Error(`ssh connection for '${this.profile.name}' was closed during the handshake`));
-          return;
-        }
-        this.client = client;
-        resolve();
+          if (this.disposed == true) {
+            client.destroy();
+            reject(new Error(`ssh connection for '${this.profile.name}' was closed during the handshake`));
+            return;
+          }
+          this.client = client;
+          resolve();
+        });
+        client.connect(connectConfig);
       });
-      client.connect(connectConfig);
-    });
+    })();
     try {
       await this.connecting;
       _logger.info("ssh connection established");
@@ -2145,6 +2386,16 @@ function formatHostProfile(profile) {
   if (summary.description != null) {
     lines.push(`    ${summary.description}`);
   }
+  const routeParts = [];
+  if (summary.viaProxyCommand == true) {
+    routeParts.push("proxy command");
+  }
+  if (summary.jump != null) {
+    routeParts.push(`jump host ${summary.jump.username}@${summary.jump.host}:${summary.jump.port}`);
+  }
+  if (routeParts.length > 0) {
+    lines.push(`    via ${routeParts.join(" \u2192 ")}`);
+  }
   if (summary.allowedPaths.length > 0) {
     lines.push(`    file tools limited to: ${summary.allowedPaths.join(", ")} (does not restrict ssh_exec)`);
   }